1 """

     2 Basic TestCases for BTree and hash DBs, with and without a DBEnv, with

     3 various DB flags, etc.

     4 """

     5 

     6 import os

     7 import errno

     8 import string

     9 from pprint import pprint

    10 import unittest

    11 import time

    12 

    13 from test_all import db, test_support, verbose, get_new_environment_path, \

    14         get_new_database_path

    15 

    16 DASH = '-'

    17 

    18 

    19 #----------------------------------------------------------------------

    20 

    21 class VersionTestCase(unittest.TestCase):

    22     def test00_version(self):

    23         info = db.version()

    24         if verbose:

    25             print '\n', '-=' * 20

    26             print 'bsddb.db.version(): %s' % (info, )

    27             print db.DB_VERSION_STRING

    28             print '-=' * 20

    29         self.assertEqual(info, (db.DB_VERSION_MAJOR, db.DB_VERSION_MINOR,

    30                         db.DB_VERSION_PATCH))

    31 

    32 #----------------------------------------------------------------------

    33 

    34 class BasicTestCase(unittest.TestCase):

    35     dbtype       = db.DB_UNKNOWN  # must be set in derived class

    36     dbopenflags  = 0

    37     dbsetflags   = 0

    38     dbmode       = 0660

    39     dbname       = None

    40     useEnv       = 0

    41     envflags     = 0

    42     envsetflags  = 0

    43 

    44     _numKeys      = 1002    # PRIVATE.  NOTE: must be an even value

    45 

    46     def setUp(self):

    47         if self.useEnv:

    48             self.homeDir=get_new_environment_path()

    49             try:

    50                 self.env = db.DBEnv()

    51                 self.env.set_lg_max(1024*1024)

    52                 self.env.set_tx_max(30)

    53                 self.env.set_tx_timestamp(int(time.time()))

    54                 self.env.set_flags(self.envsetflags, 1)

    55                 self.env.open(self.homeDir, self.envflags | db.DB_CREATE)

    56                 self.filename = "test"

    57             # Yes, a bare except is intended, since we're re-raising the exc.

    58             except:

    59                 test_support.rmtree(self.homeDir)

    60                 raise

    61         else:

    62             self.env = None

    63             self.filename = get_new_database_path()

    64 

    65         # create and open the DB

    66         self.d = db.DB(self.env)

    67         self.d.set_flags(self.dbsetflags)

    68         if self.dbname:

    69             self.d.open(self.filename, self.dbname, self.dbtype,

    70                         self.dbopenflags|db.DB_CREATE, self.dbmode)

    71         else:

    72             self.d.open(self.filename,   # try out keyword args

    73                         mode = self.dbmode,

    74                         dbtype = self.dbtype,

    75                         flags = self.dbopenflags|db.DB_CREATE)

    76 

    77         self.populateDB()

    78 

    79 

    80     def tearDown(self):

    81         self.d.close()

    82         if self.env is not None:

    83             self.env.close()

    84             test_support.rmtree(self.homeDir)

    85         else:

    86             os.remove(self.filename)

    87 

    88 

    89 

    90     def populateDB(self, _txn=None):

    91         d = self.d

    92 

    93         for x in range(self._numKeys//2):

    94             key = '%04d' % (self._numKeys - x)  # insert keys in reverse order

    95             data = self.makeData(key)

    96             d.put(key, data, _txn)

    97 

    98         d.put('empty value', '', _txn)

    99 

   100         for x in range(self._numKeys//2-1):

   101             key = '%04d' % x  # and now some in forward order

   102             data = self.makeData(key)

   103             d.put(key, data, _txn)

   104 

   105         if _txn:

   106             _txn.commit()

   107 

   108         num = len(d)

   109         if verbose:

   110             print "created %d records" % num

   111 

   112 

   113     def makeData(self, key):

   114         return DASH.join([key] * 5)

   115 

   116 

   117 

   118     #----------------------------------------

   119 

   120     def test01_GetsAndPuts(self):

   121         d = self.d

   122 

   123         if verbose:

   124             print '\n', '-=' * 30

   125             print "Running %s.test01_GetsAndPuts..." % self.__class__.__name__

   126 

   127         for key in ['0001', '0100', '0400', '0700', '0999']:

   128             data = d.get(key)

   129             if verbose:

   130                 print data

   131 

   132         self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')

   133 

   134         # By default non-existant keys return None...

   135         self.assertEqual(d.get('abcd'), None)

   136 

   137         # ...but they raise exceptions in other situations.  Call

   138         # set_get_returns_none() to change it.

   139         try:

   140             d.delete('abcd')

   141         except db.DBNotFoundError, val:

   142             import sys

   143             if sys.version_info[0] < 3 :

   144                 self.assertEqual(val[0], db.DB_NOTFOUND)

   145             else :

   146                 self.assertEqual(val.args[0], db.DB_NOTFOUND)

   147             if verbose: print val

   148         else:

   149             self.fail("expected exception")

   150 

   151 

   152         d.put('abcd', 'a new record')

   153         self.assertEqual(d.get('abcd'), 'a new record')

   154 

   155         d.put('abcd', 'same key')

   156         if self.dbsetflags & db.DB_DUP:

   157             self.assertEqual(d.get('abcd'), 'a new record')

   158         else:

   159             self.assertEqual(d.get('abcd'), 'same key')

   160 

   161 

   162         try:

   163             d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE)

   164         except db.DBKeyExistError, val:

   165             import sys

   166             if sys.version_info[0] < 3 :

   167                 self.assertEqual(val[0], db.DB_KEYEXIST)

   168             else :

   169                 self.assertEqual(val.args[0], db.DB_KEYEXIST)

   170             if verbose: print val

   171         else:

   172             self.fail("expected exception")

   173 

   174         if self.dbsetflags & db.DB_DUP:

   175             self.assertEqual(d.get('abcd'), 'a new record')

   176         else:

   177             self.assertEqual(d.get('abcd'), 'same key')

   178 

   179 

   180         d.sync()

   181         d.close()

   182         del d

   183 

   184         self.d = db.DB(self.env)

   185         if self.dbname:

   186             self.d.open(self.filename, self.dbname)

   187         else:

   188             self.d.open(self.filename)

   189         d = self.d

   190 

   191         self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')

   192         if self.dbsetflags & db.DB_DUP:

   193             self.assertEqual(d.get('abcd'), 'a new record')

   194         else:

   195             self.assertEqual(d.get('abcd'), 'same key')

   196 

   197         rec = d.get_both('0555', '0555-0555-0555-0555-0555')

   198         if verbose:

   199             print rec

   200 

   201         self.assertEqual(d.get_both('0555', 'bad data'), None)

   202 

   203         # test default value

   204         data = d.get('bad key', 'bad data')

   205         self.assertEqual(data, 'bad data')

   206 

   207         # any object can pass through

   208         data = d.get('bad key', self)

   209         self.assertEqual(data, self)

   210 

   211         s = d.stat()

   212         self.assertEqual(type(s), type({}))

   213         if verbose:

   214             print 'd.stat() returned this dictionary:'

   215             pprint(s)

   216 

   217 

   218     #----------------------------------------

   219 

   220     def test02_DictionaryMethods(self):

   221         d = self.d

   222 

   223         if verbose:

   224             print '\n', '-=' * 30

   225             print "Running %s.test02_DictionaryMethods..." % \

   226                   self.__class__.__name__

   227 

   228         for key in ['0002', '0101', '0401', '0701', '0998']:

   229             data = d[key]

   230             self.assertEqual(data, self.makeData(key))

   231             if verbose:

   232                 print data

   233 

   234         self.assertEqual(len(d), self._numKeys)

   235         keys = d.keys()

   236         self.assertEqual(len(keys), self._numKeys)

   237         self.assertEqual(type(keys), type([]))

   238 

   239         d['new record'] = 'a new record'

   240         self.assertEqual(len(d), self._numKeys+1)

   241         keys = d.keys()

   242         self.assertEqual(len(keys), self._numKeys+1)

   243 

   244         d['new record'] = 'a replacement record'

   245         self.assertEqual(len(d), self._numKeys+1)

   246         keys = d.keys()

   247         self.assertEqual(len(keys), self._numKeys+1)

   248 

   249         if verbose:

   250             print "the first 10 keys are:"

   251             pprint(keys[:10])

   252 

   253         self.assertEqual(d['new record'], 'a replacement record')

   254 

   255 # We check also the positional parameter

   256         self.assertEqual(d.has_key('0001', None), 1)

   257 # We check also the keyword parameter

   258         self.assertEqual(d.has_key('spam', txn=None), 0)

   259 

   260         items = d.items()

   261         self.assertEqual(len(items), self._numKeys+1)

   262         self.assertEqual(type(items), type([]))

   263         self.assertEqual(type(items[0]), type(()))

   264         self.assertEqual(len(items[0]), 2)

   265 

   266         if verbose:

   267             print "the first 10 items are:"

   268             pprint(items[:10])

   269 

   270         values = d.values()

   271         self.assertEqual(len(values), self._numKeys+1)

   272         self.assertEqual(type(values), type([]))

   273 

   274         if verbose:

   275             print "the first 10 values are:"

   276             pprint(values[:10])

   277 

   278 

   279 

   280     #----------------------------------------

   281 

   282     def test03_SimpleCursorStuff(self, get_raises_error=0, set_raises_error=0):

   283         if verbose:

   284             print '\n', '-=' * 30

   285             print "Running %s.test03_SimpleCursorStuff (get_error %s, set_error %s)..." % \

   286                   (self.__class__.__name__, get_raises_error, set_raises_error)

   287 

   288         if self.env and self.dbopenflags & db.DB_AUTO_COMMIT:

   289             txn = self.env.txn_begin()

   290         else:

   291             txn = None

   292         c = self.d.cursor(txn=txn)

   293 

   294         rec = c.first()

   295         count = 0

   296         while rec is not None:

   297             count = count + 1

   298             if verbose and count % 100 == 0:

   299                 print rec

   300             try:

   301                 rec = c.next()

   302             except db.DBNotFoundError, val:

   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: print val

   310                     rec = None

   311                 else:

   312                     self.fail("unexpected DBNotFoundError")

   313             self.assertEqual(c.get_current_size(), len(c.current()[1]),

   314                     "%s != len(%r)" % (c.get_current_size(), c.current()[1]))

   315 

   316         self.assertEqual(count, self._numKeys)

   317 

   318 

   319         rec = c.last()

   320         count = 0

   321         while rec is not None:

   322             count = count + 1

   323             if verbose and count % 100 == 0:

   324                 print rec

   325             try:

   326                 rec = c.prev()

   327             except db.DBNotFoundError, val:

   328                 if get_raises_error:

   329                     import sys

   330                     if sys.version_info[0] < 3 :

   331                         self.assertEqual(val[0], db.DB_NOTFOUND)

   332                     else :

   333                         self.assertEqual(val.args[0], db.DB_NOTFOUND)

   334                     if verbose: print val

   335                     rec = None

   336                 else:

   337                     self.fail("unexpected DBNotFoundError")

   338 

   339         self.assertEqual(count, self._numKeys)

   340 

   341         rec = c.set('0505')

   342         rec2 = c.current()

   343         self.assertEqual(rec, rec2)

   344         self.assertEqual(rec[0], '0505')

   345         self.assertEqual(rec[1], self.makeData('0505'))

   346         self.assertEqual(c.get_current_size(), len(rec[1]))

   347 

   348         # make sure we get empty values properly

   349         rec = c.set('empty value')

   350         self.assertEqual(rec[1], '')

   351         self.assertEqual(c.get_current_size(), 0)

   352 

   353         try:

   354             n = c.set('bad key')

   355         except db.DBNotFoundError, val:

   356             import sys

   357             if sys.version_info[0] < 3 :

   358                 self.assertEqual(val[0], db.DB_NOTFOUND)

   359             else :

   360                 self.assertEqual(val.args[0], db.DB_NOTFOUND)

   361             if verbose: print val

   362         else:

   363             if set_raises_error:

   364                 self.fail("expected exception")

   365             if n != None:

   366                 self.fail("expected None: %r" % (n,))

   367 

   368         rec = c.get_both('0404', self.makeData('0404'))

   369         self.assertEqual(rec, ('0404', self.makeData('0404')))

   370 

   371         try:

   372             n = c.get_both('0404', 'bad data')

   373         except db.DBNotFoundError, val:

   374             import sys

   375             if sys.version_info[0] < 3 :

   376                 self.assertEqual(val[0], db.DB_NOTFOUND)

   377             else :

   378                 self.assertEqual(val.args[0], db.DB_NOTFOUND)

   379             if verbose: print val

   380         else:

   381             if get_raises_error:

   382                 self.fail("expected exception")

   383             if n != None:

   384                 self.fail("expected None: %r" % (n,))

   385 

   386         if self.d.get_type() == db.DB_BTREE:

   387             rec = c.set_range('011')

   388             if verbose:

   389                 print "searched for '011', found: ", rec

   390 

   391             rec = c.set_range('011',dlen=0,doff=0)

   392             if verbose:

   393                 print "searched (partial) for '011', found: ", rec

   394             if rec[1] != '': self.fail('expected empty data portion')

   395 

   396             ev = c.set_range('empty value')

   397             if verbose:

   398                 print "search for 'empty value' returned", ev

   399             if ev[1] != '': self.fail('empty value lookup failed')

   400 

   401         c.set('0499')

   402         c.delete()

   403         try:

   404             rec = c.current()

   405         except db.DBKeyEmptyError, val:

   406             if get_raises_error:

   407                 import sys

   408                 if sys.version_info[0] < 3 :

   409                     self.assertEqual(val[0], db.DB_KEYEMPTY)

   410                 else :

   411                     self.assertEqual(val.args[0], db.DB_KEYEMPTY)

   412                 if verbose: print val

   413             else:

   414                 self.fail("unexpected DBKeyEmptyError")

   415         else:

   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 

   423         c2.put('', 'a new value', db.DB_CURRENT)

   424         self.assertEqual(c.current(), c2.current())

   425         self.assertEqual(c.current()[1], 'a new value')

   426 

   427         c2.put('', 'er', db.DB_CURRENT, dlen=0, doff=5)

   428         self.assertEqual(c2.current()[1], 'a newer value')

   429 

   430         c.close()

   431         c2.close()

   432         if txn:

   433             txn.commit()

   434 

   435         # time to abuse the closed cursors and hope we don't crash

   436         methods_to_test = {

   437             'current': (),

   438             'delete': (),

   439             'dup': (db.DB_POSITION,),

   440             'first': (),

   441             'get': (0,),

   442             'next': (),

   443             'prev': (),

   444             'last': (),

   445             'put':('', 'spam', db.DB_CURRENT),

   446             'set': ("0505",),

   447         }

   448         for method, args in methods_to_test.items():

   449             try:

   450                 if verbose:

   451                     print "attempting to use a closed cursor's %s method" % \

   452                           method

   453                 # a bug may cause a NULL pointer dereference...

   454                 apply(getattr(c, method), args)

   455             except db.DBError, val:

   456                 import sys

   457                 if sys.version_info[0] < 3 :

   458                     self.assertEqual(val[0], 0)

   459                 else :

   460                     self.assertEqual(val.args[0], 0)

   461                 if verbose: print val

   462             else:

   463                 self.fail("no exception raised when using a buggy cursor's"

   464                           "%s method" % method)

   465 

   466         #

   467         # free cursor referencing a closed database, it should not barf:

   468         #

   469         oldcursor = self.d.cursor(txn=txn)

   470         self.d.close()

   471 

   472         # this would originally cause a segfault when the cursor for a

   473         # closed database was cleaned up.  it should not anymore.

   474         # SF pybsddb bug id 667343

   475         del oldcursor

   476 

   477     def test03b_SimpleCursorWithoutGetReturnsNone0(self):

   478         # same test but raise exceptions instead of returning None

   479         if verbose:

   480             print '\n', '-=' * 30

   481             print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \

   482                   self.__class__.__name__

   483 

   484         old = self.d.set_get_returns_none(0)

   485         self.assertEqual(old, 2)

   486         self.test03_SimpleCursorStuff(get_raises_error=1, set_raises_error=1)

   487 

   488     def test03b_SimpleCursorWithGetReturnsNone1(self):

   489         # same test but raise exceptions instead of returning None

   490         if verbose:

   491             print '\n', '-=' * 30

   492             print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \

   493                   self.__class__.__name__

   494 

   495         old = self.d.set_get_returns_none(1)

   496         self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=1)

   497 

   498 

   499     def test03c_SimpleCursorGetReturnsNone2(self):

   500         # same test but raise exceptions instead of returning None

   501         if verbose:

   502             print '\n', '-=' * 30

   503             print "Running %s.test03c_SimpleCursorStuffWithoutSetReturnsNone..." % \

   504                   self.__class__.__name__

   505 

   506         old = self.d.set_get_returns_none(1)

   507         self.assertEqual(old, 2)

   508         old = self.d.set_get_returns_none(2)

   509         self.assertEqual(old, 1)

   510         self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=0)

   511 

   512     #----------------------------------------

   513 

   514     def test04_PartialGetAndPut(self):

   515         d = self.d

   516         if verbose:

   517             print '\n', '-=' * 30

   518             print "Running %s.test04_PartialGetAndPut..." % \

   519                   self.__class__.__name__

   520 

   521         key = "partialTest"

   522         data = "1" * 1000 + "2" * 1000

   523         d.put(key, data)

   524         self.assertEqual(d.get(key), data)

   525         self.assertEqual(d.get(key, dlen=20, doff=990),

   526                 ("1" * 10) + ("2" * 10))

   527 

   528         d.put("partialtest2", ("1" * 30000) + "robin" )

   529         self.assertEqual(d.get("partialtest2", dlen=5, doff=30000), "robin")

   530 

   531         # There seems to be a bug in DB here...  Commented out the test for

   532         # now.

   533         ##self.assertEqual(d.get("partialtest2", dlen=5, doff=30010), "")

   534 

   535         if self.dbsetflags != db.DB_DUP:

   536             # Partial put with duplicate records requires a cursor

   537             d.put(key, "0000", dlen=2000, doff=0)

   538             self.assertEqual(d.get(key), "0000")

   539 

   540             d.put(key, "1111", dlen=1, doff=2)

   541             self.assertEqual(d.get(key), "0011110")

   542 

   543     #----------------------------------------

   544 

   545     def test05_GetSize(self):

   546         d = self.d

   547         if verbose:

   548             print '\n', '-=' * 30

   549             print "Running %s.test05_GetSize..." % self.__class__.__name__

   550 

   551         for i in range(1, 50000, 500):

   552             key = "size%s" % i

   553             #print "before ", i,

   554             d.put(key, "1" * i)

   555             #print "after",

   556             self.assertEqual(d.get_size(key), i)

   557             #print "done"

   558 

   559     #----------------------------------------

   560 

   561     def test06_Truncate(self):

   562         d = self.d

   563         if verbose:

   564             print '\n', '-=' * 30

   565             print "Running %s.test99_Truncate..." % self.__class__.__name__

   566 

   567         d.put("abcde", "ABCDE");

   568         num = d.truncate()

   569         self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")

   570         num = d.truncate()

   571         self.assertEqual(num, 0,

   572                 "truncate on empty DB returned nonzero (%r)" % (num,))

   573 

   574     #----------------------------------------

   575 

   576     def test07_verify(self):

   577         # Verify bug solved in 4.7.3pre8

   578         self.d.close()

   579         d = db.DB(self.env)

   580         d.verify(self.filename)

   581 

   582 

   583     #----------------------------------------

   584 

   585 

   586 #----------------------------------------------------------------------

   587 

   588 

   589 class BasicBTreeTestCase(BasicTestCase):

   590     dbtype = db.DB_BTREE

   591 

   592 

   593 class BasicHashTestCase(BasicTestCase):

   594     dbtype = db.DB_HASH

   595 

   596 

   597 class BasicBTreeWithThreadFlagTestCase(BasicTestCase):

   598     dbtype = db.DB_BTREE

   599     dbopenflags = db.DB_THREAD

   600 

   601 

   602 class BasicHashWithThreadFlagTestCase(BasicTestCase):

   603     dbtype = db.DB_HASH

   604     dbopenflags = db.DB_THREAD

   605 

   606 

   607 class BasicWithEnvTestCase(BasicTestCase):

   608     dbopenflags = db.DB_THREAD

   609     useEnv = 1

   610     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK

   611 

   612     #----------------------------------------

   613 

   614     def test08_EnvRemoveAndRename(self):

   615         if not self.env:

   616             return

   617 

   618         if verbose:

   619             print '\n', '-=' * 30

   620             print "Running %s.test08_EnvRemoveAndRename..." % self.__class__.__name__

   621 

   622         # can't rename or remove an open DB

   623         self.d.close()

   624 

   625         newname = self.filename + '.renamed'

   626         self.env.dbrename(self.filename, None, newname)

   627         self.env.dbremove(newname)

   628 

   629     # dbremove and dbrename are in 4.1 and later

   630     if db.version() < (4,1):

   631         del test08_EnvRemoveAndRename

   632 

   633     #----------------------------------------

   634 

   635 class BasicBTreeWithEnvTestCase(BasicWithEnvTestCase):

   636     dbtype = db.DB_BTREE

   637 

   638 

   639 class BasicHashWithEnvTestCase(BasicWithEnvTestCase):

   640     dbtype = db.DB_HASH

   641 

   642 

   643 #----------------------------------------------------------------------

   644 

   645 class BasicTransactionTestCase(BasicTestCase):

   646     import sys

   647     if sys.version_info[:3] < (2, 4, 0):

   648         def assertTrue(self, expr, msg=None):

   649             self.failUnless(expr,msg=msg)

   650 

   651     dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT

   652     useEnv = 1

   653     envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK |

   654                 db.DB_INIT_TXN)

   655     envsetflags = db.DB_AUTO_COMMIT

   656 

   657 

   658     def tearDown(self):

   659         self.txn.commit()

   660         BasicTestCase.tearDown(self)

   661 

   662 

   663     def populateDB(self):

   664         txn = self.env.txn_begin()

   665         BasicTestCase.populateDB(self, _txn=txn)

   666 

   667         self.txn = self.env.txn_begin()

   668 

   669 

   670     def test06_Transactions(self):

   671         d = self.d

   672         if verbose:

   673             print '\n', '-=' * 30

   674             print "Running %s.test06_Transactions..." % self.__class__.__name__

   675 

   676         self.assertEqual(d.get('new rec', txn=self.txn), None)

   677         d.put('new rec', 'this is a new record', self.txn)

   678         self.assertEqual(d.get('new rec', txn=self.txn),

   679                 'this is a new record')

   680         self.txn.abort()

   681         self.assertEqual(d.get('new rec'), None)

   682 

   683         self.txn = self.env.txn_begin()

   684 

   685         self.assertEqual(d.get('new rec', txn=self.txn), None)

   686         d.put('new rec', 'this is a new record', self.txn)

   687         self.assertEqual(d.get('new rec', txn=self.txn),

   688                 'this is a new record')

   689         self.txn.commit()

   690         self.assertEqual(d.get('new rec'), 'this is a new record')

   691 

   692         self.txn = self.env.txn_begin()

   693         c = d.cursor(self.txn)

   694         rec = c.first()

   695         count = 0

   696         while rec is not None:

   697             count = count + 1

   698             if verbose and count % 100 == 0:

   699                 print rec

   700             rec = c.next()

   701         self.assertEqual(count, self._numKeys+1)

   702 

   703         c.close()                # Cursors *MUST* be closed before commit!

   704         self.txn.commit()

   705 

   706         # flush pending updates

   707         try:

   708             self.env.txn_checkpoint (0, 0, 0)

   709         except db.DBIncompleteError:

   710             pass

   711 

   712         statDict = self.env.log_stat(0);

   713         self.assert_(statDict.has_key('magic'))

   714         self.assert_(statDict.has_key('version'))

   715         self.assert_(statDict.has_key('cur_file'))

   716         self.assert_(statDict.has_key('region_nowait'))

   717 

   718         # must have at least one log file present:

   719         logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG)

   720         self.assertNotEqual(logs, None)

   721         for log in logs:

   722             if verbose:

   723                 print 'log file: ' + log

   724         if db.version() >= (4,2):

   725             logs = self.env.log_archive(db.DB_ARCH_REMOVE)

   726             self.assertTrue(not logs)

   727 

   728         self.txn = self.env.txn_begin()

   729 

   730     #----------------------------------------

   731 

   732     def test08_TxnTruncate(self):

   733         d = self.d

   734         if verbose:

   735             print '\n', '-=' * 30

   736             print "Running %s.test08_TxnTruncate..." % self.__class__.__name__

   737 

   738         d.put("abcde", "ABCDE");

   739         txn = self.env.txn_begin()

   740         num = d.truncate(txn)

   741         self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")

   742         num = d.truncate(txn)

   743         self.assertEqual(num, 0,

   744                 "truncate on empty DB returned nonzero (%r)" % (num,))

   745         txn.commit()

   746 

   747     #----------------------------------------

   748 

   749     def test09_TxnLateUse(self):

   750         txn = self.env.txn_begin()

   751         txn.abort()

   752         try:

   753             txn.abort()

   754         except db.DBError, e:

   755             pass

   756         else:

   757             raise RuntimeError, "DBTxn.abort() called after DB_TXN no longer valid w/o an exception"

   758 

   759         txn = self.env.txn_begin()

   760         txn.commit()

   761         try:

   762             txn.commit()

   763         except db.DBError, e:

   764             pass

   765         else:

   766             raise RuntimeError, "DBTxn.commit() called after DB_TXN no longer valid w/o an exception"

   767 

   768 

   769 class BTreeTransactionTestCase(BasicTransactionTestCase):

   770     dbtype = db.DB_BTREE

   771 

   772 class HashTransactionTestCase(BasicTransactionTestCase):

   773     dbtype = db.DB_HASH

   774 

   775 

   776 

   777 #----------------------------------------------------------------------

   778 

   779 class BTreeRecnoTestCase(BasicTestCase):

   780     dbtype     = db.DB_BTREE

   781     dbsetflags = db.DB_RECNUM

   782 

   783     def test08_RecnoInBTree(self):

   784         d = self.d

   785         if verbose:

   786             print '\n', '-=' * 30

   787             print "Running %s.test08_RecnoInBTree..." % self.__class__.__name__

   788 

   789         rec = d.get(200)

   790         self.assertEqual(type(rec), type(()))

   791         self.assertEqual(len(rec), 2)

   792         if verbose:

   793             print "Record #200 is ", rec

   794 

   795         c = d.cursor()

   796         c.set('0200')

   797         num = c.get_recno()

   798         self.assertEqual(type(num), type(1))

   799         if verbose:

   800             print "recno of d['0200'] is ", num

   801 

   802         rec = c.current()

   803         self.assertEqual(c.set_recno(num), rec)

   804 

   805         c.close()

   806 

   807 

   808 

   809 class BTreeRecnoWithThreadFlagTestCase(BTreeRecnoTestCase):

   810     dbopenflags = db.DB_THREAD

   811 

   812 #----------------------------------------------------------------------

   813 

   814 class BasicDUPTestCase(BasicTestCase):

   815     dbsetflags = db.DB_DUP

   816 

   817     def test09_DuplicateKeys(self):

   818         d = self.d

   819         if verbose:

   820             print '\n', '-=' * 30

   821             print "Running %s.test09_DuplicateKeys..." % \

   822                   self.__class__.__name__

   823 

   824         d.put("dup0", "before")

   825         for x in "The quick brown fox jumped over the lazy dog.".split():

   826             d.put("dup1", x)

   827         d.put("dup2", "after")

   828 

   829         data = d.get("dup1")

   830         self.assertEqual(data, "The")

   831         if verbose:

   832             print data

   833 

   834         c = d.cursor()

   835         rec = c.set("dup1")

   836         self.assertEqual(rec, ('dup1', 'The'))

   837 

   838         next_reg = c.next()

   839         self.assertEqual(next_reg, ('dup1', 'quick'))

   840 

   841         rec = c.set("dup1")

   842         count = c.count()

   843         self.assertEqual(count, 9)

   844 

   845         next_dup = c.next_dup()

   846         self.assertEqual(next_dup, ('dup1', 'quick'))

   847 

   848         rec = c.set('dup1')

   849         while rec is not None:

   850             if verbose:

   851                 print rec

   852             rec = c.next_dup()

   853 

   854         c.set('dup1')

   855         rec = c.next_nodup()

   856         self.assertNotEqual(rec[0], 'dup1')

   857         if verbose:

   858             print rec

   859 

   860         c.close()

   861 

   862 

   863 

   864 class BTreeDUPTestCase(BasicDUPTestCase):

   865     dbtype = db.DB_BTREE

   866 

   867 class HashDUPTestCase(BasicDUPTestCase):

   868     dbtype = db.DB_HASH

   869 

   870 class BTreeDUPWithThreadTestCase(BasicDUPTestCase):

   871     dbtype = db.DB_BTREE

   872     dbopenflags = db.DB_THREAD

   873 

   874 class HashDUPWithThreadTestCase(BasicDUPTestCase):

   875     dbtype = db.DB_HASH

   876     dbopenflags = db.DB_THREAD

   877 

   878 

   879 #----------------------------------------------------------------------

   880 

   881 class BasicMultiDBTestCase(BasicTestCase):

   882     dbname = 'first'

   883 

   884     def otherType(self):

   885         if self.dbtype == db.DB_BTREE:

   886             return db.DB_HASH

   887         else:

   888             return db.DB_BTREE

   889 

   890     def test10_MultiDB(self):

   891         d1 = self.d

   892         if verbose:

   893             print '\n', '-=' * 30

   894             print "Running %s.test10_MultiDB..." % self.__class__.__name__

   895 

   896         d2 = db.DB(self.env)

   897         d2.open(self.filename, "second", self.dbtype,

   898                 self.dbopenflags|db.DB_CREATE)

   899         d3 = db.DB(self.env)

   900         d3.open(self.filename, "third", self.otherType(),

   901                 self.dbopenflags|db.DB_CREATE)

   902 

   903         for x in "The quick brown fox jumped over the lazy dog".split():

   904             d2.put(x, self.makeData(x))

   905 

   906         for x in string.letters:

   907             d3.put(x, x*70)

   908 

   909         d1.sync()

   910         d2.sync()

   911         d3.sync()

   912         d1.close()

   913         d2.close()

   914         d3.close()

   915 

   916         self.d = d1 = d2 = d3 = None

   917 

   918         self.d = d1 = db.DB(self.env)

   919         d1.open(self.filename, self.dbname, flags = self.dbopenflags)

   920         d2 = db.DB(self.env)

   921         d2.open(self.filename, "second",  flags = self.dbopenflags)

   922         d3 = db.DB(self.env)

   923         d3.open(self.filename, "third", flags = self.dbopenflags)

   924 

   925         c1 = d1.cursor()

   926         c2 = d2.cursor()

   927         c3 = d3.cursor()

   928 

   929         count = 0

   930         rec = c1.first()

   931         while rec is not None:

   932             count = count + 1

   933             if verbose and (count % 50) == 0:

   934                 print rec

   935             rec = c1.next()

   936         self.assertEqual(count, self._numKeys)

   937 

   938         count = 0

   939         rec = c2.first()

   940         while rec is not None:

   941             count = count + 1

   942             if verbose:

   943                 print rec

   944             rec = c2.next()

   945         self.assertEqual(count, 9)

   946 

   947         count = 0

   948         rec = c3.first()

   949         while rec is not None:

   950             count = count + 1

   951             if verbose:

   952                 print rec

   953             rec = c3.next()

   954         self.assertEqual(count, len(string.letters))

   955 

   956 

   957         c1.close()

   958         c2.close()

   959         c3.close()

   960 

   961         d2.close()

   962         d3.close()

   963 

   964 

   965 

   966 # Strange things happen if you try to use Multiple DBs per file without a

   967 # DBEnv with MPOOL and LOCKing...

   968 

   969 class BTreeMultiDBTestCase(BasicMultiDBTestCase):

   970     dbtype = db.DB_BTREE

   971     dbopenflags = db.DB_THREAD

   972     useEnv = 1

   973     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK

   974 

   975 class HashMultiDBTestCase(BasicMultiDBTestCase):

   976     dbtype = db.DB_HASH

   977     dbopenflags = db.DB_THREAD

   978     useEnv = 1

   979     envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK

   980 

   981 

   982 class PrivateObject(unittest.TestCase) :

   983     import sys

   984     if sys.version_info[:3] < (2, 4, 0):

   985         def assertTrue(self, expr, msg=None):

   986             self.failUnless(expr,msg=msg)

   987 

   988     def tearDown(self) :

   989         del self.obj

   990 

   991     def test01_DefaultIsNone(self) :

   992         self.assertEqual(self.obj.get_private(), None)

   993 

   994     def test02_assignment(self) :

   995         a = "example of private object"

   996         self.obj.set_private(a)

   997         b = self.obj.get_private()

   998         self.assertTrue(a is b)  # Object identity

   999 

  1000     def test03_leak_assignment(self) :

  1001         import sys

  1002         a = "example of private object"

  1003         refcount = sys.getrefcount(a)

  1004         self.obj.set_private(a)

  1005         self.assertEqual(refcount+1, sys.getrefcount(a))

  1006         self.obj.set_private(None)

  1007         self.assertEqual(refcount, sys.getrefcount(a))

  1008 

  1009     def test04_leak_GC(self) :

  1010         import sys

  1011         a = "example of private object"

  1012         refcount = sys.getrefcount(a)

  1013         self.obj.set_private(a)

  1014         self.obj = None

  1015         self.assertEqual(refcount, sys.getrefcount(a))

  1016 

  1017 class DBEnvPrivateObject(PrivateObject) :

  1018     def setUp(self) :

  1019         self.obj = db.DBEnv()

  1020 

  1021 class DBPrivateObject(PrivateObject) :

  1022     def setUp(self) :

  1023         self.obj = db.DB()

  1024 

  1025 class CrashAndBurn(unittest.TestCase) :

  1026     import sys

  1027     if sys.version_info[:3] < (2, 4, 0):

  1028         def assertTrue(self, expr, msg=None):

  1029             self.failUnless(expr,msg=msg)

  1030 

  1031     #def test01_OpenCrash(self) :

  1032     #    # See http://bugs.python.org/issue3307

  1033     #    self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535)

  1034 

  1035     def test02_DBEnv_dealloc(self):

  1036         # http://bugs.python.org/issue3885

  1037         import gc

  1038         self.assertRaises(db.DBInvalidArgError, db.DBEnv, ~db.DB_RPCCLIENT)

  1039         gc.collect()

  1040 

  1041 

  1042 #----------------------------------------------------------------------

  1043 #----------------------------------------------------------------------

  1044 

  1045 def test_suite():

  1046     suite = unittest.TestSuite()

  1047 

  1048     suite.addTest(unittest.makeSuite(VersionTestCase))

  1049     suite.addTest(unittest.makeSuite(BasicBTreeTestCase))

  1050     suite.addTest(unittest.makeSuite(BasicHashTestCase))

  1051     suite.addTest(unittest.makeSuite(BasicBTreeWithThreadFlagTestCase))

  1052     suite.addTest(unittest.makeSuite(BasicHashWithThreadFlagTestCase))

  1053     suite.addTest(unittest.makeSuite(BasicBTreeWithEnvTestCase))

  1054     suite.addTest(unittest.makeSuite(BasicHashWithEnvTestCase))

  1055     suite.addTest(unittest.makeSuite(BTreeTransactionTestCase))

  1056     suite.addTest(unittest.makeSuite(HashTransactionTestCase))

  1057     suite.addTest(unittest.makeSuite(BTreeRecnoTestCase))

  1058     suite.addTest(unittest.makeSuite(BTreeRecnoWithThreadFlagTestCase))

  1059     suite.addTest(unittest.makeSuite(BTreeDUPTestCase))

  1060     suite.addTest(unittest.makeSuite(HashDUPTestCase))

  1061     suite.addTest(unittest.makeSuite(BTreeDUPWithThreadTestCase))

  1062     suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase))

  1063     suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase))

  1064     suite.addTest(unittest.makeSuite(HashMultiDBTestCase))

  1065     suite.addTest(unittest.makeSuite(DBEnvPrivateObject))

  1066     suite.addTest(unittest.makeSuite(DBPrivateObject))

  1067     suite.addTest(unittest.makeSuite(CrashAndBurn))

  1068 

  1069     return suite

  1070 

  1071 

  1072 if __name__ == '__main__':

  1073     unittest.main(defaultTest='test_suite')