home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_285 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  29.0 KB  |  1,012 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import errno
  6. import string
  7. from pprint import pprint
  8. import unittest
  9. import time
  10. from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path
  11. DASH = '-'
  12.  
  13. class VersionTestCase(unittest.TestCase):
  14.     
  15.     def test00_version(self):
  16.         info = db.version()
  17.         if verbose:
  18.             print '\n', '-=' * 20
  19.             print 'bsddb.db.version(): %s' % (info,)
  20.             print db.DB_VERSION_STRING
  21.             print '-=' * 20
  22.         
  23.         self.assertEqual(info, (db.DB_VERSION_MAJOR, db.DB_VERSION_MINOR, db.DB_VERSION_PATCH))
  24.  
  25.  
  26.  
  27. class BasicTestCase(unittest.TestCase):
  28.     dbtype = db.DB_UNKNOWN
  29.     dbopenflags = 0
  30.     dbsetflags = 0
  31.     dbmode = 432
  32.     dbname = None
  33.     useEnv = 0
  34.     envflags = 0
  35.     envsetflags = 0
  36.     _numKeys = 1002
  37.     
  38.     def setUp(self):
  39.         if self.useEnv:
  40.             self.homeDir = get_new_environment_path()
  41.             
  42.             try:
  43.                 self.env = db.DBEnv()
  44.                 self.env.set_lg_max(1048576)
  45.                 self.env.set_tx_max(30)
  46.                 self.env.set_tx_timestamp(int(time.time()))
  47.                 self.env.set_flags(self.envsetflags, 1)
  48.                 self.env.open(self.homeDir, self.envflags | db.DB_CREATE)
  49.                 self.filename = 'test'
  50.             test_support.rmtree(self.homeDir)
  51.             raise 
  52.  
  53.         else:
  54.             self.env = None
  55.             self.filename = get_new_database_path()
  56.         self.d = db.DB(self.env)
  57.         self.d.set_flags(self.dbsetflags)
  58.         if self.dbname:
  59.             self.d.open(self.filename, self.dbname, self.dbtype, self.dbopenflags | db.DB_CREATE, self.dbmode)
  60.         else:
  61.             self.d.open(self.filename, mode = self.dbmode, dbtype = self.dbtype, flags = self.dbopenflags | db.DB_CREATE)
  62.         self.populateDB()
  63.  
  64.     
  65.     def tearDown(self):
  66.         self.d.close()
  67.         if self.env is not None:
  68.             self.env.close()
  69.             test_support.rmtree(self.homeDir)
  70.         else:
  71.             os.remove(self.filename)
  72.  
  73.     
  74.     def populateDB(self, _txn = None):
  75.         d = self.d
  76.         for x in range(self._numKeys // 2):
  77.             key = '%04d' % (self._numKeys - x)
  78.             data = self.makeData(key)
  79.             d.put(key, data, _txn)
  80.         
  81.         d.put('empty value', '', _txn)
  82.         for x in range(self._numKeys // 2 - 1):
  83.             key = '%04d' % x
  84.             data = self.makeData(key)
  85.             d.put(key, data, _txn)
  86.         
  87.         if _txn:
  88.             _txn.commit()
  89.         
  90.         num = len(d)
  91.         if verbose:
  92.             print 'created %d records' % num
  93.         
  94.  
  95.     
  96.     def makeData(self, key):
  97.         return DASH.join([
  98.             key] * 5)
  99.  
  100.     
  101.     def test01_GetsAndPuts(self):
  102.         d = self.d
  103.         if verbose:
  104.             print '\n', '-=' * 30
  105.             print 'Running %s.test01_GetsAndPuts...' % self.__class__.__name__
  106.         
  107.         for key in [
  108.             '0001',
  109.             '0100',
  110.             '0400',
  111.             '0700',
  112.             '0999']:
  113.             data = d.get(key)
  114.             if verbose:
  115.                 print data
  116.                 continue
  117.         
  118.         self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')
  119.         self.assertEqual(d.get('abcd'), None)
  120.         
  121.         try:
  122.             d.delete('abcd')
  123.         except db.DBNotFoundError:
  124.             val = None
  125.             import sys
  126.             if sys.version_info[0] < 3:
  127.                 self.assertEqual(val[0], db.DB_NOTFOUND)
  128.             else:
  129.                 self.assertEqual(val.args[0], db.DB_NOTFOUND)
  130.             if verbose:
  131.                 print val
  132.             
  133.         except:
  134.             verbose
  135.  
  136.         self.fail('expected exception')
  137.         d.put('abcd', 'a new record')
  138.         self.assertEqual(d.get('abcd'), 'a new record')
  139.         d.put('abcd', 'same key')
  140.         if self.dbsetflags & db.DB_DUP:
  141.             self.assertEqual(d.get('abcd'), 'a new record')
  142.         else:
  143.             self.assertEqual(d.get('abcd'), 'same key')
  144.         
  145.         try:
  146.             d.put('abcd', 'this should fail', flags = db.DB_NOOVERWRITE)
  147.         except db.DBKeyExistError:
  148.             val = None
  149.             import sys
  150.             if sys.version_info[0] < 3:
  151.                 self.assertEqual(val[0], db.DB_KEYEXIST)
  152.             else:
  153.                 self.assertEqual(val.args[0], db.DB_KEYEXIST)
  154.             if verbose:
  155.                 print val
  156.             
  157.         except:
  158.             verbose
  159.  
  160.         self.fail('expected exception')
  161.         if self.dbsetflags & db.DB_DUP:
  162.             self.assertEqual(d.get('abcd'), 'a new record')
  163.         else:
  164.             self.assertEqual(d.get('abcd'), 'same key')
  165.         d.sync()
  166.         d.close()
  167.         del d
  168.         self.d = db.DB(self.env)
  169.         if self.dbname:
  170.             self.d.open(self.filename, self.dbname)
  171.         else:
  172.             self.d.open(self.filename)
  173.         d = self.d
  174.         self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')
  175.         if self.dbsetflags & db.DB_DUP:
  176.             self.assertEqual(d.get('abcd'), 'a new record')
  177.         else:
  178.             self.assertEqual(d.get('abcd'), 'same key')
  179.         rec = d.get_both('0555', '0555-0555-0555-0555-0555')
  180.         if verbose:
  181.             print rec
  182.         
  183.         self.assertEqual(d.get_both('0555', 'bad data'), None)
  184.         data = d.get('bad key', 'bad data')
  185.         self.assertEqual(data, 'bad data')
  186.         data = d.get('bad key', self)
  187.         self.assertEqual(data, self)
  188.         s = d.stat()
  189.         self.assertEqual(type(s), type({ }))
  190.         if verbose:
  191.             print 'd.stat() returned this dictionary:'
  192.             pprint(s)
  193.         
  194.  
  195.     
  196.     def test02_DictionaryMethods(self):
  197.         d = self.d
  198.         if verbose:
  199.             print '\n', '-=' * 30
  200.             print 'Running %s.test02_DictionaryMethods...' % self.__class__.__name__
  201.         
  202.         for key in [
  203.             '0002',
  204.             '0101',
  205.             '0401',
  206.             '0701',
  207.             '0998']:
  208.             data = d[key]
  209.             self.assertEqual(data, self.makeData(key))
  210.             if verbose:
  211.                 print data
  212.                 continue
  213.         
  214.         self.assertEqual(len(d), self._numKeys)
  215.         keys = d.keys()
  216.         self.assertEqual(len(keys), self._numKeys)
  217.         self.assertEqual(type(keys), type([]))
  218.         d['new record'] = 'a new record'
  219.         self.assertEqual(len(d), self._numKeys + 1)
  220.         keys = d.keys()
  221.         self.assertEqual(len(keys), self._numKeys + 1)
  222.         d['new record'] = 'a replacement record'
  223.         self.assertEqual(len(d), self._numKeys + 1)
  224.         keys = d.keys()
  225.         self.assertEqual(len(keys), self._numKeys + 1)
  226.         if verbose:
  227.             print 'the first 10 keys are:'
  228.             pprint(keys[:10])
  229.         
  230.         self.assertEqual(d['new record'], 'a replacement record')
  231.         self.assertEqual(d.has_key('0001', None), 1)
  232.         self.assertEqual(d.has_key('spam', txn = None), 0)
  233.         items = d.items()
  234.         self.assertEqual(len(items), self._numKeys + 1)
  235.         self.assertEqual(type(items), type([]))
  236.         self.assertEqual(type(items[0]), type(()))
  237.         self.assertEqual(len(items[0]), 2)
  238.         if verbose:
  239.             print 'the first 10 items are:'
  240.             pprint(items[:10])
  241.         
  242.         values = d.values()
  243.         self.assertEqual(len(values), self._numKeys + 1)
  244.         self.assertEqual(type(values), type([]))
  245.         if verbose:
  246.             print 'the first 10 values are:'
  247.             pprint(values[:10])
  248.         
  249.  
  250.     
  251.     def test03_SimpleCursorStuff(self, get_raises_error = 0, set_raises_error = 0):
  252.         if verbose:
  253.             print '\n', '-=' * 30
  254.             print 'Running %s.test03_SimpleCursorStuff (get_error %s, set_error %s)...' % (self.__class__.__name__, get_raises_error, set_raises_error)
  255.         
  256.         if self.env and self.dbopenflags & db.DB_AUTO_COMMIT:
  257.             txn = self.env.txn_begin()
  258.         else:
  259.             txn = None
  260.         c = self.d.cursor(txn = txn)
  261.         rec = c.first()
  262.         count = 0
  263.         while rec is not None:
  264.             count = count + 1
  265.             if verbose and count % 100 == 0:
  266.                 print rec
  267.             
  268.             
  269.             try:
  270.                 rec = c.next()
  271.             except db.DBNotFoundError:
  272.                 val = None
  273.                 if get_raises_error:
  274.                     import sys
  275.                     if sys.version_info[0] < 3:
  276.                         self.assertEqual(val[0], db.DB_NOTFOUND)
  277.                     else:
  278.                         self.assertEqual(val.args[0], db.DB_NOTFOUND)
  279.                     if verbose:
  280.                         print val
  281.                     
  282.                     rec = None
  283.                 else:
  284.                     self.fail('unexpected DBNotFoundError')
  285.             except:
  286.                 get_raises_error
  287.  
  288.             self.assertEqual(c.get_current_size(), len(c.current()[1]), '%s != len(%r)' % (c.get_current_size(), c.current()[1]))
  289.         self.assertEqual(count, self._numKeys)
  290.         rec = c.last()
  291.         count = 0
  292.         while rec is not None:
  293.             count = count + 1
  294.             if verbose and count % 100 == 0:
  295.                 print rec
  296.             
  297.             
  298.             try:
  299.                 rec = c.prev()
  300.             continue
  301.             except db.DBNotFoundError:
  302.                 val = None
  303.                 if get_raises_error:
  304.                     import sys
  305.                     if sys.version_info[0] < 3:
  306.                         self.assertEqual(val[0], db.DB_NOTFOUND)
  307.                     else:
  308.                         self.assertEqual(val.args[0], db.DB_NOTFOUND)
  309.                     if verbose:
  310.                         print val
  311.                     
  312.                     rec = None
  313.                 else:
  314.                     self.fail('unexpected DBNotFoundError')
  315.                 get_raises_error
  316.             
  317.  
  318.             None<EXCEPTION MATCH>db.DBNotFoundError
  319.         self.assertEqual(count, self._numKeys)
  320.         rec = c.set('0505')
  321.         rec2 = c.current()
  322.         self.assertEqual(rec, rec2)
  323.         self.assertEqual(rec[0], '0505')
  324.         self.assertEqual(rec[1], self.makeData('0505'))
  325.         self.assertEqual(c.get_current_size(), len(rec[1]))
  326.         rec = c.set('empty value')
  327.         self.assertEqual(rec[1], '')
  328.         self.assertEqual(c.get_current_size(), 0)
  329.         
  330.         try:
  331.             n = c.set('bad key')
  332.         except db.DBNotFoundError:
  333.             val = None
  334.             import sys
  335.             if sys.version_info[0] < 3:
  336.                 self.assertEqual(val[0], db.DB_NOTFOUND)
  337.             else:
  338.                 self.assertEqual(val.args[0], db.DB_NOTFOUND)
  339.             if verbose:
  340.                 print val
  341.             
  342.         except:
  343.             verbose
  344.  
  345.         if set_raises_error:
  346.             self.fail('expected exception')
  347.         
  348.         if n != None:
  349.             self.fail('expected None: %r' % (n,))
  350.         
  351.         rec = c.get_both('0404', self.makeData('0404'))
  352.         self.assertEqual(rec, ('0404', self.makeData('0404')))
  353.         
  354.         try:
  355.             n = c.get_both('0404', 'bad data')
  356.         except db.DBNotFoundError:
  357.             val = None
  358.             import sys
  359.             if sys.version_info[0] < 3:
  360.                 self.assertEqual(val[0], db.DB_NOTFOUND)
  361.             else:
  362.                 self.assertEqual(val.args[0], db.DB_NOTFOUND)
  363.             if verbose:
  364.                 print val
  365.             
  366.         except:
  367.             verbose
  368.  
  369.         if get_raises_error:
  370.             self.fail('expected exception')
  371.         
  372.         if n != None:
  373.             self.fail('expected None: %r' % (n,))
  374.         
  375.         if self.d.get_type() == db.DB_BTREE:
  376.             rec = c.set_range('011')
  377.             if verbose:
  378.                 print "searched for '011', found: ", rec
  379.             
  380.             rec = c.set_range('011', dlen = 0, doff = 0)
  381.             if verbose:
  382.                 print "searched (partial) for '011', found: ", rec
  383.             
  384.             if rec[1] != '':
  385.                 self.fail('expected empty data portion')
  386.             
  387.             ev = c.set_range('empty value')
  388.             if verbose:
  389.                 print "search for 'empty value' returned", ev
  390.             
  391.             if ev[1] != '':
  392.                 self.fail('empty value lookup failed')
  393.             
  394.         
  395.         c.set('0499')
  396.         c.delete()
  397.         
  398.         try:
  399.             rec = c.current()
  400.         except db.DBKeyEmptyError:
  401.             val = None
  402.             if get_raises_error:
  403.                 import sys
  404.                 if sys.version_info[0] < 3:
  405.                     self.assertEqual(val[0], db.DB_KEYEMPTY)
  406.                 else:
  407.                     self.assertEqual(val.args[0], db.DB_KEYEMPTY)
  408.                 if verbose:
  409.                     print val
  410.                 
  411.             else:
  412.                 self.fail('unexpected DBKeyEmptyError')
  413.         except:
  414.             get_raises_error
  415.  
  416.         if get_raises_error:
  417.             self.fail('DBKeyEmptyError exception expected')
  418.         
  419.         c.next()
  420.         c2 = c.dup(db.DB_POSITION)
  421.         self.assertEqual(c.current(), c2.current())
  422.         c2.put('', 'a new value', db.DB_CURRENT)
  423.         self.assertEqual(c.current(), c2.current())
  424.         self.assertEqual(c.current()[1], 'a new value')
  425.         c2.put('', 'er', db.DB_CURRENT, dlen = 0, doff = 5)
  426.         self.assertEqual(c2.current()[1], 'a newer value')
  427.         c.close()
  428.         c2.close()
  429.         if txn:
  430.             txn.commit()
  431.         
  432.         methods_to_test = {
  433.             'current': (),
  434.             'delete': (),
  435.             'dup': (db.DB_POSITION,),
  436.             'first': (),
  437.             'get': (0,),
  438.             'next': (),
  439.             'prev': (),
  440.             'last': (),
  441.             'put': ('', 'spam', db.DB_CURRENT),
  442.             'set': ('0505',) }
  443.         for method, args in methods_to_test.items():
  444.             
  445.             try:
  446.                 if verbose:
  447.                     print "attempting to use a closed cursor's %s method" % method
  448.                 
  449.                 apply(getattr(c, method), args)
  450.             except db.DBError:
  451.                 val = None
  452.                 import sys
  453.                 if sys.version_info[0] < 3:
  454.                     self.assertEqual(val[0], 0)
  455.                 else:
  456.                     self.assertEqual(val.args[0], 0)
  457.                 if verbose:
  458.                     print val
  459.                 
  460.                 verbose
  461.  
  462.             self.fail("no exception raised when using a buggy cursor's%s method" % method)
  463.         
  464.         oldcursor = self.d.cursor(txn = txn)
  465.         self.d.close()
  466.         del oldcursor
  467.  
  468.     
  469.     def test03b_SimpleCursorWithoutGetReturnsNone0(self):
  470.         if verbose:
  471.             print '\n', '-=' * 30
  472.             print 'Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone...' % self.__class__.__name__
  473.         
  474.         old = self.d.set_get_returns_none(0)
  475.         self.assertEqual(old, 2)
  476.         self.test03_SimpleCursorStuff(get_raises_error = 1, set_raises_error = 1)
  477.  
  478.     
  479.     def test03b_SimpleCursorWithGetReturnsNone1(self):
  480.         if verbose:
  481.             print '\n', '-=' * 30
  482.             print 'Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone...' % self.__class__.__name__
  483.         
  484.         old = self.d.set_get_returns_none(1)
  485.         self.test03_SimpleCursorStuff(get_raises_error = 0, set_raises_error = 1)
  486.  
  487.     
  488.     def test03c_SimpleCursorGetReturnsNone2(self):
  489.         if verbose:
  490.             print '\n', '-=' * 30
  491.             print 'Running %s.test03c_SimpleCursorStuffWithoutSetReturnsNone...' % self.__class__.__name__
  492.         
  493.         old = self.d.set_get_returns_none(1)
  494.         self.assertEqual(old, 2)
  495.         old = self.d.set_get_returns_none(2)
  496.         self.assertEqual(old, 1)
  497.         self.test03_SimpleCursorStuff(get_raises_error = 0, set_raises_error = 0)
  498.  
  499.     
  500.     def test04_PartialGetAndPut(self):
  501.         d = self.d
  502.         if verbose:
  503.             print '\n', '-=' * 30
  504.             print 'Running %s.test04_PartialGetAndPut...' % self.__class__.__name__
  505.         
  506.         key = 'partialTest'
  507.         data = '1' * 1000 + '2' * 1000
  508.         d.put(key, data)
  509.         self.assertEqual(d.get(key), data)
  510.         self.assertEqual(d.get(key, dlen = 20, doff = 990), '1111111111' + '2222222222')
  511.         d.put('partialtest2', '1' * 30000 + 'robin')
  512.         self.assertEqual(d.get('partialtest2', dlen = 5, doff = 30000), 'robin')
  513.         if self.dbsetflags != db.DB_DUP:
  514.             d.put(key, '0000', dlen = 2000, doff = 0)
  515.             self.assertEqual(d.get(key), '0000')
  516.             d.put(key, '1111', dlen = 1, doff = 2)
  517.             self.assertEqual(d.get(key), '0011110')
  518.         
  519.  
  520.     
  521.     def test05_GetSize(self):
  522.         d = self.d
  523.         if verbose:
  524.             print '\n', '-=' * 30
  525.             print 'Running %s.test05_GetSize...' % self.__class__.__name__
  526.         
  527.         for i in range(1, 50000, 500):
  528.             key = 'size%s' % i
  529.             d.put(key, '1' * i)
  530.             self.assertEqual(d.get_size(key), i)
  531.         
  532.  
  533.     
  534.     def test06_Truncate(self):
  535.         d = self.d
  536.         if verbose:
  537.             print '\n', '-=' * 30
  538.             print 'Running %s.test99_Truncate...' % self.__class__.__name__
  539.         
  540.         d.put('abcde', 'ABCDE')
  541.         num = d.truncate()
  542.         self.assert_(num >= 1, 'truncate returned <= 0 on non-empty database')
  543.         num = d.truncate()
  544.         self.assertEqual(num, 0, 'truncate on empty DB returned nonzero (%r)' % (num,))
  545.  
  546.     
  547.     def test07_verify(self):
  548.         self.d.close()
  549.         d = db.DB(self.env)
  550.         d.verify(self.filename)
  551.  
  552.  
  553.  
  554. class BasicBTreeTestCase(BasicTestCase):
  555.     dbtype = db.DB_BTREE
  556.  
  557.  
  558. class BasicHashTestCase(BasicTestCase):
  559.     dbtype = db.DB_HASH
  560.  
  561.  
  562. class BasicBTreeWithThreadFlagTestCase(BasicTestCase):
  563.     dbtype = db.DB_BTREE
  564.     dbopenflags = db.DB_THREAD
  565.  
  566.  
  567. class BasicHashWithThreadFlagTestCase(BasicTestCase):
  568.     dbtype = db.DB_HASH
  569.     dbopenflags = db.DB_THREAD
  570.  
  571.  
  572. class BasicWithEnvTestCase(BasicTestCase):
  573.     dbopenflags = db.DB_THREAD
  574.     useEnv = 1
  575.     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
  576.     
  577.     def test08_EnvRemoveAndRename(self):
  578.         if not self.env:
  579.             return None
  580.         self.d.close()
  581.         newname = self.filename + '.renamed'
  582.         self.env.dbrename(self.filename, None, newname)
  583.         self.env.dbremove(newname)
  584.  
  585.     if db.version() < (4, 1):
  586.         del test08_EnvRemoveAndRename
  587.     
  588.  
  589.  
  590. class BasicBTreeWithEnvTestCase(BasicWithEnvTestCase):
  591.     dbtype = db.DB_BTREE
  592.  
  593.  
  594. class BasicHashWithEnvTestCase(BasicWithEnvTestCase):
  595.     dbtype = db.DB_HASH
  596.  
  597.  
  598. class BasicTransactionTestCase(BasicTestCase):
  599.     import sys
  600.     if sys.version_info[:3] < (2, 4, 0):
  601.         
  602.         def assertTrue(self, expr, msg = None):
  603.             self.failUnless(expr, msg = msg)
  604.  
  605.     
  606.     dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT
  607.     useEnv = 1
  608.     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_TXN
  609.     envsetflags = db.DB_AUTO_COMMIT
  610.     
  611.     def tearDown(self):
  612.         self.txn.commit()
  613.         BasicTestCase.tearDown(self)
  614.  
  615.     
  616.     def populateDB(self):
  617.         txn = self.env.txn_begin()
  618.         BasicTestCase.populateDB(self, _txn = txn)
  619.         self.txn = self.env.txn_begin()
  620.  
  621.     
  622.     def test06_Transactions(self):
  623.         d = self.d
  624.         if verbose:
  625.             print '\n', '-=' * 30
  626.             print 'Running %s.test06_Transactions...' % self.__class__.__name__
  627.         
  628.         self.assertEqual(d.get('new rec', txn = self.txn), None)
  629.         d.put('new rec', 'this is a new record', self.txn)
  630.         self.assertEqual(d.get('new rec', txn = self.txn), 'this is a new record')
  631.         self.txn.abort()
  632.         self.assertEqual(d.get('new rec'), None)
  633.         self.txn = self.env.txn_begin()
  634.         self.assertEqual(d.get('new rec', txn = self.txn), None)
  635.         d.put('new rec', 'this is a new record', self.txn)
  636.         self.assertEqual(d.get('new rec', txn = self.txn), 'this is a new record')
  637.         self.txn.commit()
  638.         self.assertEqual(d.get('new rec'), 'this is a new record')
  639.         self.txn = self.env.txn_begin()
  640.         c = d.cursor(self.txn)
  641.         rec = c.first()
  642.         count = 0
  643.         while rec is not None:
  644.             count = count + 1
  645.             if verbose and count % 100 == 0:
  646.                 print rec
  647.             
  648.             rec = c.next()
  649.         self.assertEqual(count, self._numKeys + 1)
  650.         c.close()
  651.         self.txn.commit()
  652.         
  653.         try:
  654.             self.env.txn_checkpoint(0, 0, 0)
  655.         except db.DBIncompleteError:
  656.             pass
  657.  
  658.         statDict = self.env.log_stat(0)
  659.         self.assert_(statDict.has_key('magic'))
  660.         self.assert_(statDict.has_key('version'))
  661.         self.assert_(statDict.has_key('cur_file'))
  662.         self.assert_(statDict.has_key('region_nowait'))
  663.         logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG)
  664.         self.assertNotEqual(logs, None)
  665.         for log in logs:
  666.             if verbose:
  667.                 print 'log file: ' + log
  668.                 continue
  669.         
  670.         if db.version() >= (4, 2):
  671.             logs = self.env.log_archive(db.DB_ARCH_REMOVE)
  672.             self.assertTrue(not logs)
  673.         
  674.         self.txn = self.env.txn_begin()
  675.  
  676.     
  677.     def test08_TxnTruncate(self):
  678.         d = self.d
  679.         if verbose:
  680.             print '\n', '-=' * 30
  681.             print 'Running %s.test08_TxnTruncate...' % self.__class__.__name__
  682.         
  683.         d.put('abcde', 'ABCDE')
  684.         txn = self.env.txn_begin()
  685.         num = d.truncate(txn)
  686.         self.assert_(num >= 1, 'truncate returned <= 0 on non-empty database')
  687.         num = d.truncate(txn)
  688.         self.assertEqual(num, 0, 'truncate on empty DB returned nonzero (%r)' % (num,))
  689.         txn.commit()
  690.  
  691.     
  692.     def test09_TxnLateUse(self):
  693.         txn = self.env.txn_begin()
  694.         txn.abort()
  695.         
  696.         try:
  697.             txn.abort()
  698.         except db.DBError:
  699.             e = None
  700.  
  701.         raise RuntimeError, 'DBTxn.abort() called after DB_TXN no longer valid w/o an exception'
  702.         txn = self.env.txn_begin()
  703.         txn.commit()
  704.         
  705.         try:
  706.             txn.commit()
  707.         except db.DBError:
  708.             e = None
  709.  
  710.         raise RuntimeError, 'DBTxn.commit() called after DB_TXN no longer valid w/o an exception'
  711.  
  712.  
  713.  
  714. class BTreeTransactionTestCase(BasicTransactionTestCase):
  715.     dbtype = db.DB_BTREE
  716.  
  717.  
  718. class HashTransactionTestCase(BasicTransactionTestCase):
  719.     dbtype = db.DB_HASH
  720.  
  721.  
  722. class BTreeRecnoTestCase(BasicTestCase):
  723.     dbtype = db.DB_BTREE
  724.     dbsetflags = db.DB_RECNUM
  725.     
  726.     def test08_RecnoInBTree(self):
  727.         d = self.d
  728.         if verbose:
  729.             print '\n', '-=' * 30
  730.             print 'Running %s.test08_RecnoInBTree...' % self.__class__.__name__
  731.         
  732.         rec = d.get(200)
  733.         self.assertEqual(type(rec), type(()))
  734.         self.assertEqual(len(rec), 2)
  735.         if verbose:
  736.             print 'Record #200 is ', rec
  737.         
  738.         c = d.cursor()
  739.         c.set('0200')
  740.         num = c.get_recno()
  741.         self.assertEqual(type(num), type(1))
  742.         if verbose:
  743.             print "recno of d['0200'] is ", num
  744.         
  745.         rec = c.current()
  746.         self.assertEqual(c.set_recno(num), rec)
  747.         c.close()
  748.  
  749.  
  750.  
  751. class BTreeRecnoWithThreadFlagTestCase(BTreeRecnoTestCase):
  752.     dbopenflags = db.DB_THREAD
  753.  
  754.  
  755. class BasicDUPTestCase(BasicTestCase):
  756.     dbsetflags = db.DB_DUP
  757.     
  758.     def test09_DuplicateKeys(self):
  759.         d = self.d
  760.         if verbose:
  761.             print '\n', '-=' * 30
  762.             print 'Running %s.test09_DuplicateKeys...' % self.__class__.__name__
  763.         
  764.         d.put('dup0', 'before')
  765.         for x in 'The quick brown fox jumped over the lazy dog.'.split():
  766.             d.put('dup1', x)
  767.         
  768.         d.put('dup2', 'after')
  769.         data = d.get('dup1')
  770.         self.assertEqual(data, 'The')
  771.         if verbose:
  772.             print data
  773.         
  774.         c = d.cursor()
  775.         rec = c.set('dup1')
  776.         self.assertEqual(rec, ('dup1', 'The'))
  777.         next_reg = c.next()
  778.         self.assertEqual(next_reg, ('dup1', 'quick'))
  779.         rec = c.set('dup1')
  780.         count = c.count()
  781.         self.assertEqual(count, 9)
  782.         next_dup = c.next_dup()
  783.         self.assertEqual(next_dup, ('dup1', 'quick'))
  784.         rec = c.set('dup1')
  785.         while rec is not None:
  786.             if verbose:
  787.                 print rec
  788.             
  789.             rec = c.next_dup()
  790.         c.set('dup1')
  791.         rec = c.next_nodup()
  792.         self.assertNotEqual(rec[0], 'dup1')
  793.         if verbose:
  794.             print rec
  795.         
  796.         c.close()
  797.  
  798.  
  799.  
  800. class BTreeDUPTestCase(BasicDUPTestCase):
  801.     dbtype = db.DB_BTREE
  802.  
  803.  
  804. class HashDUPTestCase(BasicDUPTestCase):
  805.     dbtype = db.DB_HASH
  806.  
  807.  
  808. class BTreeDUPWithThreadTestCase(BasicDUPTestCase):
  809.     dbtype = db.DB_BTREE
  810.     dbopenflags = db.DB_THREAD
  811.  
  812.  
  813. class HashDUPWithThreadTestCase(BasicDUPTestCase):
  814.     dbtype = db.DB_HASH
  815.     dbopenflags = db.DB_THREAD
  816.  
  817.  
  818. class BasicMultiDBTestCase(BasicTestCase):
  819.     dbname = 'first'
  820.     
  821.     def otherType(self):
  822.         if self.dbtype == db.DB_BTREE:
  823.             return db.DB_HASH
  824.         return db.DB_BTREE
  825.  
  826.     
  827.     def test10_MultiDB(self):
  828.         d1 = self.d
  829.         if verbose:
  830.             print '\n', '-=' * 30
  831.             print 'Running %s.test10_MultiDB...' % self.__class__.__name__
  832.         
  833.         d2 = db.DB(self.env)
  834.         d2.open(self.filename, 'second', self.dbtype, self.dbopenflags | db.DB_CREATE)
  835.         d3 = db.DB(self.env)
  836.         d3.open(self.filename, 'third', self.otherType(), self.dbopenflags | db.DB_CREATE)
  837.         for x in 'The quick brown fox jumped over the lazy dog'.split():
  838.             d2.put(x, self.makeData(x))
  839.         
  840.         for x in string.letters:
  841.             d3.put(x, x * 70)
  842.         
  843.         d1.sync()
  844.         d2.sync()
  845.         d3.sync()
  846.         d1.close()
  847.         d2.close()
  848.         d3.close()
  849.         self.d = None
  850.         d1 = None
  851.         d2 = None
  852.         d3 = None
  853.         self.d = d1 = db.DB(self.env)
  854.         d1.open(self.filename, self.dbname, flags = self.dbopenflags)
  855.         d2 = db.DB(self.env)
  856.         d2.open(self.filename, 'second', flags = self.dbopenflags)
  857.         d3 = db.DB(self.env)
  858.         d3.open(self.filename, 'third', flags = self.dbopenflags)
  859.         c1 = d1.cursor()
  860.         c2 = d2.cursor()
  861.         c3 = d3.cursor()
  862.         count = 0
  863.         rec = c1.first()
  864.         while rec is not None:
  865.             count = count + 1
  866.             if verbose and count % 50 == 0:
  867.                 print rec
  868.             
  869.             rec = c1.next()
  870.         self.assertEqual(count, self._numKeys)
  871.         count = 0
  872.         rec = c2.first()
  873.         while rec is not None:
  874.             count = count + 1
  875.             if verbose:
  876.                 print rec
  877.             
  878.             rec = c2.next()
  879.         self.assertEqual(count, 9)
  880.         count = 0
  881.         rec = c3.first()
  882.         while rec is not None:
  883.             count = count + 1
  884.             if verbose:
  885.                 print rec
  886.             
  887.             rec = c3.next()
  888.         self.assertEqual(count, len(string.letters))
  889.         c1.close()
  890.         c2.close()
  891.         c3.close()
  892.         d2.close()
  893.         d3.close()
  894.  
  895.  
  896.  
  897. class BTreeMultiDBTestCase(BasicMultiDBTestCase):
  898.     dbtype = db.DB_BTREE
  899.     dbopenflags = db.DB_THREAD
  900.     useEnv = 1
  901.     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
  902.  
  903.  
  904. class HashMultiDBTestCase(BasicMultiDBTestCase):
  905.     dbtype = db.DB_HASH
  906.     dbopenflags = db.DB_THREAD
  907.     useEnv = 1
  908.     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
  909.  
  910.  
  911. class PrivateObject(unittest.TestCase):
  912.     import sys
  913.     if sys.version_info[:3] < (2, 4, 0):
  914.         
  915.         def assertTrue(self, expr, msg = None):
  916.             self.failUnless(expr, msg = msg)
  917.  
  918.     
  919.     
  920.     def tearDown(self):
  921.         del self.obj
  922.  
  923.     
  924.     def test01_DefaultIsNone(self):
  925.         self.assertEqual(self.obj.get_private(), None)
  926.  
  927.     
  928.     def test02_assignment(self):
  929.         a = 'example of private object'
  930.         self.obj.set_private(a)
  931.         b = self.obj.get_private()
  932.         self.assertTrue(a is b)
  933.  
  934.     
  935.     def test03_leak_assignment(self):
  936.         import sys
  937.         a = 'example of private object'
  938.         refcount = sys.getrefcount(a)
  939.         self.obj.set_private(a)
  940.         self.assertEqual(refcount + 1, sys.getrefcount(a))
  941.         self.obj.set_private(None)
  942.         self.assertEqual(refcount, sys.getrefcount(a))
  943.  
  944.     
  945.     def test04_leak_GC(self):
  946.         import sys
  947.         a = 'example of private object'
  948.         refcount = sys.getrefcount(a)
  949.         self.obj.set_private(a)
  950.         self.obj = None
  951.         self.assertEqual(refcount, sys.getrefcount(a))
  952.  
  953.  
  954.  
  955. class DBEnvPrivateObject(PrivateObject):
  956.     
  957.     def setUp(self):
  958.         self.obj = db.DBEnv()
  959.  
  960.  
  961.  
  962. class DBPrivateObject(PrivateObject):
  963.     
  964.     def setUp(self):
  965.         self.obj = db.DB()
  966.  
  967.  
  968.  
  969. class CrashAndBurn(unittest.TestCase):
  970.     import sys
  971.     if sys.version_info[:3] < (2, 4, 0):
  972.         
  973.         def assertTrue(self, expr, msg = None):
  974.             self.failUnless(expr, msg = msg)
  975.  
  976.     
  977.     
  978.     def test02_DBEnv_dealloc(self):
  979.         import gc
  980.         self.assertRaises(db.DBInvalidArgError, db.DBEnv, ~(db.DB_RPCCLIENT))
  981.         gc.collect()
  982.  
  983.  
  984.  
  985. def test_suite():
  986.     suite = unittest.TestSuite()
  987.     suite.addTest(unittest.makeSuite(VersionTestCase))
  988.     suite.addTest(unittest.makeSuite(BasicBTreeTestCase))
  989.     suite.addTest(unittest.makeSuite(BasicHashTestCase))
  990.     suite.addTest(unittest.makeSuite(BasicBTreeWithThreadFlagTestCase))
  991.     suite.addTest(unittest.makeSuite(BasicHashWithThreadFlagTestCase))
  992.     suite.addTest(unittest.makeSuite(BasicBTreeWithEnvTestCase))
  993.     suite.addTest(unittest.makeSuite(BasicHashWithEnvTestCase))
  994.     suite.addTest(unittest.makeSuite(BTreeTransactionTestCase))
  995.     suite.addTest(unittest.makeSuite(HashTransactionTestCase))
  996.     suite.addTest(unittest.makeSuite(BTreeRecnoTestCase))
  997.     suite.addTest(unittest.makeSuite(BTreeRecnoWithThreadFlagTestCase))
  998.     suite.addTest(unittest.makeSuite(BTreeDUPTestCase))
  999.     suite.addTest(unittest.makeSuite(HashDUPTestCase))
  1000.     suite.addTest(unittest.makeSuite(BTreeDUPWithThreadTestCase))
  1001.     suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase))
  1002.     suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase))
  1003.     suite.addTest(unittest.makeSuite(HashMultiDBTestCase))
  1004.     suite.addTest(unittest.makeSuite(DBEnvPrivateObject))
  1005.     suite.addTest(unittest.makeSuite(DBPrivateObject))
  1006.     suite.addTest(unittest.makeSuite(CrashAndBurn))
  1007.     return suite
  1008.  
  1009. if __name__ == '__main__':
  1010.     unittest.main(defaultTest = 'test_suite')
  1011.  
  1012.