home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_296 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  5.4 KB  |  167 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import time
  5. import unittest
  6. from test_all import db, test_support, verbose, have_threads, get_new_environment_path, get_new_database_path
  7. if have_threads:
  8.     from threading import Thread
  9.     import sys
  10.     if sys.version_info[0] < 3:
  11.         from threading import currentThread
  12.     else:
  13.         from threading import current_thread as currentThread
  14.  
  15.  
  16. class LockingTestCase(unittest.TestCase):
  17.     import sys
  18.     if sys.version_info[:3] < (2, 4, 0):
  19.         
  20.         def assertTrue(self, expr, msg = None):
  21.             self.failUnless(expr, msg = msg)
  22.  
  23.     
  24.     
  25.     def setUp(self):
  26.         self.homeDir = get_new_environment_path()
  27.         self.env = db.DBEnv()
  28.         self.env.open(self.homeDir, db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_CREATE)
  29.  
  30.     
  31.     def tearDown(self):
  32.         self.env.close()
  33.         test_support.rmtree(self.homeDir)
  34.  
  35.     
  36.     def test01_simple(self):
  37.         if verbose:
  38.             print '\n', '-=' * 30
  39.             print 'Running %s.test01_simple...' % self.__class__.__name__
  40.         
  41.         anID = self.env.lock_id()
  42.         if verbose:
  43.             print 'locker ID: %s' % anID
  44.         
  45.         lock = self.env.lock_get(anID, 'some locked thing', db.DB_LOCK_WRITE)
  46.         if verbose:
  47.             print 'Aquired lock: %s' % lock
  48.         
  49.         self.env.lock_put(lock)
  50.         if verbose:
  51.             print 'Released lock: %s' % lock
  52.         
  53.         self.env.lock_id_free(anID)
  54.  
  55.     
  56.     def test02_threaded(self):
  57.         if verbose:
  58.             print '\n', '-=' * 30
  59.             print 'Running %s.test02_threaded...' % self.__class__.__name__
  60.         
  61.         threads = []
  62.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_WRITE,)))
  63.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_READ,)))
  64.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_READ,)))
  65.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_WRITE,)))
  66.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_READ,)))
  67.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_READ,)))
  68.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_WRITE,)))
  69.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_WRITE,)))
  70.         threads.append(Thread(target = self.theThread, args = (db.DB_LOCK_WRITE,)))
  71.         for t in threads:
  72.             import sys
  73.             if sys.version_info[0] < 3:
  74.                 t.setDaemon(True)
  75.             else:
  76.                 t.daemon = True
  77.             t.start()
  78.         
  79.         for t in threads:
  80.             t.join()
  81.         
  82.  
  83.     
  84.     def test03_lock_timeout(self):
  85.         self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT)
  86.         self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT)
  87.         self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT)
  88.         self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT)
  89.         
  90.         def deadlock_detection():
  91.             while not deadlock_detection.end:
  92.                 deadlock_detection.count = self.env.lock_detect(db.DB_LOCK_EXPIRE)
  93.                 if deadlock_detection.count:
  94.                     while not deadlock_detection.end:
  95.                         pass
  96.                     break
  97.                 
  98.                 time.sleep(0.01)
  99.  
  100.         deadlock_detection.end = False
  101.         deadlock_detection.count = 0
  102.         t = Thread(target = deadlock_detection)
  103.         import sys
  104.         if sys.version_info[0] < 3:
  105.             t.setDaemon(True)
  106.         else:
  107.             t.daemon = True
  108.         t.start()
  109.         self.env.set_timeout(100000, db.DB_SET_LOCK_TIMEOUT)
  110.         anID = self.env.lock_id()
  111.         anID2 = self.env.lock_id()
  112.         self.assertNotEqual(anID, anID2)
  113.         lock = self.env.lock_get(anID, 'shared lock', db.DB_LOCK_WRITE)
  114.         start_time = time.time()
  115.         self.assertRaises(db.DBLockNotGrantedError, self.env.lock_get, anID2, 'shared lock', db.DB_LOCK_READ)
  116.         end_time = time.time()
  117.         deadlock_detection.end = True
  118.         self.assertTrue(end_time - start_time >= 0.0999)
  119.         self.env.lock_put(lock)
  120.         t.join()
  121.         self.env.lock_id_free(anID)
  122.         self.env.lock_id_free(anID2)
  123.         if db.version() >= (4, 6):
  124.             self.assertTrue(deadlock_detection.count > 0)
  125.         
  126.  
  127.     
  128.     def theThread(self, lockType):
  129.         import sys
  130.         if sys.version_info[0] < 3:
  131.             name = currentThread().getName()
  132.         else:
  133.             name = currentThread().name
  134.         if lockType == db.DB_LOCK_WRITE:
  135.             lt = 'write'
  136.         else:
  137.             lt = 'read'
  138.         anID = self.env.lock_id()
  139.         if verbose:
  140.             print '%s: locker ID: %s' % (name, anID)
  141.         
  142.         for i in xrange(1000):
  143.             lock = self.env.lock_get(anID, 'some locked thing', lockType)
  144.             if verbose:
  145.                 print '%s: Aquired %s lock: %s' % (name, lt, lock)
  146.             
  147.             self.env.lock_put(lock)
  148.             if verbose:
  149.                 print '%s: Released %s lock: %s' % (name, lt, lock)
  150.                 continue
  151.         
  152.         self.env.lock_id_free(anID)
  153.  
  154.  
  155.  
  156. def test_suite():
  157.     suite = unittest.TestSuite()
  158.     if have_threads:
  159.         suite.addTest(unittest.makeSuite(LockingTestCase))
  160.     else:
  161.         suite.addTest(unittest.makeSuite(LockingTestCase, 'test01'))
  162.     return suite
  163.  
  164. if __name__ == '__main__':
  165.     unittest.main(defaultTest = 'test_suite')
  166.  
  167.