| 1 | """
|
|---|
| 2 | Basic TestCases for BTree and hash DBs, with and without a DBEnv, with
|
|---|
| 3 | various DB flags, etc.
|
|---|
| 4 | """
|
|---|
| 5 |
|
|---|
| 6 | import os
|
|---|
| 7 | import errno
|
|---|
| 8 | import string
|
|---|
| 9 | from pprint import pprint
|
|---|
| 10 | import unittest
|
|---|
| 11 | import time
|
|---|
| 12 | import sys
|
|---|
| 13 |
|
|---|
| 14 | from test_all import db, test_support, verbose, get_new_environment_path, \
|
|---|
| 15 | get_new_database_path
|
|---|
| 16 |
|
|---|
| 17 | DASH = '-'
|
|---|
| 18 |
|
|---|
| 19 |
|
|---|
| 20 | #----------------------------------------------------------------------
|
|---|
| 21 |
|
|---|
| 22 | class VersionTestCase(unittest.TestCase):
|
|---|
| 23 | def test00_version(self):
|
|---|
| 24 | info = db.version()
|
|---|
| 25 | if verbose:
|
|---|
| 26 | print '\n', '-=' * 20
|
|---|
| 27 | print 'bsddb.db.version(): %s' % (info, )
|
|---|
| 28 | print db.DB_VERSION_STRING
|
|---|
| 29 | print '-=' * 20
|
|---|
| 30 | self.assertEqual(info, (db.DB_VERSION_MAJOR, db.DB_VERSION_MINOR,
|
|---|
| 31 | db.DB_VERSION_PATCH))
|
|---|
| 32 |
|
|---|
| 33 | #----------------------------------------------------------------------
|
|---|
| 34 |
|
|---|
| 35 | class BasicTestCase(unittest.TestCase):
|
|---|
| 36 | dbtype = db.DB_UNKNOWN # must be set in derived class
|
|---|
| 37 | cachesize = (0, 1024*1024, 1)
|
|---|
| 38 | dbopenflags = 0
|
|---|
| 39 | dbsetflags = 0
|
|---|
| 40 | dbmode = 0660
|
|---|
| 41 | dbname = None
|
|---|
| 42 | useEnv = 0
|
|---|
| 43 | envflags = 0
|
|---|
| 44 | envsetflags = 0
|
|---|
| 45 |
|
|---|
| 46 | _numKeys = 1002 # PRIVATE. NOTE: must be an even value
|
|---|
| 47 |
|
|---|
| 48 | def setUp(self):
|
|---|
| 49 | if self.useEnv:
|
|---|
| 50 | self.homeDir=get_new_environment_path()
|
|---|
| 51 | try:
|
|---|
| 52 | self.env = db.DBEnv()
|
|---|
| 53 | self.env.set_lg_max(1024*1024)
|
|---|
| 54 | self.env.set_tx_max(30)
|
|---|
| 55 | self._t = int(time.time())
|
|---|
| 56 | self.env.set_tx_timestamp(self._t)
|
|---|
| 57 | self.env.set_flags(self.envsetflags, 1)
|
|---|
| 58 | self.env.open(self.homeDir, self.envflags | db.DB_CREATE)
|
|---|
| 59 | self.filename = "test"
|
|---|
| 60 | # Yes, a bare except is intended, since we're re-raising the exc.
|
|---|
| 61 | except:
|
|---|
| 62 | test_support.rmtree(self.homeDir)
|
|---|
| 63 | raise
|
|---|
| 64 | else:
|
|---|
| 65 | self.env = None
|
|---|
| 66 | self.filename = get_new_database_path()
|
|---|
| 67 |
|
|---|
| 68 | # create and open the DB
|
|---|
| 69 | 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]))
|
|---|
| 78 | self.d.set_flags(self.dbsetflags)
|
|---|
| 79 | if self.dbname:
|
|---|
| 80 | self.d.open(self.filename, self.dbname, self.dbtype,
|
|---|
| 81 | self.dbopenflags|db.DB_CREATE, self.dbmode)
|
|---|
| 82 | else:
|
|---|
| 83 | self.d.open(self.filename, # try out keyword args
|
|---|
| 84 | mode = self.dbmode,
|
|---|
| 85 | dbtype = self.dbtype,
|
|---|
| 86 | flags = self.dbopenflags|db.DB_CREATE)
|
|---|
| 87 |
|
|---|
| 88 | if not self.useEnv:
|
|---|
| 89 | self.assertRaises(db.DBInvalidArgError,
|
|---|
| 90 | self.d.set_cachesize, *self.cachesize)
|
|---|
| 91 |
|
|---|
| 92 | self.populateDB()
|
|---|
| 93 |
|
|---|
| 94 |
|
|---|
| 95 | def tearDown(self):
|
|---|
| 96 | self.d.close()
|
|---|
| 97 | if self.env is not None:
|
|---|
| 98 | self.env.close()
|
|---|
| 99 | test_support.rmtree(self.homeDir)
|
|---|
| 100 | else:
|
|---|
| 101 | os.remove(self.filename)
|
|---|
| 102 |
|
|---|
| 103 |
|
|---|
| 104 |
|
|---|
| 105 | def populateDB(self, _txn=None):
|
|---|
| 106 | d = self.d
|
|---|
| 107 |
|
|---|
| 108 | for x in range(self._numKeys//2):
|
|---|
| 109 | key = '%04d' % (self._numKeys - x) # insert keys in reverse order
|
|---|
| 110 | data = self.makeData(key)
|
|---|
| 111 | d.put(key, data, _txn)
|
|---|
| 112 |
|
|---|
| 113 | d.put('empty value', '', _txn)
|
|---|
| 114 |
|
|---|
| 115 | for x in range(self._numKeys//2-1):
|
|---|
| 116 | key = '%04d' % x # and now some in forward order
|
|---|
| 117 | data = self.makeData(key)
|
|---|
| 118 | d.put(key, data, _txn)
|
|---|
| 119 |
|
|---|
| 120 | if _txn:
|
|---|
| 121 | _txn.commit()
|
|---|
| 122 |
|
|---|
| 123 | num = len(d)
|
|---|
| 124 | if verbose:
|
|---|
| 125 | print "created %d records" % num
|
|---|
| 126 |
|
|---|
| 127 |
|
|---|
| 128 | def makeData(self, key):
|
|---|
| 129 | return DASH.join([key] * 5)
|
|---|
| 130 |
|
|---|
| 131 |
|
|---|
| 132 |
|
|---|
| 133 | #----------------------------------------
|
|---|
| 134 |
|
|---|
| 135 | def test01_GetsAndPuts(self):
|
|---|
| 136 | d = self.d
|
|---|
| 137 |
|
|---|
| 138 | if verbose:
|
|---|
| 139 | print '\n', '-=' * 30
|
|---|
| 140 | print "Running %s.test01_GetsAndPuts..." % self.__class__.__name__
|
|---|
| 141 |
|
|---|
| 142 | for key in ['0001', '0100', '0400', '0700', '0999']:
|
|---|
| 143 | data = d.get(key)
|
|---|
| 144 | if verbose:
|
|---|
| 145 | print data
|
|---|
| 146 |
|
|---|
| 147 | self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')
|
|---|
| 148 |
|
|---|
| 149 | # By default non-existent keys return None...
|
|---|
| 150 | self.assertEqual(d.get('abcd'), None)
|
|---|
| 151 |
|
|---|
| 152 | # ...but they raise exceptions in other situations. Call
|
|---|
| 153 | # set_get_returns_none() to change it.
|
|---|
| 154 | try:
|
|---|
| 155 | d.delete('abcd')
|
|---|
| 156 | except db.DBNotFoundError, val:
|
|---|
| 157 | if sys.version_info < (2, 6) :
|
|---|
| 158 | self.assertEqual(val[0], db.DB_NOTFOUND)
|
|---|
| 159 | else :
|
|---|
| 160 | self.assertEqual(val.args[0], db.DB_NOTFOUND)
|
|---|
| 161 | if verbose: print val
|
|---|
| 162 | else:
|
|---|
| 163 | self.fail("expected exception")
|
|---|
| 164 |
|
|---|
| 165 |
|
|---|
| 166 | d.put('abcd', 'a new record')
|
|---|
| 167 | self.assertEqual(d.get('abcd'), 'a new record')
|
|---|
| 168 |
|
|---|
| 169 | d.put('abcd', 'same key')
|
|---|
| 170 | if self.dbsetflags & db.DB_DUP:
|
|---|
| 171 | self.assertEqual(d.get('abcd'), 'a new record')
|
|---|
| 172 | else:
|
|---|
| 173 | self.assertEqual(d.get('abcd'), 'same key')
|
|---|
| 174 |
|
|---|
| 175 |
|
|---|
| 176 | try:
|
|---|
| 177 | d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE)
|
|---|
| 178 | except db.DBKeyExistError, val:
|
|---|
| 179 | if sys.version_info < (2, 6) :
|
|---|
| 180 | self.assertEqual(val[0], db.DB_KEYEXIST)
|
|---|
| 181 | else :
|
|---|
| 182 | self.assertEqual(val.args[0], db.DB_KEYEXIST)
|
|---|
| 183 | if verbose: print val
|
|---|
| 184 | else:
|
|---|
| 185 | self.fail("expected exception")
|
|---|
| 186 |
|
|---|
| 187 | if self.dbsetflags & db.DB_DUP:
|
|---|
| 188 | self.assertEqual(d.get('abcd'), 'a new record')
|
|---|
| 189 | else:
|
|---|
| 190 | self.assertEqual(d.get('abcd'), 'same key')
|
|---|
| 191 |
|
|---|
| 192 |
|
|---|
| 193 | d.sync()
|
|---|
| 194 | d.close()
|
|---|
| 195 | del d
|
|---|
| 196 |
|
|---|
| 197 | self.d = db.DB(self.env)
|
|---|
| 198 | if self.dbname:
|
|---|
| 199 | self.d.open(self.filename, self.dbname)
|
|---|
| 200 | else:
|
|---|
| 201 | self.d.open(self.filename)
|
|---|
| 202 | d = self.d
|
|---|
| 203 |
|
|---|
| 204 | self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321')
|
|---|
| 205 | if self.dbsetflags & db.DB_DUP:
|
|---|
| 206 | self.assertEqual(d.get('abcd'), 'a new record')
|
|---|
| 207 | else:
|
|---|
| 208 | self.assertEqual(d.get('abcd'), 'same key')
|
|---|
| 209 |
|
|---|
| 210 | rec = d.get_both('0555', '0555-0555-0555-0555-0555')
|
|---|
| 211 | if verbose:
|
|---|
| 212 | print rec
|
|---|
| 213 |
|
|---|
| 214 | self.assertEqual(d.get_both('0555', 'bad data'), None)
|
|---|
| 215 |
|
|---|
| 216 | # test default value
|
|---|
| 217 | data = d.get('bad key', 'bad data')
|
|---|
| 218 | self.assertEqual(data, 'bad data')
|
|---|
| 219 |
|
|---|
| 220 | # any object can pass through
|
|---|
| 221 | data = d.get('bad key', self)
|
|---|
| 222 | self.assertEqual(data, self)
|
|---|
| 223 |
|
|---|
| 224 | s = d.stat()
|
|---|
| 225 | self.assertEqual(type(s), type({}))
|
|---|
| 226 | if verbose:
|
|---|
| 227 | print 'd.stat() returned this dictionary:'
|
|---|
| 228 | pprint(s)
|
|---|
| 229 |
|
|---|
| 230 |
|
|---|
| 231 | #----------------------------------------
|
|---|
| 232 |
|
|---|
| 233 | def test02_DictionaryMethods(self):
|
|---|
| 234 | d = self.d
|
|---|
| 235 |
|
|---|
| 236 | if verbose:
|
|---|
| 237 | print '\n', '-=' * 30
|
|---|
| 238 | print "Running %s.test02_DictionaryMethods..." % \
|
|---|
| 239 | self.__class__.__name__
|
|---|
| 240 |
|
|---|
| 241 | for key in ['0002', '0101', '0401', '0701', '0998']:
|
|---|
| 242 | data = d[key]
|
|---|
| 243 | self.assertEqual(data, self.makeData(key))
|
|---|
| 244 | if verbose:
|
|---|
| 245 | print data
|
|---|
| 246 |
|
|---|
| 247 | self.assertEqual(len(d), self._numKeys)
|
|---|
| 248 | keys = d.keys()
|
|---|
| 249 | self.assertEqual(len(keys), self._numKeys)
|
|---|
| 250 | self.assertEqual(type(keys), type([]))
|
|---|
| 251 |
|
|---|
| 252 | d['new record'] = 'a new record'
|
|---|
| 253 | self.assertEqual(len(d), self._numKeys+1)
|
|---|
| 254 | keys = d.keys()
|
|---|
| 255 | self.assertEqual(len(keys), self._numKeys+1)
|
|---|
| 256 |
|
|---|
| 257 | d['new record'] = 'a replacement record'
|
|---|
| 258 | self.assertEqual(len(d), self._numKeys+1)
|
|---|
| 259 | keys = d.keys()
|
|---|
| 260 | self.assertEqual(len(keys), self._numKeys+1)
|
|---|
| 261 |
|
|---|
| 262 | if verbose:
|
|---|
| 263 | print "the first 10 keys are:"
|
|---|
| 264 | pprint(keys[:10])
|
|---|
| 265 |
|
|---|
| 266 | self.assertEqual(d['new record'], 'a replacement record')
|
|---|
| 267 |
|
|---|
| 268 | # We check also the positional parameter
|
|---|
| 269 | self.assertEqual(d.has_key('0001', None), 1)
|
|---|
| 270 | # We check also the keyword parameter
|
|---|
| 271 | self.assertEqual(d.has_key('spam', txn=None), 0)
|
|---|
| 272 |
|
|---|
| 273 | items = d.items()
|
|---|
| 274 | self.assertEqual(len(items), self._numKeys+1)
|
|---|
| 275 | self.assertEqual(type(items), type([]))
|
|---|
| 276 | self.assertEqual(type(items[0]), type(()))
|
|---|
| 277 | self.assertEqual(len(items[0]), 2)
|
|---|
| 278 |
|
|---|
| 279 | if verbose:
|
|---|
| 280 | print "the first 10 items are:"
|
|---|
| 281 | pprint(items[:10])
|
|---|
| 282 |
|
|---|
| 283 | values = d.values()
|
|---|
| 284 | self.assertEqual(len(values), self._numKeys+1)
|
|---|
| 285 | self.assertEqual(type(values), type([]))
|
|---|
| 286 |
|
|---|
| 287 | if verbose:
|
|---|
| 288 | print "the first 10 values are:"
|
|---|
| 289 | pprint(values[:10])
|
|---|
| 290 |
|
|---|
| 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)
|
|---|
| 306 |
|
|---|
| 307 |
|
|---|
| 308 | #----------------------------------------
|
|---|
| 309 |
|
|---|
| 310 | def test03_SimpleCursorStuff(self, get_raises_error=0, set_raises_error=0):
|
|---|
| 311 | if verbose:
|
|---|
| 312 | print '\n', '-=' * 30
|
|---|
| 313 | print "Running %s.test03_SimpleCursorStuff (get_error %s, set_error %s)..." % \
|
|---|
| 314 | (self.__class__.__name__, get_raises_error, set_raises_error)
|
|---|
| 315 |
|
|---|
| 316 | if self.env and self.dbopenflags & db.DB_AUTO_COMMIT:
|
|---|
| 317 | txn = self.env.txn_begin()
|
|---|
| 318 | else:
|
|---|
| 319 | txn = None
|
|---|
| 320 | c = self.d.cursor(txn=txn)
|
|---|
| 321 |
|
|---|
| 322 | rec = c.first()
|
|---|
| 323 | count = 0
|
|---|
| 324 | while rec is not None:
|
|---|
| 325 | count = count + 1
|
|---|
| 326 | if verbose and count % 100 == 0:
|
|---|
| 327 | print rec
|
|---|
| 328 | try:
|
|---|
| 329 | rec = c.next()
|
|---|
| 330 | except db.DBNotFoundError, val:
|
|---|
| 331 | if get_raises_error:
|
|---|
| 332 | if sys.version_info < (2, 6) :
|
|---|
| 333 | self.assertEqual(val[0], db.DB_NOTFOUND)
|
|---|
| 334 | else :
|
|---|
| 335 | self.assertEqual(val.args[0], db.DB_NOTFOUND)
|
|---|
| 336 | if verbose: print val
|
|---|
| 337 | rec = None
|
|---|
| 338 | else:
|
|---|
| 339 | self.fail("unexpected DBNotFoundError")
|
|---|
| 340 | self.assertEqual(c.get_current_size(), len(c.current()[1]),
|
|---|
| 341 | "%s != len(%r)" % (c.get_current_size(), c.current()[1]))
|
|---|
| 342 |
|
|---|
| 343 | self.assertEqual(count, self._numKeys)
|
|---|
| 344 |
|
|---|
| 345 |
|
|---|
| 346 | rec = c.last()
|
|---|
| 347 | count = 0
|
|---|
| 348 | while rec is not None:
|
|---|
| 349 | count = count + 1
|
|---|
| 350 | if verbose and count % 100 == 0:
|
|---|
| 351 | print rec
|
|---|
| 352 | try:
|
|---|
| 353 | rec = c.prev()
|
|---|
| 354 | except db.DBNotFoundError, val:
|
|---|
| 355 | if get_raises_error:
|
|---|
| 356 | if sys.version_info < (2, 6) :
|
|---|
| 357 | self.assertEqual(val[0], db.DB_NOTFOUND)
|
|---|
| 358 | else :
|
|---|
| 359 | self.assertEqual(val.args[0], db.DB_NOTFOUND)
|
|---|
| 360 | if verbose: print val
|
|---|
| 361 | rec = None
|
|---|
| 362 | else:
|
|---|
| 363 | self.fail("unexpected DBNotFoundError")
|
|---|
| 364 |
|
|---|
| 365 | self.assertEqual(count, self._numKeys)
|
|---|
| 366 |
|
|---|
| 367 | rec = c.set('0505')
|
|---|
| 368 | rec2 = c.current()
|
|---|
| 369 | self.assertEqual(rec, rec2)
|
|---|
| 370 | self.assertEqual(rec[0], '0505')
|
|---|
| 371 | self.assertEqual(rec[1], self.makeData('0505'))
|
|---|
| 372 | self.assertEqual(c.get_current_size(), len(rec[1]))
|
|---|
| 373 |
|
|---|
| 374 | # make sure we get empty values properly
|
|---|
| 375 | rec = c.set('empty value')
|
|---|
| 376 | self.assertEqual(rec[1], '')
|
|---|
| 377 | self.assertEqual(c.get_current_size(), 0)
|
|---|
| 378 |
|
|---|
| 379 | try:
|
|---|
| 380 | n = c.set('bad key')
|
|---|
| 381 | except db.DBNotFoundError, val:
|
|---|
| 382 | if sys.version_info < (2, 6) :
|
|---|
| 383 | self.assertEqual(val[0], db.DB_NOTFOUND)
|
|---|
| 384 | else :
|
|---|
| 385 | self.assertEqual(val.args[0], db.DB_NOTFOUND)
|
|---|
| 386 | if verbose: print val
|
|---|
| 387 | else:
|
|---|
| 388 | if set_raises_error:
|
|---|
| 389 | self.fail("expected exception")
|
|---|
| 390 | if n is not None:
|
|---|
| 391 | self.fail("expected None: %r" % (n,))
|
|---|
| 392 |
|
|---|
| 393 | rec = c.get_both('0404', self.makeData('0404'))
|
|---|
| 394 | self.assertEqual(rec, ('0404', self.makeData('0404')))
|
|---|
| 395 |
|
|---|
| 396 | try:
|
|---|
| 397 | n = c.get_both('0404', 'bad data')
|
|---|
| 398 | except db.DBNotFoundError, val:
|
|---|
| 399 | if sys.version_info < (2, 6) :
|
|---|
| 400 | self.assertEqual(val[0], db.DB_NOTFOUND)
|
|---|
| 401 | else :
|
|---|
| 402 | self.assertEqual(val.args[0], db.DB_NOTFOUND)
|
|---|
| 403 | if verbose: print val
|
|---|
| 404 | else:
|
|---|
| 405 | if get_raises_error:
|
|---|
| 406 | self.fail("expected exception")
|
|---|
| 407 | if n is not None:
|
|---|
| 408 | self.fail("expected None: %r" % (n,))
|
|---|
| 409 |
|
|---|
| 410 | if self.d.get_type() == db.DB_BTREE:
|
|---|
| 411 | rec = c.set_range('011')
|
|---|
| 412 | if verbose:
|
|---|
| 413 | print "searched for '011', found: ", rec
|
|---|
| 414 |
|
|---|
| 415 | rec = c.set_range('011',dlen=0,doff=0)
|
|---|
| 416 | if verbose:
|
|---|
| 417 | print "searched (partial) for '011', found: ", rec
|
|---|
| 418 | if rec[1] != '': self.fail('expected empty data portion')
|
|---|
| 419 |
|
|---|
| 420 | ev = c.set_range('empty value')
|
|---|
| 421 | if verbose:
|
|---|
| 422 | print "search for 'empty value' returned", ev
|
|---|
| 423 | if ev[1] != '': self.fail('empty value lookup failed')
|
|---|
| 424 |
|
|---|
| 425 | c.set('0499')
|
|---|
| 426 | c.delete()
|
|---|
| 427 | try:
|
|---|
| 428 | rec = c.current()
|
|---|
| 429 | except db.DBKeyEmptyError, val:
|
|---|
| 430 | if get_raises_error:
|
|---|
| 431 | if sys.version_info < (2, 6) :
|
|---|
| 432 | self.assertEqual(val[0], db.DB_KEYEMPTY)
|
|---|
| 433 | else :
|
|---|
| 434 | self.assertEqual(val.args[0], db.DB_KEYEMPTY)
|
|---|
| 435 | if verbose: print val
|
|---|
| 436 | else:
|
|---|
| 437 | self.fail("unexpected DBKeyEmptyError")
|
|---|
| 438 | else:
|
|---|
| 439 | if get_raises_error:
|
|---|
| 440 | self.fail('DBKeyEmptyError exception expected')
|
|---|
| 441 |
|
|---|
| 442 | c.next()
|
|---|
| 443 | c2 = c.dup(db.DB_POSITION)
|
|---|
| 444 | self.assertEqual(c.current(), c2.current())
|
|---|
| 445 |
|
|---|
| 446 | c2.put('', 'a new value', db.DB_CURRENT)
|
|---|
| 447 | self.assertEqual(c.current(), c2.current())
|
|---|
| 448 | self.assertEqual(c.current()[1], 'a new value')
|
|---|
| 449 |
|
|---|
| 450 | c2.put('', 'er', db.DB_CURRENT, dlen=0, doff=5)
|
|---|
| 451 | self.assertEqual(c2.current()[1], 'a newer value')
|
|---|
| 452 |
|
|---|
| 453 | c.close()
|
|---|
| 454 | c2.close()
|
|---|
| 455 | if txn:
|
|---|
| 456 | txn.commit()
|
|---|
| 457 |
|
|---|
| 458 | # time to abuse the closed cursors and hope we don't crash
|
|---|
| 459 | methods_to_test = {
|
|---|
| 460 | 'current': (),
|
|---|
| 461 | 'delete': (),
|
|---|
| 462 | 'dup': (db.DB_POSITION,),
|
|---|
| 463 | 'first': (),
|
|---|
| 464 | 'get': (0,),
|
|---|
| 465 | 'next': (),
|
|---|
| 466 | 'prev': (),
|
|---|
| 467 | 'last': (),
|
|---|
| 468 | 'put':('', 'spam', db.DB_CURRENT),
|
|---|
| 469 | 'set': ("0505",),
|
|---|
| 470 | }
|
|---|
| 471 | for method, args in methods_to_test.items():
|
|---|
| 472 | try:
|
|---|
| 473 | if verbose:
|
|---|
| 474 | print "attempting to use a closed cursor's %s method" % \
|
|---|
| 475 | method
|
|---|
| 476 | # a bug may cause a NULL pointer dereference...
|
|---|
| 477 | getattr(c, method)(*args)
|
|---|
| 478 | except db.DBError, val:
|
|---|
| 479 | if sys.version_info < (2, 6) :
|
|---|
| 480 | self.assertEqual(val[0], 0)
|
|---|
| 481 | else :
|
|---|
| 482 | self.assertEqual(val.args[0], 0)
|
|---|
| 483 | if verbose: print val
|
|---|
| 484 | else:
|
|---|
| 485 | self.fail("no exception raised when using a buggy cursor's"
|
|---|
| 486 | "%s method" % method)
|
|---|
| 487 |
|
|---|
| 488 | #
|
|---|
| 489 | # free cursor referencing a closed database, it should not barf:
|
|---|
| 490 | #
|
|---|
| 491 | oldcursor = self.d.cursor(txn=txn)
|
|---|
| 492 | self.d.close()
|
|---|
| 493 |
|
|---|
| 494 | # this would originally cause a segfault when the cursor for a
|
|---|
| 495 | # closed database was cleaned up. it should not anymore.
|
|---|
| 496 | # SF pybsddb bug id 667343
|
|---|
| 497 | del oldcursor
|
|---|
| 498 |
|
|---|
| 499 | def test03b_SimpleCursorWithoutGetReturnsNone0(self):
|
|---|
| 500 | # same test but raise exceptions instead of returning None
|
|---|
| 501 | if verbose:
|
|---|
| 502 | print '\n', '-=' * 30
|
|---|
| 503 | print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \
|
|---|
| 504 | self.__class__.__name__
|
|---|
| 505 |
|
|---|
| 506 | old = self.d.set_get_returns_none(0)
|
|---|
| 507 | self.assertEqual(old, 2)
|
|---|
| 508 | self.test03_SimpleCursorStuff(get_raises_error=1, set_raises_error=1)
|
|---|
| 509 |
|
|---|
| 510 | def test03b_SimpleCursorWithGetReturnsNone1(self):
|
|---|
| 511 | # same test but raise exceptions instead of returning None
|
|---|
| 512 | if verbose:
|
|---|
| 513 | print '\n', '-=' * 30
|
|---|
| 514 | print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \
|
|---|
| 515 | self.__class__.__name__
|
|---|
| 516 |
|
|---|
| 517 | old = self.d.set_get_returns_none(1)
|
|---|
| 518 | self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=1)
|
|---|
| 519 |
|
|---|
| 520 |
|
|---|
| 521 | def test03c_SimpleCursorGetReturnsNone2(self):
|
|---|
| 522 | # same test but raise exceptions instead of returning None
|
|---|
| 523 | if verbose:
|
|---|
| 524 | print '\n', '-=' * 30
|
|---|
| 525 | print "Running %s.test03c_SimpleCursorStuffWithoutSetReturnsNone..." % \
|
|---|
| 526 | self.__class__.__name__
|
|---|
| 527 |
|
|---|
| 528 | old = self.d.set_get_returns_none(1)
|
|---|
| 529 | self.assertEqual(old, 2)
|
|---|
| 530 | old = self.d.set_get_returns_none(2)
|
|---|
| 531 | self.assertEqual(old, 1)
|
|---|
| 532 | self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=0)
|
|---|
| 533 |
|
|---|
| 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 |
|
|---|
| 543 | #----------------------------------------
|
|---|
| 544 |
|
|---|
| 545 | def test04_PartialGetAndPut(self):
|
|---|
| 546 | d = self.d
|
|---|
| 547 | if verbose:
|
|---|
| 548 | print '\n', '-=' * 30
|
|---|
| 549 | print "Running %s.test04_PartialGetAndPut..." % \
|
|---|
| 550 | self.__class__.__name__
|
|---|
| 551 |
|
|---|
| 552 | key = "partialTest"
|
|---|
| 553 | data = "1" * 1000 + "2" * 1000
|
|---|
| 554 | d.put(key, data)
|
|---|
| 555 | self.assertEqual(d.get(key), data)
|
|---|
| 556 | self.assertEqual(d.get(key, dlen=20, doff=990),
|
|---|
| 557 | ("1" * 10) + ("2" * 10))
|
|---|
| 558 |
|
|---|
| 559 | d.put("partialtest2", ("1" * 30000) + "robin" )
|
|---|
| 560 | self.assertEqual(d.get("partialtest2", dlen=5, doff=30000), "robin")
|
|---|
| 561 |
|
|---|
| 562 | # There seems to be a bug in DB here... Commented out the test for
|
|---|
| 563 | # now.
|
|---|
| 564 | ##self.assertEqual(d.get("partialtest2", dlen=5, doff=30010), "")
|
|---|
| 565 |
|
|---|
| 566 | if self.dbsetflags != db.DB_DUP:
|
|---|
| 567 | # Partial put with duplicate records requires a cursor
|
|---|
| 568 | d.put(key, "0000", dlen=2000, doff=0)
|
|---|
| 569 | self.assertEqual(d.get(key), "0000")
|
|---|
| 570 |
|
|---|
| 571 | d.put(key, "1111", dlen=1, doff=2)
|
|---|
| 572 | self.assertEqual(d.get(key), "0011110")
|
|---|
| 573 |
|
|---|
| 574 | #----------------------------------------
|
|---|
| 575 |
|
|---|
| 576 | def test05_GetSize(self):
|
|---|
| 577 | d = self.d
|
|---|
| 578 | if verbose:
|
|---|
| 579 | print '\n', '-=' * 30
|
|---|
| 580 | print "Running %s.test05_GetSize..." % self.__class__.__name__
|
|---|
| 581 |
|
|---|
| 582 | for i in range(1, 50000, 500):
|
|---|
| 583 | key = "size%s" % i
|
|---|
| 584 | #print "before ", i,
|
|---|
| 585 | d.put(key, "1" * i)
|
|---|
| 586 | #print "after",
|
|---|
| 587 | self.assertEqual(d.get_size(key), i)
|
|---|
| 588 | #print "done"
|
|---|
| 589 |
|
|---|
| 590 | #----------------------------------------
|
|---|
| 591 |
|
|---|
| 592 | def test06_Truncate(self):
|
|---|
| 593 | d = self.d
|
|---|
| 594 | if verbose:
|
|---|
| 595 | print '\n', '-=' * 30
|
|---|
| 596 | print "Running %s.test06_Truncate..." % self.__class__.__name__
|
|---|
| 597 |
|
|---|
| 598 | d.put("abcde", "ABCDE");
|
|---|
| 599 | num = d.truncate()
|
|---|
| 600 | self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
|
|---|
| 601 | num = d.truncate()
|
|---|
| 602 | self.assertEqual(num, 0,
|
|---|
| 603 | "truncate on empty DB returned nonzero (%r)" % (num,))
|
|---|
| 604 |
|
|---|
| 605 | #----------------------------------------
|
|---|
| 606 |
|
|---|
| 607 | def test07_verify(self):
|
|---|
| 608 | # Verify bug solved in 4.7.3pre8
|
|---|
| 609 | self.d.close()
|
|---|
| 610 | d = db.DB(self.env)
|
|---|
| 611 | d.verify(self.filename)
|
|---|
| 612 |
|
|---|
| 613 |
|
|---|
| 614 | #----------------------------------------
|
|---|
| 615 |
|
|---|
| 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 | #----------------------------------------
|
|---|
| 643 |
|
|---|
| 644 | #----------------------------------------------------------------------
|
|---|
| 645 |
|
|---|
| 646 |
|
|---|
| 647 | class BasicBTreeTestCase(BasicTestCase):
|
|---|
| 648 | dbtype = db.DB_BTREE
|
|---|
| 649 |
|
|---|
| 650 |
|
|---|
| 651 | class BasicHashTestCase(BasicTestCase):
|
|---|
| 652 | dbtype = db.DB_HASH
|
|---|
| 653 |
|
|---|
| 654 |
|
|---|
| 655 | class BasicBTreeWithThreadFlagTestCase(BasicTestCase):
|
|---|
| 656 | dbtype = db.DB_BTREE
|
|---|
| 657 | dbopenflags = db.DB_THREAD
|
|---|
| 658 |
|
|---|
| 659 |
|
|---|
| 660 | class BasicHashWithThreadFlagTestCase(BasicTestCase):
|
|---|
| 661 | dbtype = db.DB_HASH
|
|---|
| 662 | dbopenflags = db.DB_THREAD
|
|---|
| 663 |
|
|---|
| 664 |
|
|---|
| 665 | class BasicWithEnvTestCase(BasicTestCase):
|
|---|
| 666 | dbopenflags = db.DB_THREAD
|
|---|
| 667 | useEnv = 1
|
|---|
| 668 | envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
|
|---|
| 669 |
|
|---|
| 670 | #----------------------------------------
|
|---|
| 671 |
|
|---|
| 672 | def test09_EnvRemoveAndRename(self):
|
|---|
| 673 | if not self.env:
|
|---|
| 674 | return
|
|---|
| 675 |
|
|---|
| 676 | if verbose:
|
|---|
| 677 | print '\n', '-=' * 30
|
|---|
| 678 | print "Running %s.test09_EnvRemoveAndRename..." % self.__class__.__name__
|
|---|
| 679 |
|
|---|
| 680 | # can't rename or remove an open DB
|
|---|
| 681 | self.d.close()
|
|---|
| 682 |
|
|---|
| 683 | newname = self.filename + '.renamed'
|
|---|
| 684 | self.env.dbrename(self.filename, None, newname)
|
|---|
| 685 | self.env.dbremove(newname)
|
|---|
| 686 |
|
|---|
| 687 | #----------------------------------------
|
|---|
| 688 |
|
|---|
| 689 | class BasicBTreeWithEnvTestCase(BasicWithEnvTestCase):
|
|---|
| 690 | dbtype = db.DB_BTREE
|
|---|
| 691 |
|
|---|
| 692 |
|
|---|
| 693 | class BasicHashWithEnvTestCase(BasicWithEnvTestCase):
|
|---|
| 694 | dbtype = db.DB_HASH
|
|---|
| 695 |
|
|---|
| 696 |
|
|---|
| 697 | #----------------------------------------------------------------------
|
|---|
| 698 |
|
|---|
| 699 | class BasicTransactionTestCase(BasicTestCase):
|
|---|
| 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)
|
|---|
| 704 |
|
|---|
| 705 | dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT
|
|---|
| 706 | useEnv = 1
|
|---|
| 707 | envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK |
|
|---|
| 708 | db.DB_INIT_TXN)
|
|---|
| 709 | envsetflags = db.DB_AUTO_COMMIT
|
|---|
| 710 |
|
|---|
| 711 |
|
|---|
| 712 | def tearDown(self):
|
|---|
| 713 | self.txn.commit()
|
|---|
| 714 | BasicTestCase.tearDown(self)
|
|---|
| 715 |
|
|---|
| 716 |
|
|---|
| 717 | def populateDB(self):
|
|---|
| 718 | txn = self.env.txn_begin()
|
|---|
| 719 | BasicTestCase.populateDB(self, _txn=txn)
|
|---|
| 720 |
|
|---|
| 721 | self.txn = self.env.txn_begin()
|
|---|
| 722 |
|
|---|
| 723 |
|
|---|
| 724 | def test06_Transactions(self):
|
|---|
| 725 | d = self.d
|
|---|
| 726 | if verbose:
|
|---|
| 727 | print '\n', '-=' * 30
|
|---|
| 728 | print "Running %s.test06_Transactions..." % self.__class__.__name__
|
|---|
| 729 |
|
|---|
| 730 | self.assertEqual(d.get('new rec', txn=self.txn), None)
|
|---|
| 731 | d.put('new rec', 'this is a new record', self.txn)
|
|---|
| 732 | self.assertEqual(d.get('new rec', txn=self.txn),
|
|---|
| 733 | 'this is a new record')
|
|---|
| 734 | self.txn.abort()
|
|---|
| 735 | self.assertEqual(d.get('new rec'), None)
|
|---|
| 736 |
|
|---|
| 737 | self.txn = self.env.txn_begin()
|
|---|
| 738 |
|
|---|
| 739 | self.assertEqual(d.get('new rec', txn=self.txn), None)
|
|---|
| 740 | d.put('new rec', 'this is a new record', self.txn)
|
|---|
| 741 | self.assertEqual(d.get('new rec', txn=self.txn),
|
|---|
| 742 | 'this is a new record')
|
|---|
| 743 | self.txn.commit()
|
|---|
| 744 | self.assertEqual(d.get('new rec'), 'this is a new record')
|
|---|
| 745 |
|
|---|
| 746 | self.txn = self.env.txn_begin()
|
|---|
| 747 | c = d.cursor(self.txn)
|
|---|
| 748 | rec = c.first()
|
|---|
| 749 | count = 0
|
|---|
| 750 | while rec is not None:
|
|---|
| 751 | count = count + 1
|
|---|
| 752 | if verbose and count % 100 == 0:
|
|---|
| 753 | print rec
|
|---|
| 754 | rec = c.next()
|
|---|
| 755 | self.assertEqual(count, self._numKeys+1)
|
|---|
| 756 |
|
|---|
| 757 | c.close() # Cursors *MUST* be closed before commit!
|
|---|
| 758 | self.txn.commit()
|
|---|
| 759 |
|
|---|
| 760 | # flush pending updates
|
|---|
| 761 | self.env.txn_checkpoint (0, 0, 0)
|
|---|
| 762 |
|
|---|
| 763 | statDict = self.env.log_stat(0);
|
|---|
| 764 | self.assertIn('magic', statDict)
|
|---|
| 765 | self.assertIn('version', statDict)
|
|---|
| 766 | self.assertIn('cur_file', statDict)
|
|---|
| 767 | self.assertIn('region_nowait', statDict)
|
|---|
| 768 |
|
|---|
| 769 | # must have at least one log file present:
|
|---|
| 770 | logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG)
|
|---|
| 771 | self.assertNotEqual(logs, None)
|
|---|
| 772 | for log in logs:
|
|---|
| 773 | if verbose:
|
|---|
| 774 | print 'log file: ' + log
|
|---|
| 775 | logs = self.env.log_archive(db.DB_ARCH_REMOVE)
|
|---|
| 776 | self.assertTrue(not logs)
|
|---|
| 777 |
|
|---|
| 778 | self.txn = self.env.txn_begin()
|
|---|
| 779 |
|
|---|
| 780 | #----------------------------------------
|
|---|
| 781 |
|
|---|
| 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):
|
|---|
| 797 | d = self.d
|
|---|
| 798 | if verbose:
|
|---|
| 799 | print '\n', '-=' * 30
|
|---|
| 800 | print "Running %s.test09_TxnTruncate..." % self.__class__.__name__
|
|---|
| 801 |
|
|---|
| 802 | d.put("abcde", "ABCDE");
|
|---|
| 803 | txn = self.env.txn_begin()
|
|---|
| 804 | num = d.truncate(txn)
|
|---|
| 805 | self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
|
|---|
| 806 | num = d.truncate(txn)
|
|---|
| 807 | self.assertEqual(num, 0,
|
|---|
| 808 | "truncate on empty DB returned nonzero (%r)" % (num,))
|
|---|
| 809 | txn.commit()
|
|---|
| 810 |
|
|---|
| 811 | #----------------------------------------
|
|---|
| 812 |
|
|---|
| 813 | def test10_TxnLateUse(self):
|
|---|
| 814 | txn = self.env.txn_begin()
|
|---|
| 815 | txn.abort()
|
|---|
| 816 | try:
|
|---|
| 817 | txn.abort()
|
|---|
| 818 | except db.DBError, e:
|
|---|
| 819 | pass
|
|---|
| 820 | else:
|
|---|
| 821 | raise RuntimeError, "DBTxn.abort() called after DB_TXN no longer valid w/o an exception"
|
|---|
| 822 |
|
|---|
| 823 | txn = self.env.txn_begin()
|
|---|
| 824 | txn.commit()
|
|---|
| 825 | try:
|
|---|
| 826 | txn.commit()
|
|---|
| 827 | except db.DBError, e:
|
|---|
| 828 | pass
|
|---|
| 829 | else:
|
|---|
| 830 | raise RuntimeError, "DBTxn.commit() called after DB_TXN no longer valid w/o an exception"
|
|---|
| 831 |
|
|---|
| 832 |
|
|---|
| 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 |
|
|---|
| 865 | class BTreeTransactionTestCase(BasicTransactionTestCase):
|
|---|
| 866 | dbtype = db.DB_BTREE
|
|---|
| 867 |
|
|---|
| 868 | class HashTransactionTestCase(BasicTransactionTestCase):
|
|---|
| 869 | dbtype = db.DB_HASH
|
|---|
| 870 |
|
|---|
| 871 |
|
|---|
| 872 |
|
|---|
| 873 | #----------------------------------------------------------------------
|
|---|
| 874 |
|
|---|
| 875 | class BTreeRecnoTestCase(BasicTestCase):
|
|---|
| 876 | dbtype = db.DB_BTREE
|
|---|
| 877 | dbsetflags = db.DB_RECNUM
|
|---|
| 878 |
|
|---|
| 879 | def test09_RecnoInBTree(self):
|
|---|
| 880 | d = self.d
|
|---|
| 881 | if verbose:
|
|---|
| 882 | print '\n', '-=' * 30
|
|---|
| 883 | print "Running %s.test09_RecnoInBTree..." % self.__class__.__name__
|
|---|
| 884 |
|
|---|
| 885 | rec = d.get(200)
|
|---|
| 886 | self.assertEqual(type(rec), type(()))
|
|---|
| 887 | self.assertEqual(len(rec), 2)
|
|---|
| 888 | if verbose:
|
|---|
| 889 | print "Record #200 is ", rec
|
|---|
| 890 |
|
|---|
| 891 | c = d.cursor()
|
|---|
| 892 | c.set('0200')
|
|---|
| 893 | num = c.get_recno()
|
|---|
| 894 | self.assertEqual(type(num), type(1))
|
|---|
| 895 | if verbose:
|
|---|
| 896 | print "recno of d['0200'] is ", num
|
|---|
| 897 |
|
|---|
| 898 | rec = c.current()
|
|---|
| 899 | self.assertEqual(c.set_recno(num), rec)
|
|---|
| 900 |
|
|---|
| 901 | c.close()
|
|---|
| 902 |
|
|---|
| 903 |
|
|---|
| 904 |
|
|---|
| 905 | class BTreeRecnoWithThreadFlagTestCase(BTreeRecnoTestCase):
|
|---|
| 906 | dbopenflags = db.DB_THREAD
|
|---|
| 907 |
|
|---|
| 908 | #----------------------------------------------------------------------
|
|---|
| 909 |
|
|---|
| 910 | class BasicDUPTestCase(BasicTestCase):
|
|---|
| 911 | dbsetflags = db.DB_DUP
|
|---|
| 912 |
|
|---|
| 913 | def test10_DuplicateKeys(self):
|
|---|
| 914 | d = self.d
|
|---|
| 915 | if verbose:
|
|---|
| 916 | print '\n', '-=' * 30
|
|---|
| 917 | print "Running %s.test10_DuplicateKeys..." % \
|
|---|
| 918 | self.__class__.__name__
|
|---|
| 919 |
|
|---|
| 920 | d.put("dup0", "before")
|
|---|
| 921 | for x in "The quick brown fox jumped over the lazy dog.".split():
|
|---|
| 922 | d.put("dup1", x)
|
|---|
| 923 | d.put("dup2", "after")
|
|---|
| 924 |
|
|---|
| 925 | data = d.get("dup1")
|
|---|
| 926 | self.assertEqual(data, "The")
|
|---|
| 927 | if verbose:
|
|---|
| 928 | print data
|
|---|
| 929 |
|
|---|
| 930 | c = d.cursor()
|
|---|
| 931 | rec = c.set("dup1")
|
|---|
| 932 | self.assertEqual(rec, ('dup1', 'The'))
|
|---|
| 933 |
|
|---|
| 934 | next_reg = c.next()
|
|---|
| 935 | self.assertEqual(next_reg, ('dup1', 'quick'))
|
|---|
| 936 |
|
|---|
| 937 | rec = c.set("dup1")
|
|---|
| 938 | count = c.count()
|
|---|
| 939 | self.assertEqual(count, 9)
|
|---|
| 940 |
|
|---|
| 941 | next_dup = c.next_dup()
|
|---|
| 942 | self.assertEqual(next_dup, ('dup1', 'quick'))
|
|---|
| 943 |
|
|---|
| 944 | rec = c.set('dup1')
|
|---|
| 945 | while rec is not None:
|
|---|
| 946 | if verbose:
|
|---|
| 947 | print rec
|
|---|
| 948 | rec = c.next_dup()
|
|---|
| 949 |
|
|---|
| 950 | c.set('dup1')
|
|---|
| 951 | rec = c.next_nodup()
|
|---|
| 952 | self.assertNotEqual(rec[0], 'dup1')
|
|---|
| 953 | if verbose:
|
|---|
| 954 | print rec
|
|---|
| 955 |
|
|---|
| 956 | c.close()
|
|---|
| 957 |
|
|---|
| 958 |
|
|---|
| 959 |
|
|---|
| 960 | class BTreeDUPTestCase(BasicDUPTestCase):
|
|---|
| 961 | dbtype = db.DB_BTREE
|
|---|
| 962 |
|
|---|
| 963 | class HashDUPTestCase(BasicDUPTestCase):
|
|---|
| 964 | dbtype = db.DB_HASH
|
|---|
| 965 |
|
|---|
| 966 | class BTreeDUPWithThreadTestCase(BasicDUPTestCase):
|
|---|
| 967 | dbtype = db.DB_BTREE
|
|---|
| 968 | dbopenflags = db.DB_THREAD
|
|---|
| 969 |
|
|---|
| 970 | class HashDUPWithThreadTestCase(BasicDUPTestCase):
|
|---|
| 971 | dbtype = db.DB_HASH
|
|---|
| 972 | dbopenflags = db.DB_THREAD
|
|---|
| 973 |
|
|---|
| 974 |
|
|---|
| 975 | #----------------------------------------------------------------------
|
|---|
| 976 |
|
|---|
| 977 | class BasicMultiDBTestCase(BasicTestCase):
|
|---|
| 978 | dbname = 'first'
|
|---|
| 979 |
|
|---|
| 980 | def otherType(self):
|
|---|
| 981 | if self.dbtype == db.DB_BTREE:
|
|---|
| 982 | return db.DB_HASH
|
|---|
| 983 | else:
|
|---|
| 984 | return db.DB_BTREE
|
|---|
| 985 |
|
|---|
| 986 | def test11_MultiDB(self):
|
|---|
| 987 | d1 = self.d
|
|---|
| 988 | if verbose:
|
|---|
| 989 | print '\n', '-=' * 30
|
|---|
| 990 | print "Running %s.test11_MultiDB..." % self.__class__.__name__
|
|---|
| 991 |
|
|---|
| 992 | d2 = db.DB(self.env)
|
|---|
| 993 | d2.open(self.filename, "second", self.dbtype,
|
|---|
| 994 | self.dbopenflags|db.DB_CREATE)
|
|---|
| 995 | d3 = db.DB(self.env)
|
|---|
| 996 | d3.open(self.filename, "third", self.otherType(),
|
|---|
| 997 | self.dbopenflags|db.DB_CREATE)
|
|---|
| 998 |
|
|---|
| 999 | for x in "The quick brown fox jumped over the lazy dog".split():
|
|---|
| 1000 | d2.put(x, self.makeData(x))
|
|---|
| 1001 |
|
|---|
| 1002 | for x in string.letters:
|
|---|
| 1003 | d3.put(x, x*70)
|
|---|
| 1004 |
|
|---|
| 1005 | d1.sync()
|
|---|
| 1006 | d2.sync()
|
|---|
| 1007 | d3.sync()
|
|---|
| 1008 | d1.close()
|
|---|
| 1009 | d2.close()
|
|---|
| 1010 | d3.close()
|
|---|
| 1011 |
|
|---|
| 1012 | self.d = d1 = d2 = d3 = None
|
|---|
| 1013 |
|
|---|
| 1014 | self.d = d1 = db.DB(self.env)
|
|---|
| 1015 | d1.open(self.filename, self.dbname, flags = self.dbopenflags)
|
|---|
| 1016 | d2 = db.DB(self.env)
|
|---|
| 1017 | d2.open(self.filename, "second", flags = self.dbopenflags)
|
|---|
| 1018 | d3 = db.DB(self.env)
|
|---|
| 1019 | d3.open(self.filename, "third", flags = self.dbopenflags)
|
|---|
| 1020 |
|
|---|
| 1021 | c1 = d1.cursor()
|
|---|
| 1022 | c2 = d2.cursor()
|
|---|
| 1023 | c3 = d3.cursor()
|
|---|
| 1024 |
|
|---|
| 1025 | count = 0
|
|---|
| 1026 | rec = c1.first()
|
|---|
| 1027 | while rec is not None:
|
|---|
| 1028 | count = count + 1
|
|---|
| 1029 | if verbose and (count % 50) == 0:
|
|---|
| 1030 | print rec
|
|---|
| 1031 | rec = c1.next()
|
|---|
| 1032 | self.assertEqual(count, self._numKeys)
|
|---|
| 1033 |
|
|---|
| 1034 | count = 0
|
|---|
| 1035 | rec = c2.first()
|
|---|
| 1036 | while rec is not None:
|
|---|
| 1037 | count = count + 1
|
|---|
| 1038 | if verbose:
|
|---|
| 1039 | print rec
|
|---|
| 1040 | rec = c2.next()
|
|---|
| 1041 | self.assertEqual(count, 9)
|
|---|
| 1042 |
|
|---|
| 1043 | count = 0
|
|---|
| 1044 | rec = c3.first()
|
|---|
| 1045 | while rec is not None:
|
|---|
| 1046 | count = count + 1
|
|---|
| 1047 | if verbose:
|
|---|
| 1048 | print rec
|
|---|
| 1049 | rec = c3.next()
|
|---|
| 1050 | self.assertEqual(count, len(string.letters))
|
|---|
| 1051 |
|
|---|
| 1052 |
|
|---|
| 1053 | c1.close()
|
|---|
| 1054 | c2.close()
|
|---|
| 1055 | c3.close()
|
|---|
| 1056 |
|
|---|
| 1057 | d2.close()
|
|---|
| 1058 | d3.close()
|
|---|
| 1059 |
|
|---|
| 1060 |
|
|---|
| 1061 |
|
|---|
| 1062 | # Strange things happen if you try to use Multiple DBs per file without a
|
|---|
| 1063 | # DBEnv with MPOOL and LOCKing...
|
|---|
| 1064 |
|
|---|
| 1065 | class BTreeMultiDBTestCase(BasicMultiDBTestCase):
|
|---|
| 1066 | dbtype = db.DB_BTREE
|
|---|
| 1067 | dbopenflags = db.DB_THREAD
|
|---|
| 1068 | useEnv = 1
|
|---|
| 1069 | envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
|
|---|
| 1070 |
|
|---|
| 1071 | class HashMultiDBTestCase(BasicMultiDBTestCase):
|
|---|
| 1072 | dbtype = db.DB_HASH
|
|---|
| 1073 | dbopenflags = db.DB_THREAD
|
|---|
| 1074 | useEnv = 1
|
|---|
| 1075 | envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
|
|---|
| 1076 |
|
|---|
| 1077 |
|
|---|
| 1078 | class PrivateObject(unittest.TestCase) :
|
|---|
| 1079 | def tearDown(self) :
|
|---|
| 1080 | del self.obj
|
|---|
| 1081 |
|
|---|
| 1082 | def test01_DefaultIsNone(self) :
|
|---|
| 1083 | self.assertEqual(self.obj.get_private(), None)
|
|---|
| 1084 |
|
|---|
| 1085 | def test02_assignment(self) :
|
|---|
| 1086 | a = "example of private object"
|
|---|
| 1087 | self.obj.set_private(a)
|
|---|
| 1088 | b = self.obj.get_private()
|
|---|
| 1089 | self.assertTrue(a is b) # Object identity
|
|---|
| 1090 |
|
|---|
| 1091 | def test03_leak_assignment(self) :
|
|---|
| 1092 | a = "example of private object"
|
|---|
| 1093 | refcount = sys.getrefcount(a)
|
|---|
| 1094 | self.obj.set_private(a)
|
|---|
| 1095 | self.assertEqual(refcount+1, sys.getrefcount(a))
|
|---|
| 1096 | self.obj.set_private(None)
|
|---|
| 1097 | self.assertEqual(refcount, sys.getrefcount(a))
|
|---|
| 1098 |
|
|---|
| 1099 | def test04_leak_GC(self) :
|
|---|
| 1100 | a = "example of private object"
|
|---|
| 1101 | refcount = sys.getrefcount(a)
|
|---|
| 1102 | self.obj.set_private(a)
|
|---|
| 1103 | self.obj = None
|
|---|
| 1104 | self.assertEqual(refcount, sys.getrefcount(a))
|
|---|
| 1105 |
|
|---|
| 1106 | class DBEnvPrivateObject(PrivateObject) :
|
|---|
| 1107 | def setUp(self) :
|
|---|
| 1108 | self.obj = db.DBEnv()
|
|---|
| 1109 |
|
|---|
| 1110 | class DBPrivateObject(PrivateObject) :
|
|---|
| 1111 | def setUp(self) :
|
|---|
| 1112 | self.obj = db.DB()
|
|---|
| 1113 |
|
|---|
| 1114 | class CrashAndBurn(unittest.TestCase) :
|
|---|
| 1115 | #def test01_OpenCrash(self) :
|
|---|
| 1116 | # # See http://bugs.python.org/issue3307
|
|---|
| 1117 | # self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535)
|
|---|
| 1118 |
|
|---|
| 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()
|
|---|
| 1125 |
|
|---|
| 1126 |
|
|---|
| 1127 | #----------------------------------------------------------------------
|
|---|
| 1128 | #----------------------------------------------------------------------
|
|---|
| 1129 |
|
|---|
| 1130 | def test_suite():
|
|---|
| 1131 | suite = unittest.TestSuite()
|
|---|
| 1132 |
|
|---|
| 1133 | suite.addTest(unittest.makeSuite(VersionTestCase))
|
|---|
| 1134 | suite.addTest(unittest.makeSuite(BasicBTreeTestCase))
|
|---|
| 1135 | suite.addTest(unittest.makeSuite(BasicHashTestCase))
|
|---|
| 1136 | suite.addTest(unittest.makeSuite(BasicBTreeWithThreadFlagTestCase))
|
|---|
| 1137 | suite.addTest(unittest.makeSuite(BasicHashWithThreadFlagTestCase))
|
|---|
| 1138 | suite.addTest(unittest.makeSuite(BasicBTreeWithEnvTestCase))
|
|---|
| 1139 | suite.addTest(unittest.makeSuite(BasicHashWithEnvTestCase))
|
|---|
| 1140 | suite.addTest(unittest.makeSuite(BTreeTransactionTestCase))
|
|---|
| 1141 | suite.addTest(unittest.makeSuite(HashTransactionTestCase))
|
|---|
| 1142 | suite.addTest(unittest.makeSuite(BTreeRecnoTestCase))
|
|---|
| 1143 | suite.addTest(unittest.makeSuite(BTreeRecnoWithThreadFlagTestCase))
|
|---|
| 1144 | suite.addTest(unittest.makeSuite(BTreeDUPTestCase))
|
|---|
| 1145 | suite.addTest(unittest.makeSuite(HashDUPTestCase))
|
|---|
| 1146 | suite.addTest(unittest.makeSuite(BTreeDUPWithThreadTestCase))
|
|---|
| 1147 | suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase))
|
|---|
| 1148 | suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase))
|
|---|
| 1149 | suite.addTest(unittest.makeSuite(HashMultiDBTestCase))
|
|---|
| 1150 | suite.addTest(unittest.makeSuite(DBEnvPrivateObject))
|
|---|
| 1151 | suite.addTest(unittest.makeSuite(DBPrivateObject))
|
|---|
| 1152 | suite.addTest(unittest.makeSuite(CrashAndBurn))
|
|---|
| 1153 |
|
|---|
| 1154 | return suite
|
|---|
| 1155 |
|
|---|
| 1156 |
|
|---|
| 1157 | if __name__ == '__main__':
|
|---|
| 1158 | unittest.main(defaultTest='test_suite')
|
|---|
