Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
22 edited
3 copied

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/bsddb/test/test_all.py

    r2 r391  
    1616    charset = "iso8859-1"  # Full 8 bit
    1717
     18    class logcursor_py3k(object) :
     19        def __init__(self, env) :
     20            self._logcursor = env.log_cursor()
     21
     22        def __getattr__(self, v) :
     23            return getattr(self._logcursor, v)
     24
     25        def __next__(self) :
     26            v = getattr(self._logcursor, "next")()
     27            if v is not None :
     28                v = (v[0], v[1].decode(charset))
     29            return v
     30
     31        next = __next__
     32
     33        def first(self) :
     34            v = self._logcursor.first()
     35            if v is not None :
     36                v = (v[0], v[1].decode(charset))
     37            return v
     38
     39        def last(self) :
     40            v = self._logcursor.last()
     41            if v is not None :
     42                v = (v[0], v[1].decode(charset))
     43            return v
     44
     45        def prev(self) :
     46            v = self._logcursor.prev()
     47            if v is not None :
     48                v = (v[0], v[1].decode(charset))
     49            return v
     50
     51        def current(self) :
     52            v = self._logcursor.current()
     53            if v is not None :
     54                v = (v[0], v[1].decode(charset))
     55            return v
     56
     57        def set(self, lsn) :
     58            v = self._logcursor.set(lsn)
     59            if v is not None :
     60                v = (v[0], v[1].decode(charset))
     61            return v
     62
    1863    class cursor_py3k(object) :
    1964        def __init__(self, db, *args, **kwargs) :
    … …  
    2469
    2570        def _fix(self, v) :
    26             if v == None : return None
     71            if v is None : return None
    2772            key, value = v
    2873            if isinstance(key, bytes) :
    … …  
    72117            return self._fix(v)
    73118
    74         def put(self, key, value, flags=0, dlen=-1, doff=-1) :
    75             if isinstance(key, str) :
    76                 key = bytes(key, charset)
    77             if isinstance(value, str) :
    78                 value = bytes(value, charset)
    79             return self._dbcursor.put(key, value, flags=flags, dlen=dlen,
     119        def put(self, key, data, flags=0, dlen=-1, doff=-1) :
     120            if isinstance(key, str) :
     121                key = bytes(key, charset)
     122            if isinstance(data, str) :
     123                value = bytes(data, charset)
     124            return self._dbcursor.put(key, data, flags=flags, dlen=dlen,
    80125                    doff=doff)
    81126
    … …  
    91136            # Incorrect because key can be a bare number,
    92137            # but enough to pass testsuite
    93             if isinstance(key, int) and (data==None) and (flags==0) :
     138            if isinstance(key, int) and (data is None) and (flags == 0) :
    94139                flags = key
    95140                key = None
    … …  
    102147                data = bytes(data, charset)
    103148            v=self._dbcursor.pget(key=key, data=data, flags=flags)
    104             if v != None :
     149            if v is not None :
    105150                v1, v2, v3 = v
    106151                if isinstance(v1, bytes) :
    … …  
    115160        def join_item(self) :
    116161            v = self._dbcursor.join_item()
    117             if v != None :
     162            if v is not None :
    118163                v = v.decode(charset)
    119164            return v
    … …  
    135180
    136181            v = self._dbcursor.get(*args, **kwargs)
    137             if v != None :
     182            if v is not None :
    138183                k, v = v
    139184                if isinstance(k, bytes) :
    … …  
    177222                k = bytes(k, charset)
    178223            v = self._db[k]
    179             if v != None :
     224            if v is not None :
    180225                v = v.decode(charset)
    181226            return v
    … …  
    204249            return self._db.has_key(k, txn=txn)
    205250
    206         def put(self, key, value, txn=None, flags=0, dlen=-1, doff=-1) :
    207             if isinstance(key, str) :
    208                 key = bytes(key, charset)
    209             if isinstance(value, str) :
    210                 value = bytes(value, charset)
    211             return self._db.put(key, value, flags=flags, txn=txn, dlen=dlen,
     251        def set_re_delim(self, c) :
     252            if isinstance(c, str) :  # We can use a numeric value byte too
     253                c = bytes(c, charset)
     254            return self._db.set_re_delim(c)
     255
     256        def set_re_pad(self, c) :
     257            if isinstance(c, str) :  # We can use a numeric value byte too
     258                c = bytes(c, charset)
     259            return self._db.set_re_pad(c)
     260
     261        def get_re_source(self) :
     262            source = self._db.get_re_source()
     263            return source.decode(charset)
     264
     265        def put(self, key, data, txn=None, flags=0, dlen=-1, doff=-1) :
     266            if isinstance(key, str) :
     267                key = bytes(key, charset)
     268            if isinstance(data, str) :
     269                value = bytes(data, charset)
     270            return self._db.put(key, data, flags=flags, txn=txn, dlen=dlen,
    212271                    doff=doff)
    213272
    … …  
    221280                key = bytes(key, charset)
    222281            return self._db.get_size(key)
     282
     283        def exists(self, key, *args, **kwargs) :
     284            if isinstance(key, str) :
     285                key = bytes(key, charset)
     286            return self._db.exists(key, *args, **kwargs)
    223287
    224288        def get(self, key, default="MagicCookie", txn=None, flags=0, dlen=-1, doff=-1) :
    … …  
    231295                v=self._db.get(key, txn=txn, flags=flags,
    232296                        dlen=dlen, doff=doff)
    233             if (v != None) and isinstance(v, bytes) :
     297            if (v is not None) and isinstance(v, bytes) :
    234298                v = v.decode(charset)
    235299            return v
    … …  
    239303                key = bytes(key, charset)
    240304            v=self._db.pget(key, txn=txn)
    241             if v != None :
     305            if v is not None :
    242306                v1, v2 = v
    243307                if isinstance(v1, bytes) :
    … …  
    253317                value = bytes(value, charset)
    254318            v=self._db.get_both(key, value, txn=txn, flags=flags)
    255             if v != None :
     319            if v is not None :
    256320                v = v.decode(charset)
    257321            return v
    … …  
    289353                    data = data.decode(charset)
    290354                    key = self._callback(key, data)
    291                     if (key != bsddb._db.DB_DONOTINDEX) and isinstance(key,
    292                             str) :
    293                         key = bytes(key, charset)
     355                    if (key != bsddb._db.DB_DONOTINDEX) :
     356                        if isinstance(key, str) :
     357                            key = bytes(key, charset)
     358                        elif isinstance(key, list) :
     359                            key2 = []
     360                            for i in key :
     361                                if isinstance(i, str) :
     362                                    i = bytes(i, charset)
     363                                key2.append(i)
     364                            key = key2
    294365                    return key
    295366
    296367            return self._db.associate(secondarydb._db,
    297                     associate_callback(callback).callback, flags=flags, txn=txn)
     368                    associate_callback(callback).callback, flags=flags,
     369                    txn=txn)
    298370
    299371        def cursor(self, txn=None, flags=0) :
    … …  
    310382        def __getattr__(self, v) :
    311383            return getattr(self._dbenv, v)
     384
     385        def log_cursor(self, flags=0) :
     386            return logcursor_py3k(self._dbenv)
     387
     388        def get_lg_dir(self) :
     389            return self._dbenv.get_lg_dir().decode(charset)
     390
     391        def get_tmp_dir(self) :
     392            return self._dbenv.get_tmp_dir().decode(charset)
     393
     394        def get_data_dirs(self) :
     395            return tuple(
     396                (i.decode(charset) for i in self._dbenv.get_data_dirs()))
    312397
    313398    class DBSequence_py3k(object) :
    … …  
    333418    bsddb._db.DBEnv_orig = bsddb._db.DBEnv
    334419    bsddb._db.DB_orig = bsddb._db.DB
    335     bsddb._db.DBSequence_orig = bsddb._db.DBSequence
     420    if bsddb.db.version() <= (4, 3) :
     421        bsddb._db.DBSequence_orig = None
     422    else :
     423        bsddb._db.DBSequence_orig = bsddb._db.DBSequence
    336424
    337425    def do_proxy_db_py3k(flag) :
    … …  
    395483    print db.DB_VERSION_STRING
    396484    print 'bsddb.db.version():   %s' % (db.version(), )
     485    if db.version() >= (5, 0) :
     486        print 'bsddb.db.full_version(): %s' %repr(db.full_version())
    397487    print 'bsddb.db.__version__: %s' % db.__version__
    398488    print 'bsddb.db.cvsid:       %s' % db.cvsid
    399     print 'py module:            %s' % bsddb.__file__
    400     print 'extension module:     %s' % bsddb._bsddb.__file__
     489
     490    # Workaround for allowing generating an EGGs as a ZIP files.
     491    suffix="__"
     492    print 'py module:            %s' % getattr(bsddb, "__file"+suffix)
     493    print 'extension module:     %s' % getattr(bsddb, "__file"+suffix)
     494
    401495    print 'python version:       %s' % sys.version
    402496    print 'My pid:               %s' % os.getpid()
    … …  
    435529# This path can be overriden via "set_test_path_prefix()".
    436530import os, os.path
    437 get_new_path.prefix=os.path.join(os.sep,"tmp","z-Berkeley_DB")
     531get_new_path.prefix=os.path.join(os.environ.get("TMPDIR",
     532    os.path.join(os.sep,"tmp")), "z-Berkeley_DB")
    438533get_new_path.num=0
    439534
    … …  
    482577        'test_associate',
    483578        'test_basics',
     579        'test_dbenv',
     580        'test_db',
    484581        'test_compare',
    485582        'test_compat',
    … …  
    490587        'test_distributed_transactions',
    491588        'test_early_close',
     589        'test_fileid',
    492590        'test_get_none',
    493591        'test_join',

  • python/trunk/Lib/bsddb/test/test_associate.py

    r2 r391  
    149149        self.primary = db.DB(self.env)
    150150        self.primary.set_get_returns_none(2)
    151         if db.version() >= (4, 1):
    152             self.primary.open(self.filename, "primary", self.dbtype,
    153                           db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn)
    154         else:
    155             self.primary.open(self.filename, "primary", self.dbtype,
    156                           db.DB_CREATE | db.DB_THREAD | self.dbFlags)
     151        self.primary.open(self.filename, "primary", self.dbtype,
     152                      db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn)
    157153
    158154    def closeDB(self):
    … …  
    170166
    171167
    172     def test01_associateWithDB(self):
    173         if verbose:
    174             print '\n', '-=' * 30
    175             print "Running %s.test01_associateWithDB..." % \
    176                   self.__class__.__name__
    177 
     168    def _associateWithDB(self, getGenre):
    178169        self.createDB()
    179170
    … …  
    183174        self.secDB.open(self.filename, "secondary", db.DB_BTREE,
    184175                   db.DB_CREATE | db.DB_THREAD | self.dbFlags)
    185         self.getDB().associate(self.secDB, self.getGenre)
     176        self.getDB().associate(self.secDB, getGenre)
    186177
    187178        self.addDataToDB(self.getDB())
    … …  
    189180        self.finish_test(self.secDB)
    190181
    191 
    192     def test02_associateAfterDB(self):
     182    def test01_associateWithDB(self):
    193183        if verbose:
    194184            print '\n', '-=' * 30
    195             print "Running %s.test02_associateAfterDB..." % \
     185            print "Running %s.test01_associateWithDB..." % \
    196186                  self.__class__.__name__
    197187
     188        return self._associateWithDB(self.getGenre)
     189
     190    def _associateAfterDB(self, getGenre) :
    198191        self.createDB()
    199192        self.addDataToDB(self.getDB())
    … …  
    205198
    206199        # adding the DB_CREATE flag will cause it to index existing records
    207         self.getDB().associate(self.secDB, self.getGenre, db.DB_CREATE)
     200        self.getDB().associate(self.secDB, getGenre, db.DB_CREATE)
    208201
    209202        self.finish_test(self.secDB)
     203
     204    def test02_associateAfterDB(self):
     205        if verbose:
     206            print '\n', '-=' * 30
     207            print "Running %s.test02_associateAfterDB..." % \
     208                  self.__class__.__name__
     209
     210        return self._associateAfterDB(self.getGenre)
     211
     212    if db.version() >= (4, 6):
     213        def test03_associateWithDB(self):
     214            if verbose:
     215                print '\n', '-=' * 30
     216                print "Running %s.test03_associateWithDB..." % \
     217                      self.__class__.__name__
     218
     219            return self._associateWithDB(self.getGenreList)
     220
     221        def test04_associateAfterDB(self):
     222            if verbose:
     223                print '\n', '-=' * 30
     224                print "Running %s.test04_associateAfterDB..." % \
     225                      self.__class__.__name__
     226
     227            return self._associateAfterDB(self.getGenreList)
    210228
    211229
    … …  
    216234
    217235        vals = secDB.pget('Unknown', txn=txn)
    218         self.assert_(vals[0] == 99 or vals[0] == '99', vals)
     236        self.assertTrue(vals[0] == 99 or vals[0] == '99', vals)
    219237        vals[1].index('Unknown')
    220238        vals[1].index('Unnamed')
    … …  
    228246        while rec is not None:
    229247            if type(self.keytype) == type(''):
    230                 self.assert_(int(rec[0]))  # for primary db, key is a number
     248                self.assertTrue(int(rec[0]))  # for primary db, key is a number
    231249            else:
    232                 self.assert_(rec[0] and type(rec[0]) == type(0))
     250                self.assertTrue(rec[0] and type(rec[0]) == type(0))
    233251            count = count + 1
    234252            if verbose:
    … …  
    245263        # test cursor pget
    246264        vals = self.cur.pget('Unknown', flags=db.DB_LAST)
    247         self.assert_(vals[1] == 99 or vals[1] == '99', vals)
     265        self.assertTrue(vals[1] == 99 or vals[1] == '99', vals)
    248266        self.assertEqual(vals[0], 'Unknown')
    249267        vals[2].index('Unknown')
    … …  
    278296            return genre
    279297
     298    def getGenreList(self, priKey, PriData) :
     299        v = self.getGenre(priKey, PriData)
     300        if type(v) == type("") :
     301            v = [v]
     302        return v
     303
    280304
    281305#----------------------------------------------------------------------
    … …  
    323347            self.secDB.open(self.filename, "secondary", db.DB_BTREE,
    324348                       db.DB_CREATE | db.DB_THREAD, txn=txn)
    325             if db.version() >= (4,1):
    326                 self.getDB().associate(self.secDB, self.getGenre, txn=txn)
    327             else:
    328                 self.getDB().associate(self.secDB, self.getGenre)
     349            self.getDB().associate(self.secDB, self.getGenre, txn=txn)
    329350
    330351            self.addDataToDB(self.getDB(), txn=txn)
    … …  
    427448    suite.addTest(unittest.makeSuite(AssociateRecnoTestCase))
    428449
    429     if db.version() >= (4, 1):
    430         suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase))
     450    suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase))
    431451
    432452    suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase))

  • python/trunk/Lib/bsddb/test/test_basics.py

    r2 r391  
    1010import unittest
    1111import time
     12import sys
    1213
    1314from test_all import db, test_support, verbose, get_new_environment_path, \
    … …  
    3435class BasicTestCase(unittest.TestCase):
    3536    dbtype       = db.DB_UNKNOWN  # must be set in derived class
     37    cachesize    = (0, 1024*1024, 1)
    3638    dbopenflags  = 0
    3739    dbsetflags   = 0
    … …  
    5153                self.env.set_lg_max(1024*1024)
    5254                self.env.set_tx_max(30)
    53                 self.env.set_tx_timestamp(int(time.time()))
     55                self._t = int(time.time())
     56                self.env.set_tx_timestamp(self._t)
    5457                self.env.set_flags(self.envsetflags, 1)
    5558                self.env.open(self.homeDir, self.envflags | db.DB_CREATE)
    … …  
    6568        # create and open the DB
    6669        self.d = db.DB(self.env)
     70        if not self.useEnv :
     71            self.d.set_cachesize(*self.cachesize)
     72            cachesize = self.d.get_cachesize()
     73            self.assertEqual(cachesize[0], self.cachesize[0])
     74            self.assertEqual(cachesize[2], self.cachesize[2])
     75            # Berkeley DB expands the cache 25% accounting overhead,
     76            # if the cache is small.
     77            self.assertEqual(125, int(100.0*cachesize[1]/self.cachesize[1]))
    6778        self.d.set_flags(self.dbsetflags)
    6879        if self.dbname:
    … …  
    7485                        dbtype = self.dbtype,
    7586                        flags = self.dbopenflags|db.DB_CREATE)
     87
     88        if not self.useEnv:
     89            self.assertRaises(db.DBInvalidArgError,
     90                    self.d.set_cachesize, *self.cachesize)
    7691
    7792        self.populateDB()
    … …  
    140155            d.delete('abcd')
    141156        except db.DBNotFoundError, val:
    142             import sys
    143             if sys.version_info[0] < 3 :
     157            if sys.version_info < (2, 6) :
    144158                self.assertEqual(val[0], db.DB_NOTFOUND)
    145159            else :
    … …  
    163177            d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE)
    164178        except db.DBKeyExistError, val:
    165             import sys
    166             if sys.version_info[0] < 3 :
     179            if sys.version_info < (2, 6) :
    167180                self.assertEqual(val[0], db.DB_KEYEXIST)
    168181            else :
    … …  
    276289            pprint(values[:10])
    277290
     291
     292    #----------------------------------------
     293
     294    def test02b_SequenceMethods(self):
     295        d = self.d
     296
     297        for key in ['0002', '0101', '0401', '0701', '0998']:
     298            data = d[key]
     299            self.assertEqual(data, self.makeData(key))
     300            if verbose:
     301                print data
     302
     303        self.assertTrue(hasattr(d, "__contains__"))
     304        self.assertTrue("0401" in d)
     305        self.assertFalse("1234" in d)
    278306
    279307
    … …  
    302330            except db.DBNotFoundError, val:
    303331                if get_raises_error:
    304                     import sys
    305                     if sys.version_info[0] < 3 :
     332                    if sys.version_info < (2, 6) :
    306333                        self.assertEqual(val[0], db.DB_NOTFOUND)
    307334                    else :
    … …  
    327354            except db.DBNotFoundError, val:
    328355                if get_raises_error:
    329                     import sys
    330                     if sys.version_info[0] < 3 :
     356                    if sys.version_info < (2, 6) :
    331357                        self.assertEqual(val[0], db.DB_NOTFOUND)
    332358                    else :
    … …  
    354380            n = c.set('bad key')
    355381        except db.DBNotFoundError, val:
    356             import sys
    357             if sys.version_info[0] < 3 :
     382            if sys.version_info < (2, 6) :
    358383                self.assertEqual(val[0], db.DB_NOTFOUND)
    359384            else :
    … …  
    363388            if set_raises_error:
    364389                self.fail("expected exception")
    365             if n != None:
     390            if n is not None:
    366391                self.fail("expected None: %r" % (n,))
    367392
    … …  
    372397            n = c.get_both('0404', 'bad data')
    373398        except db.DBNotFoundError, val:
    374             import sys
    375             if sys.version_info[0] < 3 :
     399            if sys.version_info < (2, 6) :
    376400                self.assertEqual(val[0], db.DB_NOTFOUND)
    377401            else :
    … …  
    381405            if get_raises_error:
    382406                self.fail("expected exception")
    383             if n != None:
     407            if n is not None:
    384408                self.fail("expected None: %r" % (n,))
    385409
    … …  
    405429        except db.DBKeyEmptyError, val:
    406430            if get_raises_error:
    407                 import sys
    408                 if sys.version_info[0] < 3 :
     431                if sys.version_info < (2, 6) :
    409432                    self.assertEqual(val[0], db.DB_KEYEMPTY)
    410433                else :
    … …  
    452475                          method
    453476                # a bug may cause a NULL pointer dereference...
    454                 apply(getattr(c, method), args)
     477                getattr(c, method)(*args)
    455478            except db.DBError, val:
    456                 import sys
    457                 if sys.version_info[0] < 3 :
     479                if sys.version_info < (2, 6) :
    458480                    self.assertEqual(val[0], 0)
    459481                else :
    … …  
    510532        self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=0)
    511533
     534    if db.version() >= (4, 6):
     535        def test03d_SimpleCursorPriority(self) :
     536            c = self.d.cursor()
     537            c.set_priority(db.DB_PRIORITY_VERY_LOW)  # Positional
     538            self.assertEqual(db.DB_PRIORITY_VERY_LOW, c.get_priority())
     539            c.set_priority(priority=db.DB_PRIORITY_HIGH)  # Keyword
     540            self.assertEqual(db.DB_PRIORITY_HIGH, c.get_priority())
     541            c.close()
     542
    512543    #----------------------------------------
    513544
    … …  
    563594        if verbose:
    564595            print '\n', '-=' * 30
    565             print "Running %s.test99_Truncate..." % self.__class__.__name__
     596            print "Running %s.test06_Truncate..." % self.__class__.__name__
    566597
    567598        d.put("abcde", "ABCDE");
    568599        num = d.truncate()
    569         self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")
     600        self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
    570601        num = d.truncate()
    571602        self.assertEqual(num, 0,
    … …  
    583614    #----------------------------------------
    584615
     616    if db.version() >= (4, 6):
     617        def test08_exists(self) :
     618            self.d.put("abcde", "ABCDE")
     619            self.assertTrue(self.d.exists("abcde") == True,
     620                    "DB->exists() returns wrong value")
     621            self.assertTrue(self.d.exists("x") == False,
     622                    "DB->exists() returns wrong value")
     623
     624    #----------------------------------------
     625
     626    if db.version() >= (4, 7):
     627        def test_compact(self) :
     628            d = self.d
     629            self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY))
     630            self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY))
     631            d.put("abcde", "ABCDE");
     632            d.put("bcde", "BCDE");
     633            d.put("abc", "ABC");
     634            d.put("monty", "python");
     635            d.delete("abc")
     636            d.delete("bcde")
     637            d.compact(start='abcde', stop='monty', txn=None,
     638                    compact_fillpercent=42, compact_pages=1,
     639                    compact_timeout=50000000,
     640                    flags=db.DB_FREELIST_ONLY|db.DB_FREE_SPACE)
     641
     642    #----------------------------------------
    585643
    586644#----------------------------------------------------------------------
    … …  
    612670    #----------------------------------------
    613671
    614     def test08_EnvRemoveAndRename(self):
     672    def test09_EnvRemoveAndRename(self):
    615673        if not self.env:
    616674            return
    … …  
    618676        if verbose:
    619677            print '\n', '-=' * 30
    620             print "Running %s.test08_EnvRemoveAndRename..." % self.__class__.__name__
     678            print "Running %s.test09_EnvRemoveAndRename..." % self.__class__.__name__
    621679
    622680        # can't rename or remove an open DB
    … …  
    627685        self.env.dbremove(newname)
    628686
    629     # dbremove and dbrename are in 4.1 and later
    630     if db.version() < (4,1):
    631         del test08_EnvRemoveAndRename
    632 
    633687    #----------------------------------------
    634688
    … …  
    644698
    645699class 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)
     700    if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
     701            (sys.version_info < (3, 2))) :
     702        def assertIn(self, a, b, msg=None) :
     703            return self.assertTrue(a in b, msg=msg)
    650704
    651705    dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT
    … …  
    705759
    706760        # flush pending updates
    707         try:
    708             self.env.txn_checkpoint (0, 0, 0)
    709         except db.DBIncompleteError:
    710             pass
     761        self.env.txn_checkpoint (0, 0, 0)
    711762
    712763        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'))
     764        self.assertIn('magic', statDict)
     765        self.assertIn('version', statDict)
     766        self.assertIn('cur_file', statDict)
     767        self.assertIn('region_nowait', statDict)
    717768
    718769        # must have at least one log file present:
    … …  
    722773            if verbose:
    723774                print 'log file: ' + log
    724         if db.version() >= (4,2):
    725775            logs = self.env.log_archive(db.DB_ARCH_REMOVE)
    726776            self.assertTrue(not logs)
    … …  
    730780    #----------------------------------------
    731781
    732     def test08_TxnTruncate(self):
     782    if db.version() >= (4, 6):
     783        def test08_exists(self) :
     784            txn = self.env.txn_begin()
     785            self.d.put("abcde", "ABCDE", txn=txn)
     786            txn.commit()
     787            txn = self.env.txn_begin()
     788            self.assertTrue(self.d.exists("abcde", txn=txn) == True,
     789                    "DB->exists() returns wrong value")
     790            self.assertTrue(self.d.exists("x", txn=txn) == False,
     791                    "DB->exists() returns wrong value")
     792            txn.abort()
     793
     794    #----------------------------------------
     795
     796    def test09_TxnTruncate(self):
    733797        d = self.d
    734798        if verbose:
    735799            print '\n', '-=' * 30
    736             print "Running %s.test08_TxnTruncate..." % self.__class__.__name__
     800            print "Running %s.test09_TxnTruncate..." % self.__class__.__name__
    737801
    738802        d.put("abcde", "ABCDE");
    739803        txn = self.env.txn_begin()
    740804        num = d.truncate(txn)
    741         self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")
     805        self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
    742806        num = d.truncate(txn)
    743807        self.assertEqual(num, 0,
    … …  
    747811    #----------------------------------------
    748812
    749     def test09_TxnLateUse(self):
     813    def test10_TxnLateUse(self):
    750814        txn = self.env.txn_begin()
    751815        txn.abort()
    … …  
    767831
    768832
     833    #----------------------------------------
     834
     835
     836    if db.version() >= (4, 4):
     837        def test_txn_name(self) :
     838            txn=self.env.txn_begin()
     839            self.assertEqual(txn.get_name(), "")
     840            txn.set_name("XXYY")
     841            self.assertEqual(txn.get_name(), "XXYY")
     842            txn.set_name("")
     843            self.assertEqual(txn.get_name(), "")
     844            txn.abort()
     845
     846    #----------------------------------------
     847
     848
     849        def test_txn_set_timeout(self) :
     850            txn=self.env.txn_begin()
     851            txn.set_timeout(1234567, db.DB_SET_LOCK_TIMEOUT)
     852            txn.set_timeout(2345678, flags=db.DB_SET_TXN_TIMEOUT)
     853            txn.abort()
     854
     855    #----------------------------------------
     856
     857        def test_get_tx_max(self) :
     858            self.assertEqual(self.env.get_tx_max(), 30)
     859
     860        def test_get_tx_timestamp(self) :
     861            self.assertEqual(self.env.get_tx_timestamp(), self._t)
     862
     863
     864
    769865class BTreeTransactionTestCase(BasicTransactionTestCase):
    770866    dbtype = db.DB_BTREE
    … …  
    781877    dbsetflags = db.DB_RECNUM
    782878
    783     def test08_RecnoInBTree(self):
     879    def test09_RecnoInBTree(self):
    784880        d = self.d
    785881        if verbose:
    786882            print '\n', '-=' * 30
    787             print "Running %s.test08_RecnoInBTree..." % self.__class__.__name__
     883            print "Running %s.test09_RecnoInBTree..." % self.__class__.__name__
    788884
    789885        rec = d.get(200)
    … …  
    815911    dbsetflags = db.DB_DUP
    816912
    817     def test09_DuplicateKeys(self):
     913    def test10_DuplicateKeys(self):
    818914        d = self.d
    819915        if verbose:
    820916            print '\n', '-=' * 30
    821             print "Running %s.test09_DuplicateKeys..." % \
     917            print "Running %s.test10_DuplicateKeys..." % \
    822918                  self.__class__.__name__
    823919
    … …  
    888984            return db.DB_BTREE
    889985
    890     def test10_MultiDB(self):
     986    def test11_MultiDB(self):
    891987        d1 = self.d
    892988        if verbose:
    893989            print '\n', '-=' * 30
    894             print "Running %s.test10_MultiDB..." % self.__class__.__name__
     990            print "Running %s.test11_MultiDB..." % self.__class__.__name__
    895991
    896992        d2 = db.DB(self.env)
    … …  
    9811077
    9821078class 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 
    9881079    def tearDown(self) :
    9891080        del self.obj
    … …  
    9991090
    10001091    def test03_leak_assignment(self) :
    1001         import sys
    10021092        a = "example of private object"
    10031093        refcount = sys.getrefcount(a)
    … …  
    10081098
    10091099    def test04_leak_GC(self) :
    1010         import sys
    10111100        a = "example of private object"
    10121101        refcount = sys.getrefcount(a)
    … …  
    10241113
    10251114class 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 
    10311115    #def test01_OpenCrash(self) :
    10321116    #    # See http://bugs.python.org/issue3307
    10331117    #    self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535)
    10341118
    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()
     1119    if db.version() < (4, 8) :
     1120        def test02_DBEnv_dealloc(self):
     1121            # http://bugs.python.org/issue3885
     1122            import gc
     1123            self.assertRaises(db.DBInvalidArgError, db.DBEnv, ~db.DB_RPCCLIENT)
     1124            gc.collect()
    10401125
    10411126

  • python/trunk/Lib/bsddb/test/test_compare.py

    r2 r391  
    11"""
    2 TestCases for python DB Btree key comparison function.
     2TestCases for python DB duplicate and Btree key comparison function.
    33"""
    44
    … …  
    1313
    1414
     15# Needed for python 3. "cmp" vanished in 3.0.1
     16def cmp(a, b) :
     17    if a==b : return 0
     18    if a<b : return -1
     19    return 1
     20
    1521lexical_cmp = cmp
    1622
    17 def lowercase_cmp(left, right):
    18     return cmp (left.lower(), right.lower())
    19 
    20 def make_reverse_comparator (cmp):
    21     def reverse (left, right, delegate=cmp):
    22         return - delegate (left, right)
     23def lowercase_cmp(left, right) :
     24    return cmp(left.lower(), right.lower())
     25
     26def make_reverse_comparator(cmp) :
     27    def reverse(left, right, delegate=cmp) :
     28        return - delegate(left, right)
    2329    return reverse
    2430
    … …  
    2632_expected_lowercase_test_data = ['', 'a', 'aaa', 'b', 'c', 'CC', 'cccce', 'ccccf', 'CCCP']
    2733
    28 class ComparatorTests (unittest.TestCase):
    29     def comparator_test_helper (self, comparator, expected_data):
     34class ComparatorTests(unittest.TestCase) :
     35    def comparator_test_helper(self, comparator, expected_data) :
    3036        data = expected_data[:]
    3137
    3238        import sys
    33         if sys.version_info[0] < 3 :
    34             if sys.version_info[:3] < (2, 4, 0):
    35                 data.sort(comparator)
    36             else :
    37                 data.sort(cmp=comparator)
     39        if sys.version_info < (2, 6) :
     40            data.sort(cmp=comparator)
    3841        else :  # Insertion Sort. Please, improve
    3942            data2 = []
    … …  
    4851            data = data2
    4952
    50         self.failUnless (data == expected_data,
     53        self.assertEqual(data, expected_data,
    5154                         "comparator `%s' is not right: %s vs. %s"
    5255                         % (comparator, expected_data, data))
    53     def test_lexical_comparator (self):
    54         self.comparator_test_helper (lexical_cmp, _expected_lexical_test_data)
    55     def test_reverse_lexical_comparator (self):
     56    def test_lexical_comparator(self) :
     57        self.comparator_test_helper(lexical_cmp, _expected_lexical_test_data)
     58    def test_reverse_lexical_comparator(self) :
    5659        rev = _expected_lexical_test_data[:]
    57         rev.reverse ()
    58         self.comparator_test_helper (make_reverse_comparator (lexical_cmp),
     60        rev.reverse()
     61        self.comparator_test_helper(make_reverse_comparator(lexical_cmp),
    5962                                     rev)
    60     def test_lowercase_comparator (self):
    61         self.comparator_test_helper (lowercase_cmp,
     63    def test_lowercase_comparator(self) :
     64        self.comparator_test_helper(lowercase_cmp,
    6265                                     _expected_lowercase_test_data)
    6366
    64 class AbstractBtreeKeyCompareTestCase (unittest.TestCase):
     67class AbstractBtreeKeyCompareTestCase(unittest.TestCase) :
    6568    env = None
    6669    db = None
    6770
    68     def setUp (self):
     71    if (sys.version_info < (2, 7)) or ((sys.version_info >= (3,0)) and
     72            (sys.version_info < (3, 2))) :
     73        def assertLess(self, a, b, msg=None) :
     74            return self.assertTrue(a<b, msg=msg)
     75
     76    def setUp(self) :
    6977        self.filename = self.__class__.__name__ + '.db'
    7078        self.homeDir = get_new_environment_path()
    7179        env = db.DBEnv()
    72         env.open (self.homeDir,
     80        env.open(self.homeDir,
    7381                  db.DB_CREATE | db.DB_INIT_MPOOL
    7482                  | db.DB_INIT_LOCK | db.DB_THREAD)
    7583        self.env = env
    7684
    77     def tearDown (self):
     85    def tearDown(self) :
    7886        self.closeDB()
    7987        if self.env is not None:
    … …  
    8290        test_support.rmtree(self.homeDir)
    8391
    84     def addDataToDB (self, data):
     92    def addDataToDB(self, data) :
    8593        i = 0
    8694        for item in data:
    87             self.db.put (item, str (i))
     95            self.db.put(item, str(i))
    8896            i = i + 1
    8997
    90     def createDB (self, key_comparator):
    91         self.db = db.DB (self.env)
    92         self.setupDB (key_comparator)
    93         self.db.open (self.filename, "test", db.DB_BTREE, db.DB_CREATE)
    94 
    95     def setupDB (self, key_comparator):
    96         self.db.set_bt_compare (key_comparator)
    97 
    98     def closeDB (self):
     98    def createDB(self, key_comparator) :
     99        self.db = db.DB(self.env)
     100        self.setupDB(key_comparator)
     101        self.db.open(self.filename, "test", db.DB_BTREE, db.DB_CREATE)
     102
     103    def setupDB(self, key_comparator) :
     104        self.db.set_bt_compare(key_comparator)
     105
     106    def closeDB(self) :
    99107        if self.db is not None:
    100             self.db.close ()
     108            self.db.close()
    101109            self.db = None
    102110
    103     def startTest (self):
     111    def startTest(self) :
    104112        pass
    105113
    106     def finishTest (self, expected = None):
     114    def finishTest(self, expected = None) :
    107115        if expected is not None:
    108             self.check_results (expected)
    109         self.closeDB ()
    110 
    111     def check_results (self, expected):
    112         curs = self.db.cursor ()
     116            self.check_results(expected)
     117        self.closeDB()
     118
     119    def check_results(self, expected) :
     120        curs = self.db.cursor()
    113121        try:
    114122            index = 0
    115             rec = curs.first ()
     123            rec = curs.first()
    116124            while rec:
    117125                key, ignore = rec
    118                 self.failUnless (index < len (expected),
     126                self.assertLess(index, len(expected),
    119127                                 "to many values returned from cursor")
    120                 self.failUnless (expected[index] == key,
     128                self.assertEqual(expected[index], key,
    121129                                 "expected value `%s' at %d but got `%s'"
    122130                                 % (expected[index], index, key))
    123131                index = index + 1
    124                 rec = curs.next ()
    125             self.failUnless (index == len (expected),
     132                rec = curs.next()
     133            self.assertEqual(index, len(expected),
    126134                             "not enough values returned from cursor")
    127135        finally:
    128             curs.close ()
    129 
    130 class BtreeKeyCompareTestCase (AbstractBtreeKeyCompareTestCase):
    131     def runCompareTest (self, comparator, data):
    132         self.startTest ()
    133         self.createDB (comparator)
    134         self.addDataToDB (data)
    135         self.finishTest (data)
    136 
    137     def test_lexical_ordering (self):
    138         self.runCompareTest (lexical_cmp, _expected_lexical_test_data)
    139 
    140     def test_reverse_lexical_ordering (self):
     136            curs.close()
     137
     138class BtreeKeyCompareTestCase(AbstractBtreeKeyCompareTestCase) :
     139    def runCompareTest(self, comparator, data) :
     140        self.startTest()
     141        self.createDB(comparator)
     142        self.addDataToDB(data)
     143        self.finishTest(data)
     144
     145    def test_lexical_ordering(self) :
     146        self.runCompareTest(lexical_cmp, _expected_lexical_test_data)
     147
     148    def test_reverse_lexical_ordering(self) :
    141149        expected_rev_data = _expected_lexical_test_data[:]
    142         expected_rev_data.reverse ()
    143         self.runCompareTest (make_reverse_comparator (lexical_cmp),
     150        expected_rev_data.reverse()
     151        self.runCompareTest(make_reverse_comparator(lexical_cmp),
    144152                             expected_rev_data)
    145153
    146     def test_compare_function_useless (self):
    147         self.startTest ()
    148         def socialist_comparator (l, r):
     154    def test_compare_function_useless(self) :
     155        self.startTest()
     156        def socialist_comparator(l, r) :
    149157            return 0
    150         self.createDB (socialist_comparator)
    151         self.addDataToDB (['b', 'a', 'd'])
     158        self.createDB(socialist_comparator)
     159        self.addDataToDB(['b', 'a', 'd'])
    152160        # all things being equal the first key will be the only key
    153161        # in the database...  (with the last key's value fwiw)
    154         self.finishTest (['b'])
    155 
    156 
    157 class BtreeExceptionsTestCase (AbstractBtreeKeyCompareTestCase):
    158     def test_raises_non_callable (self):
    159         self.startTest ()
    160         self.assertRaises (TypeError, self.createDB, 'abc')
    161         self.assertRaises (TypeError, self.createDB, None)
    162         self.finishTest ()
    163 
    164     def test_set_bt_compare_with_function (self):
    165         self.startTest ()
    166         self.createDB (lexical_cmp)
    167         self.finishTest ()
    168 
    169     def check_results (self, results):
     162        self.finishTest(['b'])
     163
     164
     165class BtreeExceptionsTestCase(AbstractBtreeKeyCompareTestCase) :
     166    def test_raises_non_callable(self) :
     167        self.startTest()
     168        self.assertRaises(TypeError, self.createDB, 'abc')
     169        self.assertRaises(TypeError, self.createDB, None)
     170        self.finishTest()
     171
     172    def test_set_bt_compare_with_function(self) :
     173        self.startTest()
     174        self.createDB(lexical_cmp)
     175        self.finishTest()
     176
     177    def check_results(self, results) :
    170178        pass
    171179
    172     def test_compare_function_incorrect (self):
    173         self.startTest ()
    174         def bad_comparator (l, r):
     180    def test_compare_function_incorrect(self) :
     181        self.startTest()
     182        def bad_comparator(l, r) :
    175183            return 1
    176184        # verify that set_bt_compare checks that comparator('', '') == 0
    177         self.assertRaises (TypeError, self.createDB, bad_comparator)
    178         self.finishTest ()
    179 
    180     def verifyStderr(self, method, successRe):
     185        self.assertRaises(TypeError, self.createDB, bad_comparator)
     186        self.finishTest()
     187
     188    def verifyStderr(self, method, successRe) :
    181189        """
    182190        Call method() while capturing sys.stderr output internally and
    … …  
    192200            sys.stderr = stdErr
    193201            errorOut = temp.getvalue()
    194             if not successRe.search(errorOut):
     202            if not successRe.search(errorOut) :
    195203                self.fail("unexpected stderr output:\n"+errorOut)
    196         sys.exc_traceback = sys.last_traceback = None
    197 
    198     def _test_compare_function_exception (self):
    199         self.startTest ()
    200         def bad_comparator (l, r):
     204        if sys.version_info < (3, 0) :  # XXX: How to do this in Py3k ???
     205            sys.exc_traceback = sys.last_traceback = None
     206
     207    def _test_compare_function_exception(self) :
     208        self.startTest()
     209        def bad_comparator(l, r) :
    201210            if l == r:
    202211                # pass the set_bt_compare test
    203212                return 0
    204213            raise RuntimeError, "i'm a naughty comparison function"
    205         self.createDB (bad_comparator)
     214        self.createDB(bad_comparator)
    206215        #print "\n*** test should print 2 uncatchable tracebacks ***"
    207         self.addDataToDB (['a', 'b', 'c'])  # this should raise, but...
    208         self.finishTest ()
    209 
    210     def test_compare_function_exception(self):
     216        self.addDataToDB(['a', 'b', 'c'])  # this should raise, but...
     217        self.finishTest()
     218
     219    def test_compare_function_exception(self) :
    211220        self.verifyStderr(
    212221                self._test_compare_function_exception,
    … …  
    214223        )
    215224
    216     def _test_compare_function_bad_return (self):
    217         self.startTest ()
    218         def bad_comparator (l, r):
     225    def _test_compare_function_bad_return(self) :
     226        self.startTest()
     227        def bad_comparator(l, r) :
    219228            if l == r:
    220229                # pass the set_bt_compare test
    221230                return 0
    222231            return l
    223         self.createDB (bad_comparator)
     232        self.createDB(bad_comparator)
    224233        #print "\n*** test should print 2 errors about returning an int ***"
    225         self.addDataToDB (['a', 'b', 'c'])  # this should raise, but...
    226         self.finishTest ()
    227 
    228     def test_compare_function_bad_return(self):
     234        self.addDataToDB(['a', 'b', 'c'])  # this should raise, but...
     235        self.finishTest()
     236
     237    def test_compare_function_bad_return(self) :
    229238        self.verifyStderr(
    230239                self._test_compare_function_bad_return,
    … …  
    233242
    234243
    235     def test_cannot_assign_twice (self):
    236 
    237         def my_compare (a, b):
     244    def test_cannot_assign_twice(self) :
     245
     246        def my_compare(a, b) :
    238247            return 0
    239248
    240         self.startTest ()
    241         self.createDB (my_compare)
     249        self.startTest()
     250        self.createDB(my_compare)
     251        self.assertRaises(RuntimeError, self.db.set_bt_compare, my_compare)
     252
     253class AbstractDuplicateCompareTestCase(unittest.TestCase) :
     254    env = None
     255    db = None
     256
     257    if (sys.version_info < (2, 7)) or ((sys.version_info >= (3,0)) and
     258            (sys.version_info < (3, 2))) :
     259        def assertLess(self, a, b, msg=None) :
     260            return self.assertTrue(a<b, msg=msg)
     261
     262    def setUp(self) :
     263        self.filename = self.__class__.__name__ + '.db'
     264        self.homeDir = get_new_environment_path()
     265        env = db.DBEnv()
     266        env.open(self.homeDir,
     267                  db.DB_CREATE | db.DB_INIT_MPOOL
     268                  | db.DB_INIT_LOCK | db.DB_THREAD)
     269        self.env = env
     270
     271    def tearDown(self) :
     272        self.closeDB()
     273        if self.env is not None:
     274            self.env.close()
     275            self.env = None
     276        test_support.rmtree(self.homeDir)
     277
     278    def addDataToDB(self, data) :
     279        for item in data:
     280            self.db.put("key", item)
     281
     282    def createDB(self, dup_comparator) :
     283        self.db = db.DB(self.env)
     284        self.setupDB(dup_comparator)
     285        self.db.open(self.filename, "test", db.DB_BTREE, db.DB_CREATE)
     286
     287    def setupDB(self, dup_comparator) :
     288        self.db.set_flags(db.DB_DUPSORT)
     289        self.db.set_dup_compare(dup_comparator)
     290
     291    def closeDB(self) :
     292        if self.db is not None:
     293            self.db.close()
     294            self.db = None
     295
     296    def startTest(self) :
     297        pass
     298
     299    def finishTest(self, expected = None) :
     300        if expected is not None:
     301            self.check_results(expected)
     302        self.closeDB()
     303
     304    def check_results(self, expected) :
     305        curs = self.db.cursor()
    242306        try:
    243             self.db.set_bt_compare (my_compare)
    244             self.assert_(0, "this set should fail")
    245 
    246         except RuntimeError, msg:
    247             pass
    248 
    249 def test_suite ():
    250     res = unittest.TestSuite ()
    251 
    252     res.addTest (unittest.makeSuite (ComparatorTests))
    253     res.addTest (unittest.makeSuite (BtreeExceptionsTestCase))
    254     res.addTest (unittest.makeSuite (BtreeKeyCompareTestCase))
     307            index = 0
     308            rec = curs.first()
     309            while rec:
     310                ignore, data = rec
     311                self.assertLess(index, len(expected),
     312                                 "to many values returned from cursor")
     313                self.assertEqual(expected[index], data,
     314                                 "expected value `%s' at %d but got `%s'"
     315                                 % (expected[index], index, data))
     316                index = index + 1
     317                rec = curs.next()
     318            self.assertEqual(index, len(expected),
     319                             "not enough values returned from cursor")
     320        finally:
     321            curs.close()
     322
     323class DuplicateCompareTestCase(AbstractDuplicateCompareTestCase) :
     324    def runCompareTest(self, comparator, data) :
     325        self.startTest()
     326        self.createDB(comparator)
     327        self.addDataToDB(data)
     328        self.finishTest(data)
     329
     330    def test_lexical_ordering(self) :
     331        self.runCompareTest(lexical_cmp, _expected_lexical_test_data)
     332
     333    def test_reverse_lexical_ordering(self) :
     334        expected_rev_data = _expected_lexical_test_data[:]
     335        expected_rev_data.reverse()
     336        self.runCompareTest(make_reverse_comparator(lexical_cmp),
     337                             expected_rev_data)
     338
     339class DuplicateExceptionsTestCase(AbstractDuplicateCompareTestCase) :
     340    def test_raises_non_callable(self) :
     341        self.startTest()
     342        self.assertRaises(TypeError, self.createDB, 'abc')
     343        self.assertRaises(TypeError, self.createDB, None)
     344        self.finishTest()
     345
     346    def test_set_dup_compare_with_function(self) :
     347        self.startTest()
     348        self.createDB(lexical_cmp)
     349        self.finishTest()
     350
     351    def check_results(self, results) :
     352        pass
     353
     354    def test_compare_function_incorrect(self) :
     355        self.startTest()
     356        def bad_comparator(l, r) :
     357            return 1
     358        # verify that set_dup_compare checks that comparator('', '') == 0
     359        self.assertRaises(TypeError, self.createDB, bad_comparator)
     360        self.finishTest()
     361
     362    def test_compare_function_useless(self) :
     363        self.startTest()
     364        def socialist_comparator(l, r) :
     365            return 0
     366        self.createDB(socialist_comparator)
     367        # DUPSORT does not allow "duplicate duplicates"
     368        self.assertRaises(db.DBKeyExistError, self.addDataToDB, ['b', 'a', 'd'])
     369        self.finishTest()
     370
     371    def verifyStderr(self, method, successRe) :
     372        """
     373        Call method() while capturing sys.stderr output internally and
     374        call self.fail() if successRe.search() does not match the stderr
     375        output.  This is used to test for uncatchable exceptions.
     376        """
     377        stdErr = sys.stderr
     378        sys.stderr = StringIO()
     379        try:
     380            method()
     381        finally:
     382            temp = sys.stderr
     383            sys.stderr = stdErr
     384            errorOut = temp.getvalue()
     385            if not successRe.search(errorOut) :
     386                self.fail("unexpected stderr output:\n"+errorOut)
     387        if sys.version_info < (3, 0) :  # XXX: How to do this in Py3k ???
     388            sys.exc_traceback = sys.last_traceback = None
     389
     390    def _test_compare_function_exception(self) :
     391        self.startTest()
     392        def bad_comparator(l, r) :
     393            if l == r:
     394                # pass the set_dup_compare test
     395                return 0
     396            raise RuntimeError, "i'm a naughty comparison function"
     397        self.createDB(bad_comparator)
     398        #print "\n*** test should print 2 uncatchable tracebacks ***"
     399        self.addDataToDB(['a', 'b', 'c'])  # this should raise, but...
     400        self.finishTest()
     401
     402    def test_compare_function_exception(self) :
     403        self.verifyStderr(
     404                self._test_compare_function_exception,
     405                re.compile('(^RuntimeError:.* naughty.*){2}', re.M|re.S)
     406        )
     407
     408    def _test_compare_function_bad_return(self) :
     409        self.startTest()
     410        def bad_comparator(l, r) :
     411            if l == r:
     412                # pass the set_dup_compare test
     413                return 0
     414            return l
     415        self.createDB(bad_comparator)
     416        #print "\n*** test should print 2 errors about returning an int ***"
     417        self.addDataToDB(['a', 'b', 'c'])  # this should raise, but...
     418        self.finishTest()
     419
     420    def test_compare_function_bad_return(self) :
     421        self.verifyStderr(
     422                self._test_compare_function_bad_return,
     423                re.compile('(^TypeError:.* return an int.*){2}', re.M|re.S)
     424        )
     425
     426
     427    def test_cannot_assign_twice(self) :
     428
     429        def my_compare(a, b) :
     430            return 0
     431
     432        self.startTest()
     433        self.createDB(my_compare)
     434        self.assertRaises(RuntimeError, self.db.set_dup_compare, my_compare)
     435
     436def test_suite() :
     437    res = unittest.TestSuite()
     438
     439    res.addTest(unittest.makeSuite(ComparatorTests))
     440    res.addTest(unittest.makeSuite(BtreeExceptionsTestCase))
     441    res.addTest(unittest.makeSuite(BtreeKeyCompareTestCase))
     442    res.addTest(unittest.makeSuite(DuplicateExceptionsTestCase))
     443    res.addTest(unittest.makeSuite(DuplicateCompareTestCase))
    255444    return res
    256445
    257446if __name__ == '__main__':
    258     unittest.main (defaultTest = 'suite')
     447    unittest.main(defaultTest = 'suite')

  • python/trunk/Lib/bsddb/test/test_compat.py

    r2 r391  
    120120                print rec
    121121
    122         self.assert_(f.has_key('f'), 'Error, missing key!')
     122        self.assertTrue(f.has_key('f'), 'Error, missing key!')
    123123
    124124        # test that set_location() returns the next nearest key, value

  • python/trunk/Lib/bsddb/test/test_cursor_pget_bug.py

    r2 r391  
    3838        cursor = self.secondary_db.cursor()
    3939
    40         self.assertEquals(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET))
    41         self.assertEquals(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP))
    42         self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP))
     40        self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET))
     41        self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP))
     42        self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
    4343
    44         self.assertEquals(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET))
    45         self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP))
     44        self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET))
     45        self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
    4646
    4747        cursor.close()

  • python/trunk/Lib/bsddb/test/test_dbobj.py

    r2 r391  
    2828                key = key.upper()
    2929                # call our parent classes put method with an upper case key
    30                 return apply(dbobj.DB.put, (self, key) + args, kwargs)
     30                return dbobj.DB.put(self, key, *args, **kwargs)
    3131        self.env = TestDBEnv()
    3232        self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)

  • python/trunk/Lib/bsddb/test/test_dbshelve.py

    r2 r391  
    33"""
    44
    5 import os, string
     5import os, string, sys
    66import random
    77import unittest
    … …  
    1010from test_all import db, dbshelve, test_support, verbose, \
    1111        get_new_environment_path, get_new_database_path
     12
     13
    1214
    1315
    … …  
    2931
    3032class DBShelveTestCase(unittest.TestCase):
     33    if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
     34            (sys.version_info < (3, 2))) :
     35        def assertIn(self, a, b, msg=None) :
     36            return self.assertTrue(a in b, msg=msg)
     37
     38
    3139    def setUp(self):
    32         import sys
    3340        if sys.version_info[0] >= 3 :
    3441            from test_all import do_proxy_db_py3k
    … …  
    3845
    3946    def tearDown(self):
    40         import sys
    4147        if sys.version_info[0] >= 3 :
    4248            from test_all import do_proxy_db_py3k
    … …  
    4854        """Turn key into an appropriate key type for this db"""
    4955        # override in child class for RECNO
    50         import sys
    5156        if sys.version_info[0] < 3 :
    5257            return key
    … …  
    118123        dbvalues = d.values()
    119124        self.assertEqual(len(dbvalues), len(d.keys()))
    120         import sys
    121         if sys.version_info[0] < 3 :
     125        if sys.version_info < (2, 6) :
    122126            values.sort()
    123127            dbvalues.sort()
    … …  
    201205
    202206
     207    def test04_iterable(self) :
     208        self.populateDB(self.d)
     209        d = self.d
     210        keys = d.keys()
     211        keyset = set(keys)
     212        self.assertEqual(len(keyset), len(keys))
     213
     214        for key in d :
     215            self.assertIn(key, keyset)
     216            keyset.remove(key)
     217        self.assertEqual(len(keyset), 0)
     218
    203219    def checkrec(self, key, value):
    204220        # override this in a subclass if the key type is different
    205221
    206         import sys
    207222        if sys.version_info[0] >= 3 :
    208223            if isinstance(key, bytes) :
    … …  
    223238
    224239        elif key[0] == 'O':
    225             import sys
    226240            if sys.version_info[0] < 3 :
    227241                from types import InstanceType
    … …  
    235249
    236250        else:
    237             self.assert_(0, 'Unknown key type, fix the test')
     251            self.assertTrue(0, 'Unknown key type, fix the test')
    238252
    239253#----------------------------------------------------------------------
    … …  
    291305
    292306    def tearDown(self):
    293         import sys
    294307        if sys.version_info[0] >= 3 :
    295308            from test_all import do_proxy_db_py3k

  • python/trunk/Lib/bsddb/test/test_dbtables.py

    r2 r391  
    1919#   --  Gregory P. Smith <greg@krypto.org>
    2020#
    21 # $Id: test_dbtables.py 66088 2008-08-31 14:00:51Z jesus.cea $
    22 
    23 import os, re
    24 try:
    25     import cPickle
    26     pickle = cPickle
    27 except ImportError:
     21# $Id$
     22
     23import os, re, sys
     24
     25if sys.version_info[0] < 3 :
     26    try:
     27        import cPickle
     28        pickle = cPickle
     29    except ImportError:
     30        import pickle
     31else :
    2832    import pickle
    2933
    … …  
    8185        else :
    8286            colval = pickle.loads(bytes(values[0][colname], "iso8859-1"))
    83         self.assert_(colval > 3.141)
    84         self.assert_(colval < 3.142)
     87        self.assertTrue(colval > 3.141)
     88        self.assertTrue(colval < 3.142)
    8589
    8690
    … …  
    342346
    343347        def set_type(type):
    344             if type == None:
     348            if type is None:
    345349                return 'MP3'
    346350            return type

  • python/trunk/Lib/bsddb/test/test_distributed_transactions.py

    r2 r391  
    77from test_all import db, test_support, get_new_environment_path, \
    88        get_new_database_path
    9 
    10 try :
    11     a=set()
    12 except : # Python 2.3
    13     from sets import Set as set
    14 else :
    15     del a
    169
    1710from test_all import verbose
    … …  
    3629                db.DB_INIT_LOCK, 0666)
    3730        self.db = db.DB(self.dbenv)
    38         self.db.set_re_len(db.DB_XIDDATASIZE)
     31        self.db.set_re_len(db.DB_GID_SIZE)
    3932        if must_open_db :
    40             if db.version() > (4,1) :
    41                 txn=self.dbenv.txn_begin()
    42                 self.db.open(self.filename,
    43                         db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0666,
    44                         txn=txn)
    45                 txn.commit()
    46             else :
    47                 self.db.open(self.filename,
    48                         db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0666)
     33            txn=self.dbenv.txn_begin()
     34            self.db.open(self.filename,
     35                    db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0666,
     36                    txn=txn)
     37            txn.commit()
    4938
    5039    def setUp(self) :
    … …  
    7766        for i in xrange(self.num_txns) :
    7867            txn = self.dbenv.txn_begin()
    79             gid = "%%%dd" %db.DB_XIDDATASIZE
     68            gid = "%%%dd" %db.DB_GID_SIZE
    8069            gid = adapt(gid %i)
    8170            self.db.put(i, gid, txn=txn, flags=db.DB_APPEND)
    … …  
    8978    # let them be garbage collected.
    9079        recovered_txns=self.dbenv.txn_recover()
    91         self.assertEquals(self.num_txns,len(recovered_txns))
     80        self.assertEqual(self.num_txns,len(recovered_txns))
    9281        for gid,txn in recovered_txns :
    93             self.assert_(gid in txns)
     82            self.assertTrue(gid in txns)
    9483        del txn
    9584        del recovered_txns
    … …  
    10089    # discard them.
    10190        recovered_txns=self.dbenv.txn_recover()
    102         self.assertEquals(self.num_txns,len(recovered_txns))
     91        self.assertEqual(self.num_txns,len(recovered_txns))
    10392        discard_txns=set()
    10493        committed_txns=set()
    … …  
    123112    # around, and dispose them.
    124113        recovered_txns=self.dbenv.txn_recover()
    125         self.assertEquals(len(discard_txns),len(recovered_txns))
     114        self.assertEqual(len(discard_txns),len(recovered_txns))
    126115        for gid,txn in recovered_txns :
    127116            txn.abort()
    … …  
    134123    # Check also database size.
    135124        recovered_txns=self.dbenv.txn_recover()
    136         self.assert_(len(recovered_txns)==0)
    137         self.assertEquals(len(committed_txns),self.db.stat()["nkeys"])
     125        self.assertTrue(len(recovered_txns)==0)
     126        self.assertEqual(len(committed_txns),self.db.stat()["nkeys"])
    138127
    139128class DBTxn_distributedSYNC(DBTxn_distributed):

  • python/trunk/Lib/bsddb/test/test_early_close.py

    r2 r391  
    33"""
    44
    5 import os
     5import os, sys
    66import unittest
    77
    … …  
    156156        d = db.DB(dbenv)
    157157        txn = dbenv.txn_begin()
    158         if db.version() < (4,1) :
    159             d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE)
    160         else :
    161             d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE,
    162                     txn=txn)
     158        d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE,
     159                txn=txn)
    163160        d.put("XXX", "yyy", txn=txn)
    164161        txn.commit()
    … …  
    166163        c1 = d.cursor(txn)
    167164        c2 = c1.dup()
    168         self.assertEquals(("XXX", "yyy"), c1.first())
     165        self.assertEqual(("XXX", "yyy"), c1.first())
     166
     167        # Not interested in warnings about implicit close.
    169168        import warnings
    170         # Not interested in warnings about implicit close.
    171         with warnings.catch_warnings():
     169        if sys.version_info < (2, 6) :
     170            # Completely resetting the warning state is
     171            # problematic with python >=2.6 with -3 (py3k warning),
     172            # because some stdlib modules selectively ignores warnings.
    172173            warnings.simplefilter("ignore")
    173174            txn.commit()
     175            warnings.resetwarnings()
     176        else :
     177            # When we drop support for python 2.4
     178            # we could use: (in 2.5 we need a __future__ statement)
     179            #
     180            #    with warnings.catch_warnings():
     181            #        warnings.simplefilter("ignore")
     182            #        txn.commit()
     183            #
     184            # We can not use "with" as is, because it would be invalid syntax
     185            # in python 2.4 and (with no __future__) 2.5.
     186            # Here we simulate "with" following PEP 343 :
     187            w = warnings.catch_warnings()
     188            w.__enter__()
     189            try :
     190                warnings.simplefilter("ignore")
     191                txn.commit()
     192            finally :
     193                w.__exit__()
     194
    174195        self.assertRaises(db.DBCursorClosedError, c2.first)
    175196
    176     if db.version() > (4,3,0) :
    177         def test07_close_db_before_sequence(self):
    178             import os.path
    179             path=os.path.join(self.homeDir,self.filename)
    180             d = db.DB()
    181             d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
    182             dbs=db.DBSequence(d)
    183             d.close()  # This "close" should close the child DBSequence also
    184             dbs.close()  # If not closed, core dump (in Berkeley DB 4.6.*)
     197    def test07_close_db_before_sequence(self):
     198        import os.path
     199        path=os.path.join(self.homeDir,self.filename)
     200        d = db.DB()
     201        d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
     202        dbs=db.DBSequence(d)
     203        d.close()  # This "close" should close the child DBSequence also
     204        dbs.close()  # If not closed, core dump (in Berkeley DB 4.6.*)
    185205
    186206#----------------------------------------------------------------------

  • python/trunk/Lib/bsddb/test/test_get_none.py

    r2 r391  
    7777
    7878        self.assertNotEqual(rec, None)
    79         self.assert_(exceptionHappened)
     79        self.assertTrue(exceptionHappened)
    8080        self.assertEqual(count, len(string.letters))
    8181

  • python/trunk/Lib/bsddb/test/test_join.py

    r2 r391  
    5252        priDB = db.DB(self.env)
    5353        priDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE)
    54         map(lambda t, priDB=priDB: apply(priDB.put, t), ProductIndex)
     54        map(lambda t, priDB=priDB: priDB.put(*t), ProductIndex)
    5555
    5656        # create and populate secondary index
    … …  
    5858        secDB.set_flags(db.DB_DUP | db.DB_DUPSORT)
    5959        secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE)
    60         map(lambda t, secDB=secDB: apply(secDB.put, t), ColorIndex)
     60        map(lambda t, secDB=secDB: secDB.put(*t), ColorIndex)
    6161
    6262        sCursor = None
    … …  
    6868            # when running python -O
    6969            tmp = sCursor.set('red')
    70             self.assert_(tmp)
     70            self.assertTrue(tmp)
    7171
    7272            # FIXME: jCursor doesn't properly hold a reference to its

  • python/trunk/Lib/bsddb/test/test_lock.py

    r2 r391  
    2020
    2121class LockingTestCase(unittest.TestCase):
    22     import sys
    23     if sys.version_info[:3] < (2, 4, 0):
    24         def assertTrue(self, expr, msg=None):
    25             self.failUnless(expr,msg=msg)
    26 
    27 
    2822    def setUp(self):
    2923        self.homeDir = get_new_environment_path()
    … …  
    9084            t.join()
    9185
    92     def test03_lock_timeout(self):
     86        def test03_lock_timeout(self):
     87            self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT)
     88            self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 0)
     89            self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT)
     90            self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 0)
     91            self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT)
     92            self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 123456)
     93            self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT)
     94            self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 7890123)
     95
     96    def test04_lock_timeout2(self):
    9397        self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT)
    9498        self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT)
    … …  
    125129        end_time=time.time()
    126130        deadlock_detection.end=True
     131        # Floating point rounding
    127132        self.assertTrue((end_time-start_time) >= 0.0999)
    128133        self.env.lock_put(lock)

  • python/trunk/Lib/bsddb/test/test_misc.py

    r2 r391  
    22"""
    33
    4 import os
     4import os, sys
    55import unittest
    66
    … …  
    2626        env = db.DBEnv()
    2727        # check for crash fixed when db_home is used before open()
    28         self.assert_(env.db_home is None)
     28        self.assertTrue(env.db_home is None)
    2929        env.open(self.homeDir, db.DB_CREATE)
    30         import sys
    3130        if sys.version_info[0] < 3 :
    3231            self.assertEqual(self.homeDir, env.db_home)
    … …  
    3837        db.close()
    3938        rp = repr(db)
    40         self.assertEquals(rp, "{}")
     39        self.assertEqual(rp, "{}")
    4140
    4241    def test04_repr_db(self) :
    … …  
    4948        db = hashopen(self.filename)
    5049        rp = repr(db)
    51         self.assertEquals(rp, repr(d))
     50        self.assertEqual(rp, repr(d))
    5251        db.close()
    5352
    … …  
    9291
    9392    def test07_DB_set_flags_persists(self):
    94         if db.version() < (4,2):
    95             # The get_flags API required for this to work is only available
    96             # in Berkeley DB >= 4.2
    97             return
    9893        try:
    9994            db1 = db.DB()
    … …  
    120115
    121116
     117    def test08_ExceptionTypes(self) :
     118        self.assertTrue(issubclass(db.DBError, Exception))
     119        for i, j in db.__dict__.items() :
     120            if i.startswith("DB") and i.endswith("Error") :
     121                self.assertTrue(issubclass(j, db.DBError), msg=i)
     122                if i not in ("DBKeyEmptyError", "DBNotFoundError") :
     123                    self.assertFalse(issubclass(j, KeyError), msg=i)
     124
     125        # This two exceptions have two bases
     126        self.assertTrue(issubclass(db.DBKeyEmptyError, KeyError))
     127        self.assertTrue(issubclass(db.DBNotFoundError, KeyError))
     128
     129
    122130#----------------------------------------------------------------------
    123131

  • python/trunk/Lib/bsddb/test/test_pickle.py

    r2 r391  
    22import os
    33import pickle
    4 try:
    5     import cPickle
    6 except ImportError:
     4import sys
     5
     6if sys.version_info[0] < 3 :
     7    try:
     8        import cPickle
     9    except ImportError:
     10        cPickle = None
     11else :
    712    cPickle = None
     13
    814import unittest
    915

  • python/trunk/Lib/bsddb/test/test_queue.py

    r2 r391  
    100100            print "Running %s.test02_basicPost32..." % self.__class__.__name__
    101101
    102         if db.version() < (3, 2, 0):
    103             if verbose:
    104                 print "Test not run, DB not new enough..."
    105             return
    106 
    107102        d = db.DB()
    108103        d.set_re_len(40)  # Queues must be fixed length

  • python/trunk/Lib/bsddb/test/test_recno.py

    r2 r391  
    22"""
    33
    4 import os
     4import os, sys
    55import errno
    66from pprint import pprint
    … …  
    1515
    1616class SimpleRecnoTestCase(unittest.TestCase):
    17     import sys
    18     if sys.version_info[:3] < (2, 4, 0):
    19         def assertFalse(self, expr, msg=None):
    20             self.failIf(expr,msg=msg)
     17    if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
     18            (sys.version_info < (3, 2))) :
     19        def assertIsInstance(self, obj, datatype, msg=None) :
     20            return self.assertEqual(type(obj), datatype, msg=msg)
     21        def assertGreaterEqual(self, a, b, msg=None) :
     22            return self.assertTrue(a>=b, msg=msg)
     23
    2124
    2225    def setUp(self):
    … …  
    3942        for x in letters:
    4043            recno = d.append(x * 60)
    41             self.assertEqual(type(recno), type(0))
    42             self.assert_(recno >= 1)
     44            self.assertIsInstance(recno, int)
     45            self.assertGreaterEqual(recno, 1)
    4346            if verbose:
    4447                print recno,
    … …  
    5558                print data
    5659
    57             self.assertEqual(type(data), type(""))
     60            self.assertIsInstance(data, str)
    5861            self.assertEqual(data, d.get(recno))
    5962
    … …  
    6164            data = d[0]  # This should raise a KeyError!?!?!
    6265        except db.DBInvalidArgError, val:
    63             import sys
    64             if sys.version_info[0] < 3 :
     66            if sys.version_info < (2, 6) :
    6567                self.assertEqual(val[0], db.EINVAL)
    6668            else :
    … …  
    9698        if verbose:
    9799            print keys
    98         self.assertEqual(type(keys), type([]))
    99         self.assertEqual(type(keys[0]), type(123))
     100        self.assertIsInstance(keys, list)
     101        self.assertIsInstance(keys[0], int)
    100102        self.assertEqual(len(keys), len(d))
    101103
    … …  
    103105        if verbose:
    104106            pprint(items)
    105         self.assertEqual(type(items), type([]))
    106         self.assertEqual(type(items[0]), type(()))
     107        self.assertIsInstance(items, list)
     108        self.assertIsInstance(items[0], tuple)
    107109        self.assertEqual(len(items[0]), 2)
    108         self.assertEqual(type(items[0][0]), type(123))
    109         self.assertEqual(type(items[0][1]), type(""))
     110        self.assertIsInstance(items[0][0], int)
     111        self.assertIsInstance(items[0][1], str)
    110112        self.assertEqual(len(items), len(d))
    111113
    112         self.assert_(d.has_key(25))
     114        self.assertTrue(d.has_key(25))
    113115
    114116        del d[25]
    … …  
    182184                self.fail("unexpected DBKeyEmptyError exception")
    183185            else:
    184                 self.assertEqual(val[0], db.DB_KEYEMPTY)
     186                if sys.version_info < (2, 6) :
     187                    self.assertEqual(val[0], db.DB_KEYEMPTY)
     188                else :
     189                    self.assertEqual(val.args[0], db.DB_KEYEMPTY)
    185190                if verbose: print val
    186191        else:
    … …  
    226231
    227232        # get the text from the backing source
    228         text = open(source, 'r').read()
     233        f = open(source, 'r')
     234        text = f.read()
     235        f.close()
    229236        text = text.strip()
    230237        if verbose:
    … …  
    246253        d.close()
    247254
    248         text = open(source, 'r').read()
     255        f = open(source, 'r')
     256        text = f.read()
     257        f.close()
    249258        text = text.strip()
    250259        if verbose:
    … …  
    270279            d.append('bad' * 20)
    271280        except db.DBInvalidArgError, val:
    272             import sys
    273             if sys.version_info[0] < 3 :
     281            if sys.version_info < (2, 6) :
    274282                self.assertEqual(val[0], db.EINVAL)
    275283            else :
    … …  
    289297        d.close()
    290298
     299    def test04_get_size_empty(self) :
     300        d = db.DB()
     301        d.open(self.filename, dbtype=db.DB_RECNO, flags=db.DB_CREATE)
     302
     303        row_id = d.append(' ')
     304        self.assertEqual(1, d.get_size(key=row_id))
     305        row_id = d.append('')
     306        self.assertEqual(0, d.get_size(key=row_id))
     307
     308
     309
     310
    291311
    292312#----------------------------------------------------------------------

  • python/trunk/Lib/bsddb/test/test_replication.py

    r2 r391  
    55import time
    66import unittest
    7 import weakref
    87
    98from test_all import db, test_support, have_threads, verbose, \
    … …  
    1312#----------------------------------------------------------------------
    1413
    15 class DBReplicationManager(unittest.TestCase):
    16     import sys
    17     if sys.version_info[:3] < (2, 4, 0):
    18         def assertTrue(self, expr, msg=None):
    19             self.failUnless(expr,msg=msg)
    20 
     14class DBReplication(unittest.TestCase) :
    2115    def setUp(self) :
    2216        self.homeDirMaster = get_new_environment_path()
    … …  
    3630                db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0666)
    3731
    38         wr = weakref.ref(self)
    3932        self.confirmed_master=self.client_startupdone=False
    4033        def confirmed_master(a,b,c) :
    4134            if b==db.DB_EVENT_REP_MASTER :
    42                 self = wr()
    4335                self.confirmed_master=True
    4436
    4537        def client_startupdone(a,b,c) :
    4638            if b==db.DB_EVENT_REP_STARTUPDONE :
    47                 self = wr()
    4839                self.client_startupdone=True
    4940
    … …  
    6455        if self.dbMaster :
    6556            self.dbMaster.close()
     57
     58        # Here we assign dummy event handlers to allow GC of the test object.
     59        # Since the dummy handler doesn't use any outer scope variable, it
     60        # doesn't keep any reference to the test object.
     61        def dummy(*args) :
     62            pass
     63        self.dbenvMaster.set_event_notify(dummy)
     64        self.dbenvClient.set_event_notify(dummy)
     65
    6666        self.dbenvClient.close()
    6767        self.dbenvMaster.close()
    … …  
    6969        test_support.rmtree(self.homeDirMaster)
    7070
     71class DBReplicationManager(DBReplication) :
    7172    def test01_basic_replication(self) :
    7273        master_port = test_support.find_unused_port()
    73         self.dbenvMaster.repmgr_set_local_site("127.0.0.1", master_port)
    7474        client_port = test_support.find_unused_port()
    75         self.dbenvClient.repmgr_set_local_site("127.0.0.1", client_port)
    76         self.dbenvMaster.repmgr_add_remote_site("127.0.0.1", client_port)
    77         self.dbenvClient.repmgr_add_remote_site("127.0.0.1", master_port)
    78         self.dbenvMaster.rep_set_nsites(2)
    79         self.dbenvClient.rep_set_nsites(2)
     75        if db.version() >= (5, 2) :
     76            self.site = self.dbenvMaster.repmgr_site("127.0.0.1", master_port)
     77            self.site.set_config(db.DB_GROUP_CREATOR, True)
     78            self.site.set_config(db.DB_LOCAL_SITE, True)
     79            self.site2 = self.dbenvMaster.repmgr_site("127.0.0.1", client_port)
     80
     81            self.site3 = self.dbenvClient.repmgr_site("127.0.0.1", master_port)
     82            self.site3.set_config(db.DB_BOOTSTRAP_HELPER, True)
     83            self.site4 = self.dbenvClient.repmgr_site("127.0.0.1", client_port)
     84            self.site4.set_config(db.DB_LOCAL_SITE, True)
     85
     86            d = {
     87                    db.DB_BOOTSTRAP_HELPER: [False, False, True, False],
     88                    db.DB_GROUP_CREATOR: [True, False, False, False],
     89                    db.DB_LEGACY: [False, False, False, False],
     90                    db.DB_LOCAL_SITE: [True, False, False, True],
     91                    db.DB_REPMGR_PEER: [False, False, False, False ],
     92                }
     93
     94            for i, j in d.items() :
     95                for k, v in \
     96                        zip([self.site, self.site2, self.site3, self.site4], j) :
     97                    if v :
     98                        self.assertTrue(k.get_config(i))
     99                    else :
     100                        self.assertFalse(k.get_config(i))
     101
     102            self.assertNotEqual(self.site.get_eid(), self.site2.get_eid())
     103            self.assertNotEqual(self.site3.get_eid(), self.site4.get_eid())
     104
     105            for i, j in zip([self.site, self.site2, self.site3, self.site4], \
     106                    [master_port, client_port, master_port, client_port]) :
     107                addr = i.get_address()
     108                self.assertEqual(addr, ("127.0.0.1", j))
     109
     110            for i in [self.site, self.site2] :
     111                self.assertEqual(i.get_address(),
     112                        self.dbenvMaster.repmgr_site_by_eid(i.get_eid()).get_address())
     113            for i in [self.site3, self.site4] :
     114                self.assertEqual(i.get_address(),
     115                        self.dbenvClient.repmgr_site_by_eid(i.get_eid()).get_address())
     116        else :
     117            self.dbenvMaster.repmgr_set_local_site("127.0.0.1", master_port)
     118            self.dbenvClient.repmgr_set_local_site("127.0.0.1", client_port)
     119            self.dbenvMaster.repmgr_add_remote_site("127.0.0.1", client_port)
     120            self.dbenvClient.repmgr_add_remote_site("127.0.0.1", master_port)
     121
     122            self.dbenvMaster.rep_set_nsites(2)
     123            self.dbenvClient.rep_set_nsites(2)
     124
    80125        self.dbenvMaster.rep_set_priority(10)
    81126        self.dbenvClient.rep_set_priority(0)
    … …  
    83128        self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123)
    84129        self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321)
    85         self.assertEquals(self.dbenvMaster.rep_get_timeout(
     130        self.assertEqual(self.dbenvMaster.rep_get_timeout(
    86131            db.DB_REP_CONNECTION_RETRY), 100123)
    87         self.assertEquals(self.dbenvClient.rep_get_timeout(
     132        self.assertEqual(self.dbenvClient.rep_get_timeout(
    88133            db.DB_REP_CONNECTION_RETRY), 100321)
    89134
    90135        self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234)
    91136        self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432)
    92         self.assertEquals(self.dbenvMaster.rep_get_timeout(
     137        self.assertEqual(self.dbenvMaster.rep_get_timeout(
    93138            db.DB_REP_ELECTION_TIMEOUT), 100234)
    94         self.assertEquals(self.dbenvClient.rep_get_timeout(
     139        self.assertEqual(self.dbenvClient.rep_get_timeout(
    95140            db.DB_REP_ELECTION_TIMEOUT), 100432)
    96141
    97142        self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345)
    98143        self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543)
    99         self.assertEquals(self.dbenvMaster.rep_get_timeout(
     144        self.assertEqual(self.dbenvMaster.rep_get_timeout(
    100145            db.DB_REP_ELECTION_RETRY), 100345)
    101         self.assertEquals(self.dbenvClient.rep_get_timeout(
     146        self.assertEqual(self.dbenvClient.rep_get_timeout(
    102147            db.DB_REP_ELECTION_RETRY), 100543)
    103148
    … …  
    108153        self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT);
    109154
    110         self.assertEquals(self.dbenvMaster.rep_get_nsites(),2)
    111         self.assertEquals(self.dbenvClient.rep_get_nsites(),2)
    112         self.assertEquals(self.dbenvMaster.rep_get_priority(),10)
    113         self.assertEquals(self.dbenvClient.rep_get_priority(),0)
    114         self.assertEquals(self.dbenvMaster.repmgr_get_ack_policy(),
     155        self.assertEqual(self.dbenvMaster.rep_get_nsites(),2)
     156        self.assertEqual(self.dbenvClient.rep_get_nsites(),2)
     157        self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
     158        self.assertEqual(self.dbenvClient.rep_get_priority(),0)
     159        self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(),
    115160                db.DB_REPMGR_ACKS_ALL)
    116         self.assertEquals(self.dbenvClient.repmgr_get_ack_policy(),
     161        self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(),
    117162                db.DB_REPMGR_ACKS_ALL)
    118163
    … …  
    138183
    139184        d = self.dbenvMaster.repmgr_site_list()
    140         self.assertEquals(len(d), 1)
    141         self.assertEquals(d[0][0], "127.0.0.1")
    142         self.assertEquals(d[0][1], client_port)
    143         self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \
    144                 (d[0][2]==db.DB_REPMGR_DISCONNECTED))
     185        self.assertEqual(len(d), 1)
     186        d = d.values()[0]  # There is only one
     187        self.assertEqual(d[0], "127.0.0.1")
     188        self.assertEqual(d[1], client_port)
     189        self.assertTrue((d[2]==db.DB_REPMGR_CONNECTED) or \
     190                (d[2]==db.DB_REPMGR_DISCONNECTED))
    145191
    146192        d = self.dbenvClient.repmgr_site_list()
    147         self.assertEquals(len(d), 1)
    148         self.assertEquals(d[0][0], "127.0.0.1")
    149         self.assertEquals(d[0][1], master_port)
    150         self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \
    151                 (d[0][2]==db.DB_REPMGR_DISCONNECTED))
     193        self.assertEqual(len(d), 1)
     194        d = d.values()[0]  # There is only one
     195        self.assertEqual(d[0], "127.0.0.1")
     196        self.assertEqual(d[1], master_port)
     197        self.assertTrue((d[2]==db.DB_REPMGR_CONNECTED) or \
     198                (d[2]==db.DB_REPMGR_DISCONNECTED))
    152199
    153200        if db.version() >= (4,6) :
    … …  
    187234        timeout=time.time()+10
    188235        v=None
    189         while (time.time()<timeout) and (v==None) :
     236        while (time.time()<timeout) and (v is None) :
    190237            txn=self.dbenvClient.txn_begin()
    191238            v=self.dbClient.get("ABC", txn=txn)
    192239            txn.commit()
    193             if v==None :
     240            if v is None :
    194241                time.sleep(0.02)
    195242        # If startup did not happen before the timeout above, then this test
    … …  
    202249                "see issue 3892")
    203250        self.assertTrue(time.time()<timeout)
    204         self.assertEquals("123", v)
     251        self.assertEqual("123", v)
    205252
    206253        txn=self.dbenvMaster.txn_begin()
    … …  
    208255        txn.commit()
    209256        timeout=time.time()+10
    210         while (time.time()<timeout) and (v!=None) :
     257        while (time.time()<timeout) and (v is not None) :
    211258            txn=self.dbenvClient.txn_begin()
    212259            v=self.dbClient.get("ABC", txn=txn)
    213260            txn.commit()
    214             if v==None :
     261            if v is None :
    215262                time.sleep(0.02)
    216263        self.assertTrue(time.time()<timeout)
    217         self.assertEquals(None, v)
    218 
    219 class DBBaseReplication(DBReplicationManager):
     264        self.assertEqual(None, v)
     265
     266class DBBaseReplication(DBReplication) :
    220267    def setUp(self) :
    221         DBReplicationManager.setUp(self)
    222         wr = weakref.ref(self)
     268        DBReplication.setUp(self)
    223269        def confirmed_master(a,b,c) :
    224270            if (b == db.DB_EVENT_REP_MASTER) or (b == db.DB_EVENT_REP_ELECTED) :
    225                 self = wr()
    226271                self.confirmed_master = True
    227272
    228273        def client_startupdone(a,b,c) :
    229274            if b == db.DB_EVENT_REP_STARTUPDONE :
    230                 self = wr()
    231275                self.client_startupdone = True
    232276
    … …  
    241285        # do any routing decision
    242286        def m2c(dbenv, control, rec, lsnp, envid, flags) :
    243             self = wr()
    244287            self.m2c.put((control, rec))
    245288
    246289        def c2m(dbenv, control, rec, lsnp, envid, flags) :
    247             self = wr()
    248290            self.c2m.put((control, rec))
    249291
    … …  
    253295        self.dbenvClient.rep_set_priority(0)
    254296
    255         self.assertEquals(self.dbenvMaster.rep_get_priority(),10)
    256         self.assertEquals(self.dbenvClient.rep_get_priority(),0)
     297        self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
     298        self.assertEqual(self.dbenvClient.rep_get_priority(),0)
    257299
    258300        #self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True)
    … …  
    262304
    263305        def thread_master() :
    264             self = wr()
    265306            return self.thread_do(self.dbenvMaster, self.c2m, 3,
    266307                    self.master_doing_election, True)
    267308
    268309        def thread_client() :
    269             self = wr()
    270310            return self.thread_do(self.dbenvClient, self.m2c, 13,
    271311                    self.client_doing_election, False)
    … …  
    300340        self.t_m.join()
    301341        self.t_c.join()
     342
     343        # Here we assign dummy event handlers to allow GC of the test object.
     344        # Since the dummy handler doesn't use any outer scope variable, it
     345        # doesn't keep any reference to the test object.
     346        def dummy(*args) :
     347            pass
     348        self.dbenvMaster.set_event_notify(dummy)
     349        self.dbenvClient.set_event_notify(dummy)
     350        self.dbenvMaster.rep_set_transport(13,dummy)
     351        self.dbenvClient.rep_set_transport(3,dummy)
     352
    302353        self.dbenvClient.close()
    303354        self.dbenvMaster.close()
    … …  
    312363            while True :
    313364                v=q.get()
    314                 if v == None : return
     365                if v is None : return
    315366                env.rep_process_message(v[0], v[1], envid)
    316367
    … …  
    359410            break
    360411
     412        d = self.dbenvMaster.rep_stat(flags=db.DB_STAT_CLEAR);
     413        self.assertTrue("master_changes" in d)
     414
    361415        txn=self.dbenvMaster.txn_begin()
    362416        self.dbMaster.put("ABC", "123", txn=txn)
    … …  
    365419        timeout=time.time()+10
    366420        v=None
    367         while (time.time()<timeout) and (v==None) :
     421        while (time.time()<timeout) and (v is None) :
    368422            txn=self.dbenvClient.txn_begin()
    369423            v=self.dbClient.get("ABC", txn=txn)
    370424            txn.commit()
    371             if v==None :
     425            if v is None :
    372426                time.sleep(0.02)
    373427        self.assertTrue(time.time()<timeout)
    374         self.assertEquals("123", v)
     428        self.assertEqual("123", v)
    375429
    376430        txn=self.dbenvMaster.txn_begin()
    … …  
    378432        txn.commit()
    379433        timeout=time.time()+10
    380         while (time.time()<timeout) and (v!=None) :
     434        while (time.time()<timeout) and (v is not None) :
    381435            txn=self.dbenvClient.txn_begin()
    382436            v=self.dbClient.get("ABC", txn=txn)
    383437            txn.commit()
    384             if v==None :
     438            if v is None :
    385439                time.sleep(0.02)
    386440        self.assertTrue(time.time()<timeout)
    387         self.assertEquals(None, v)
     441        self.assertEqual(None, v)
    388442
    389443    if db.version() >= (4,7) :
    … …  
    405459                while True :
    406460                    v=q.get()
    407                     if v == None : return
     461                    if v is None : return
    408462                    r = env.rep_process_message(v[0],v[1],envid)
    409463                    if must_be_master and self.confirmed_master :
    … …  
    420474                                except db.DBRepUnavailError :
    421475                                    pass
    422 
    423476                        if not election_status[0] and not self.confirmed_master :
    424477                            from threading import Thread
    … …  
    449502
    450503            self.assertTrue(self.confirmed_master)
     504
     505            # Race condition showed up after upgrading to Solaris 10 Update 10
     506            # https://forums.oracle.com/forums/thread.jspa?messageID=9902860
     507            # jcea@jcea.es: See private email from Paula Bingham (Oracle),
     508            # in 20110929.
     509            while not (self.dbenvClient.rep_stat()["startup_complete"]) :
     510                pass
     511
     512    if db.version() >= (4,7) :
     513        def test04_test_clockskew(self) :
     514            fast, slow = 1234, 1230
     515            self.dbenvMaster.rep_set_clockskew(fast, slow)
     516            self.assertEqual((fast, slow),
     517                    self.dbenvMaster.rep_get_clockskew())
     518            self.basic_rep_threading()
    451519
    452520#----------------------------------------------------------------------

  • python/trunk/Lib/bsddb/test/test_sequence.py

    r2 r391  
    66
    77class DBSequenceTest(unittest.TestCase):
    8     import sys
    9     if sys.version_info[:3] < (2, 4, 0):
    10         def assertTrue(self, expr, msg=None):
    11             self.failUnless(expr,msg=msg)
    12 
    138    def setUp(self):
    149        self.int_32_max = 0x100000000
    … …  
    3833        start_value = 10 * self.int_32_max
    3934        self.assertEqual(0xA00000000, start_value)
    40         self.assertEquals(None, self.seq.init_value(start_value))
    41         self.assertEquals(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE))
    42         self.assertEquals(start_value, self.seq.get(5))
    43         self.assertEquals(start_value + 5, self.seq.get())
     35        self.assertEqual(None, self.seq.initial_value(start_value))
     36        self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE))
     37        self.assertEqual(start_value, self.seq.get(5))
     38        self.assertEqual(start_value + 5, self.seq.get())
    4439
    4540    def test_remove(self):
    4641        self.seq = db.DBSequence(self.d, flags=0)
    47         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    48         self.assertEquals(None, self.seq.remove(txn=None, flags=0))
     42        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     43        self.assertEqual(None, self.seq.remove(txn=None, flags=0))
    4944        del self.seq
    5045
    … …  
    5247        self.seq = db.DBSequence(self.d, flags=0)
    5348        key = 'foo'
    54         self.assertEquals(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE))
    55         self.assertEquals(key, self.seq.get_key())
     49        self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE))
     50        self.assertEqual(key, self.seq.get_key())
    5651
    5752    def test_get_dbp(self):
    5853        self.seq = db.DBSequence(self.d, flags=0)
    59         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    60         self.assertEquals(self.d, self.seq.get_dbp())
     54        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     55        self.assertEqual(self.d, self.seq.get_dbp())
    6156
    6257    def test_cachesize(self):
    6358        self.seq = db.DBSequence(self.d, flags=0)
    6459        cashe_size = 10
    65         self.assertEquals(None, self.seq.set_cachesize(cashe_size))
    66         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    67         self.assertEquals(cashe_size, self.seq.get_cachesize())
     60        self.assertEqual(None, self.seq.set_cachesize(cashe_size))
     61        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     62        self.assertEqual(cashe_size, self.seq.get_cachesize())
    6863
    6964    def test_flags(self):
    7065        self.seq = db.DBSequence(self.d, flags=0)
    7166        flag = db.DB_SEQ_WRAP;
    72         self.assertEquals(None, self.seq.set_flags(flag))
    73         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    74         self.assertEquals(flag, self.seq.get_flags() & flag)
     67        self.assertEqual(None, self.seq.set_flags(flag))
     68        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     69        self.assertEqual(flag, self.seq.get_flags() & flag)
    7570
    7671    def test_range(self):
    7772        self.seq = db.DBSequence(self.d, flags=0)
    7873        seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1)
    79         self.assertEquals(None, self.seq.set_range(seq_range))
    80         self.seq.init_value(seq_range[0])
    81         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    82         self.assertEquals(seq_range, self.seq.get_range())
     74        self.assertEqual(None, self.seq.set_range(seq_range))
     75        self.seq.initial_value(seq_range[0])
     76        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     77        self.assertEqual(seq_range, self.seq.get_range())
    8378
    8479    def test_stat(self):
    8580        self.seq = db.DBSequence(self.d, flags=0)
    86         self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
     81        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
    8782        stat = self.seq.stat()
    8883        for param in ('nowait', 'min', 'max', 'value', 'current',
    … …  
    107102        # We don't use both extremes because they are problematic
    108103        value_plus=(1L<<63)-2
    109         self.assertEquals(9223372036854775806L,value_plus)
     104        self.assertEqual(9223372036854775806L,value_plus)
    110105        value_minus=(-1L<<63)+1  # Two complement
    111         self.assertEquals(-9223372036854775807L,value_minus)
     106        self.assertEqual(-9223372036854775807L,value_minus)
    112107        self.seq = db.DBSequence(self.d, flags=0)
    113         self.assertEquals(None, self.seq.init_value(value_plus-1))
    114         self.assertEquals(None, self.seq.open(key='id', txn=None,
     108        self.assertEqual(None, self.seq.initial_value(value_plus-1))
     109        self.assertEqual(None, self.seq.open(key='id', txn=None,
    115110            flags=db.DB_CREATE))
    116         self.assertEquals(value_plus-1, self.seq.get(1))
    117         self.assertEquals(value_plus, self.seq.get(1))
     111        self.assertEqual(value_plus-1, self.seq.get(1))
     112        self.assertEqual(value_plus, self.seq.get(1))
    118113
    119114        self.seq.remove(txn=None, flags=0)
    120115
    121116        self.seq = db.DBSequence(self.d, flags=0)
    122         self.assertEquals(None, self.seq.init_value(value_minus))
    123         self.assertEquals(None, self.seq.open(key='id', txn=None,
     117        self.assertEqual(None, self.seq.initial_value(value_minus))
     118        self.assertEqual(None, self.seq.open(key='id', txn=None,
    124119            flags=db.DB_CREATE))
    125         self.assertEquals(value_minus, self.seq.get(1))
    126         self.assertEquals(value_minus+1, self.seq.get(1))
     120        self.assertEqual(value_minus, self.seq.get(1))
     121        self.assertEqual(value_minus+1, self.seq.get(1))
    127122
    128123    def test_multiple_close(self):
    … …  
    134129def test_suite():
    135130    suite = unittest.TestSuite()
    136     if db.version() >= (4,3):
    137         suite.addTest(unittest.makeSuite(DBSequenceTest))
     131    suite.addTest(unittest.makeSuite(DBSequenceTest))
    138132    return suite
    139133

  • python/trunk/Lib/bsddb/test/test_thread.py

    r2 r391  
    2222if have_threads :
    2323    from threading import Thread
    24     import sys
    2524    if sys.version_info[0] < 3 :
    2625        from threading import currentThread
    … …  
    3635    dbsetflags   = 0
    3736    envflags     = 0
    38 
    39     import sys
    40     if sys.version_info[:3] < (2, 4, 0):
    41         def assertTrue(self, expr, msg=None):
    42             self.failUnless(expr,msg=msg)
    4337
    4438    def setUp(self):
    … …  
    10094                        name = 'reader %d' % x,
    10195                        )#verbose = verbose)
    102             import sys
    10396            if sys.version_info[0] < 3 :
    10497                rt.setDaemon(True)
    … …  
    119112
    120113        for t in writers:
    121             import sys
    122114            if sys.version_info[0] < 3 :
    123115                t.setDaemon(True)
    … …  
    132124
    133125    def writerThread(self, d, keys, readers):
    134         import sys
    135126        if sys.version_info[0] < 3 :
    136127            name = currentThread().getName()
    … …  
    162153
    163154    def readerThread(self, d, readerNum):
    164         import sys
    165155        if sys.version_info[0] < 3 :
    166156            name = currentThread().getName()
    … …  
    232222                        name = 'reader %d' % x,
    233223                        )#verbose = verbose)
    234             import sys
    235224            if sys.version_info[0] < 3 :
    236225                rt.setDaemon(True)
    … …  
    251240
    252241        for t in writers:
    253             import sys
    254242            if sys.version_info[0] < 3 :
    255243                t.setDaemon(True)
    … …  
    264252
    265253    def writerThread(self, d, keys, readers):
    266         import sys
    267254        if sys.version_info[0] < 3 :
    268255            name = currentThread().getName()
    … …  
    291278
    292279    def readerThread(self, d, readerNum):
    293         import sys
    294280        if sys.version_info[0] < 3 :
    295281            name = currentThread().getName()
    … …  
    362348                        name = 'reader %d' % x,
    363349                        )#verbose = verbose)
    364             import sys
    365350            if sys.version_info[0] < 3 :
    366351                rt.setDaemon(True)
    … …  
    380365
    381366        dt = Thread(target = self.deadlockThread)
    382         import sys
    383367        if sys.version_info[0] < 3 :
    384368            dt.setDaemon(True)
    … …  
    388372
    389373        for t in writers:
    390             import sys
    391374            if sys.version_info[0] < 3 :
    392375                t.setDaemon(True)
    … …  
    404387
    405388    def writerThread(self, d, keys, readers):
    406         import sys
    407389        if sys.version_info[0] < 3 :
    408390            name = currentThread().getName()
    … …  
    425407            except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
    426408                if verbose:
    427                     print "%s: Aborting transaction (%s)" % (name, val[1])
     409                    if sys.version_info < (2, 6) :
     410                        print "%s: Aborting transaction (%s)" % (name, val[1])
     411                    else :
     412                        print "%s: Aborting transaction (%s)" % (name,
     413                                val.args[1])
    428414                txn.abort()
    429415
    … …  
    432418
    433419    def readerThread(self, d, readerNum):
    434         import sys
    435420        if sys.version_info[0] < 3 :
    436421            name = currentThread().getName()
    … …  
    456441            except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
    457442                if verbose:
    458                     print "%s: Aborting transaction (%s)" % (name, val[1])
     443                    if sys.version_info < (2, 6) :
     444                        print "%s: Aborting transaction (%s)" % (name, val[1])
     445                    else :
     446                        print "%s: Aborting transaction (%s)" % (name,
     447                                val.args[1])
    459448                c.close()
    460449                txn.abort()
Note: See TracChangeset for help on using the changeset viewer.