| 1 | """
|
|---|
| 2 | TestCases for DB.associate.
|
|---|
| 3 | """
|
|---|
| 4 |
|
|---|
| 5 | import sys, os, string
|
|---|
| 6 | import time
|
|---|
| 7 | from pprint import pprint
|
|---|
| 8 |
|
|---|
| 9 | import unittest
|
|---|
| 10 | from test_all import db, dbshelve, test_support, verbose, have_threads, \
|
|---|
| 11 | get_new_environment_path
|
|---|
| 12 |
|
|---|
| 13 |
|
|---|
| 14 | #----------------------------------------------------------------------
|
|---|
| 15 |
|
|---|
| 16 |
|
|---|
| 17 | musicdata = {
|
|---|
| 18 | 1 : ("Bad English", "The Price Of Love", "Rock"),
|
|---|
| 19 | 2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"),
|
|---|
| 20 | 3 : ("George Michael", "Praying For Time", "Rock"),
|
|---|
| 21 | 4 : ("Gloria Estefan", "Here We Are", "Rock"),
|
|---|
| 22 | 5 : ("Linda Ronstadt", "Don't Know Much", "Rock"),
|
|---|
| 23 | 6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"),
|
|---|
| 24 | 7 : ("Paul Young", "Oh Girl", "Rock"),
|
|---|
| 25 | 8 : ("Paula Abdul", "Opposites Attract", "Rock"),
|
|---|
| 26 | 9 : ("Richard Marx", "Should've Known Better", "Rock"),
|
|---|
| 27 | 10: ("Rod Stewart", "Forever Young", "Rock"),
|
|---|
| 28 | 11: ("Roxette", "Dangerous", "Rock"),
|
|---|
| 29 | 12: ("Sheena Easton", "The Lover In Me", "Rock"),
|
|---|
| 30 | 13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"),
|
|---|
| 31 | 14: ("Stevie B.", "Because I Love You", "Rock"),
|
|---|
| 32 | 15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"),
|
|---|
| 33 | 16: ("The Bangles", "Eternal Flame", "Rock"),
|
|---|
| 34 | 17: ("Wilson Phillips", "Release Me", "Rock"),
|
|---|
| 35 | 18: ("Billy Joel", "Blonde Over Blue", "Rock"),
|
|---|
| 36 | 19: ("Billy Joel", "Famous Last Words", "Rock"),
|
|---|
| 37 | 20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"),
|
|---|
| 38 | 21: ("Billy Joel", "The River Of Dreams", "Rock"),
|
|---|
| 39 | 22: ("Billy Joel", "Two Thousand Years", "Rock"),
|
|---|
| 40 | 23: ("Janet Jackson", "Alright", "Rock"),
|
|---|
| 41 | 24: ("Janet Jackson", "Black Cat", "Rock"),
|
|---|
| 42 | 25: ("Janet Jackson", "Come Back To Me", "Rock"),
|
|---|
| 43 | 26: ("Janet Jackson", "Escapade", "Rock"),
|
|---|
| 44 | 27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"),
|
|---|
| 45 | 28: ("Janet Jackson", "Miss You Much", "Rock"),
|
|---|
| 46 | 29: ("Janet Jackson", "Rhythm Nation", "Rock"),
|
|---|
| 47 | 30: ("Janet Jackson", "State Of The World", "Rock"),
|
|---|
| 48 | 31: ("Janet Jackson", "The Knowledge", "Rock"),
|
|---|
| 49 | 32: ("Spyro Gyra", "End of Romanticism", "Jazz"),
|
|---|
| 50 | 33: ("Spyro Gyra", "Heliopolis", "Jazz"),
|
|---|
| 51 | 34: ("Spyro Gyra", "Jubilee", "Jazz"),
|
|---|
| 52 | 35: ("Spyro Gyra", "Little Linda", "Jazz"),
|
|---|
| 53 | 36: ("Spyro Gyra", "Morning Dance", "Jazz"),
|
|---|
| 54 | 37: ("Spyro Gyra", "Song for Lorraine", "Jazz"),
|
|---|
| 55 | 38: ("Yes", "Owner Of A Lonely Heart", "Rock"),
|
|---|
| 56 | 39: ("Yes", "Rhythm Of Love", "Rock"),
|
|---|
| 57 | 40: ("Cusco", "Dream Catcher", "New Age"),
|
|---|
| 58 | 41: ("Cusco", "Geronimos Laughter", "New Age"),
|
|---|
| 59 | 42: ("Cusco", "Ghost Dance", "New Age"),
|
|---|
| 60 | 43: ("Blue Man Group", "Drumbone", "New Age"),
|
|---|
| 61 | 44: ("Blue Man Group", "Endless Column", "New Age"),
|
|---|
| 62 | 45: ("Blue Man Group", "Klein Mandelbrot", "New Age"),
|
|---|
| 63 | 46: ("Kenny G", "Silhouette", "Jazz"),
|
|---|
| 64 | 47: ("Sade", "Smooth Operator", "Jazz"),
|
|---|
| 65 | 48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)",
|
|---|
| 66 | "New Age"),
|
|---|
| 67 | 49: ("David Arkenstone", "Stepping Stars", "New Age"),
|
|---|
| 68 | 50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"),
|
|---|
| 69 | 51: ("David Lanz", "Behind The Waterfall", "New Age"),
|
|---|
| 70 | 52: ("David Lanz", "Cristofori's Dream", "New Age"),
|
|---|
| 71 | 53: ("David Lanz", "Heartsounds", "New Age"),
|
|---|
| 72 | 54: ("David Lanz", "Leaves on the Seine", "New Age"),
|
|---|
| 73 | 99: ("unknown artist", "Unnamed song", "Unknown"),
|
|---|
| 74 | }
|
|---|
| 75 |
|
|---|
| 76 | #----------------------------------------------------------------------
|
|---|
| 77 |
|
|---|
| 78 | class AssociateErrorTestCase(unittest.TestCase):
|
|---|
| 79 | def setUp(self):
|
|---|
| 80 | self.filename = self.__class__.__name__ + '.db'
|
|---|
| 81 | self.homeDir = get_new_environment_path()
|
|---|
| 82 | self.env = db.DBEnv()
|
|---|
| 83 | self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
|---|
| 84 |
|
|---|
| 85 | def tearDown(self):
|
|---|
| 86 | self.env.close()
|
|---|
| 87 | self.env = None
|
|---|
| 88 | test_support.rmtree(self.homeDir)
|
|---|
| 89 |
|
|---|
| 90 | def test00_associateDBError(self):
|
|---|
| 91 | if verbose:
|
|---|
| 92 | print '\n', '-=' * 30
|
|---|
| 93 | print "Running %s.test00_associateDBError..." % \
|
|---|
| 94 | self.__class__.__name__
|
|---|
| 95 |
|
|---|
| 96 | dupDB = db.DB(self.env)
|
|---|
| 97 | dupDB.set_flags(db.DB_DUP)
|
|---|
| 98 | dupDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE)
|
|---|
| 99 |
|
|---|
| 100 | secDB = db.DB(self.env)
|
|---|
| 101 | secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE)
|
|---|
| 102 |
|
|---|
| 103 | # dupDB has been configured to allow duplicates, it can't
|
|---|
| 104 | # associate with a secondary. Berkeley DB will return an error.
|
|---|
| 105 | try:
|
|---|
| 106 | def f(a,b): return a+b
|
|---|
| 107 | dupDB.associate(secDB, f)
|
|---|
| 108 | except db.DBError:
|
|---|
| 109 | # good
|
|---|
| 110 | secDB.close()
|
|---|
| 111 | dupDB.close()
|
|---|
| 112 | else:
|
|---|
| 113 | secDB.close()
|
|---|
| 114 | dupDB.close()
|
|---|
| 115 | self.fail("DBError exception was expected")
|
|---|
| 116 |
|
|---|
| 117 |
|
|---|
| 118 |
|
|---|
| 119 | #----------------------------------------------------------------------
|
|---|
| 120 |
|
|---|
| 121 |
|
|---|
| 122 | class AssociateTestCase(unittest.TestCase):
|
|---|
| 123 | keytype = ''
|
|---|
| 124 | envFlags = 0
|
|---|
| 125 | dbFlags = 0
|
|---|
| 126 |
|
|---|
| 127 | def setUp(self):
|
|---|
| 128 | self.filename = self.__class__.__name__ + '.db'
|
|---|
| 129 | self.homeDir = get_new_environment_path()
|
|---|
| 130 | self.env = db.DBEnv()
|
|---|
| 131 | self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
|---|
| 132 | db.DB_INIT_LOCK | db.DB_THREAD | self.envFlags)
|
|---|
| 133 |
|
|---|
| 134 | def tearDown(self):
|
|---|
| 135 | self.closeDB()
|
|---|
| 136 | self.env.close()
|
|---|
| 137 | self.env = None
|
|---|
| 138 | test_support.rmtree(self.homeDir)
|
|---|
| 139 |
|
|---|
| 140 | def addDataToDB(self, d, txn=None):
|
|---|
| 141 | for key, value in musicdata.items():
|
|---|
| 142 | if type(self.keytype) == type(''):
|
|---|
| 143 | key = "%02d" % key
|
|---|
| 144 | d.put(key, '|'.join(value), txn=txn)
|
|---|
| 145 |
|
|---|
| 146 | def createDB(self, txn=None):
|
|---|
| 147 | self.cur = None
|
|---|
| 148 | self.secDB = None
|
|---|
| 149 | self.primary = db.DB(self.env)
|
|---|
| 150 | self.primary.set_get_returns_none(2)
|
|---|
| 151 | self.primary.open(self.filename, "primary", self.dbtype,
|
|---|
| 152 | db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn)
|
|---|
| 153 |
|
|---|
| 154 | def closeDB(self):
|
|---|
| 155 | if self.cur:
|
|---|
| 156 | self.cur.close()
|
|---|
| 157 | self.cur = None
|
|---|
| 158 | if self.secDB:
|
|---|
| 159 | self.secDB.close()
|
|---|
| 160 | self.secDB = None
|
|---|
| 161 | self.primary.close()
|
|---|
| 162 | self.primary = None
|
|---|
| 163 |
|
|---|
| 164 | def getDB(self):
|
|---|
| 165 | return self.primary
|
|---|
| 166 |
|
|---|
| 167 |
|
|---|
| 168 | def _associateWithDB(self, getGenre):
|
|---|
| 169 | self.createDB()
|
|---|
| 170 |
|
|---|
| 171 | self.secDB = db.DB(self.env)
|
|---|
| 172 | self.secDB.set_flags(db.DB_DUP)
|
|---|
| 173 | self.secDB.set_get_returns_none(2)
|
|---|
| 174 | self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
|---|
| 175 | db.DB_CREATE | db.DB_THREAD | self.dbFlags)
|
|---|
| 176 | self.getDB().associate(self.secDB, getGenre)
|
|---|
| 177 |
|
|---|
| 178 | self.addDataToDB(self.getDB())
|
|---|
| 179 |
|
|---|
| 180 | self.finish_test(self.secDB)
|
|---|
| 181 |
|
|---|
| 182 | def test01_associateWithDB(self):
|
|---|
| 183 | if verbose:
|
|---|
| 184 | print '\n', '-=' * 30
|
|---|
| 185 | print "Running %s.test01_associateWithDB..." % \
|
|---|
| 186 | self.__class__.__name__
|
|---|
| 187 |
|
|---|
| 188 | return self._associateWithDB(self.getGenre)
|
|---|
| 189 |
|
|---|
| 190 | def _associateAfterDB(self, getGenre) :
|
|---|
| 191 | self.createDB()
|
|---|
| 192 | self.addDataToDB(self.getDB())
|
|---|
| 193 |
|
|---|
| 194 | self.secDB = db.DB(self.env)
|
|---|
| 195 | self.secDB.set_flags(db.DB_DUP)
|
|---|
| 196 | self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
|---|
| 197 | db.DB_CREATE | db.DB_THREAD | self.dbFlags)
|
|---|
| 198 |
|
|---|
| 199 | # adding the DB_CREATE flag will cause it to index existing records
|
|---|
| 200 | self.getDB().associate(self.secDB, getGenre, db.DB_CREATE)
|
|---|
| 201 |
|
|---|
| 202 | 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)
|
|---|
| 228 |
|
|---|
| 229 |
|
|---|
| 230 | def finish_test(self, secDB, txn=None):
|
|---|
| 231 | # 'Blues' should not be in the secondary database
|
|---|
| 232 | vals = secDB.pget('Blues', txn=txn)
|
|---|
| 233 | self.assertEqual(vals, None, vals)
|
|---|
| 234 |
|
|---|
| 235 | vals = secDB.pget('Unknown', txn=txn)
|
|---|
| 236 | self.assertTrue(vals[0] == 99 or vals[0] == '99', vals)
|
|---|
| 237 | vals[1].index('Unknown')
|
|---|
| 238 | vals[1].index('Unnamed')
|
|---|
| 239 | vals[1].index('unknown')
|
|---|
| 240 |
|
|---|
| 241 | if verbose:
|
|---|
| 242 | print "Primary key traversal:"
|
|---|
| 243 | self.cur = self.getDB().cursor(txn)
|
|---|
| 244 | count = 0
|
|---|
| 245 | rec = self.cur.first()
|
|---|
| 246 | while rec is not None:
|
|---|
| 247 | if type(self.keytype) == type(''):
|
|---|
| 248 | self.assertTrue(int(rec[0])) # for primary db, key is a number
|
|---|
| 249 | else:
|
|---|
| 250 | self.assertTrue(rec[0] and type(rec[0]) == type(0))
|
|---|
| 251 | count = count + 1
|
|---|
| 252 | if verbose:
|
|---|
| 253 | print rec
|
|---|
| 254 | rec = getattr(self.cur, "next")()
|
|---|
| 255 | self.assertEqual(count, len(musicdata)) # all items accounted for
|
|---|
| 256 |
|
|---|
| 257 |
|
|---|
| 258 | if verbose:
|
|---|
| 259 | print "Secondary key traversal:"
|
|---|
| 260 | self.cur = secDB.cursor(txn)
|
|---|
| 261 | count = 0
|
|---|
| 262 |
|
|---|
| 263 | # test cursor pget
|
|---|
| 264 | vals = self.cur.pget('Unknown', flags=db.DB_LAST)
|
|---|
| 265 | self.assertTrue(vals[1] == 99 or vals[1] == '99', vals)
|
|---|
| 266 | self.assertEqual(vals[0], 'Unknown')
|
|---|
| 267 | vals[2].index('Unknown')
|
|---|
| 268 | vals[2].index('Unnamed')
|
|---|
| 269 | vals[2].index('unknown')
|
|---|
| 270 |
|
|---|
| 271 | vals = self.cur.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH)
|
|---|
| 272 | self.assertEqual(vals, None, vals)
|
|---|
| 273 |
|
|---|
| 274 | rec = self.cur.first()
|
|---|
| 275 | self.assertEqual(rec[0], "Jazz")
|
|---|
| 276 | while rec is not None:
|
|---|
| 277 | count = count + 1
|
|---|
| 278 | if verbose:
|
|---|
| 279 | print rec
|
|---|
| 280 | rec = getattr(self.cur, "next")()
|
|---|
| 281 | # all items accounted for EXCEPT for 1 with "Blues" genre
|
|---|
| 282 | self.assertEqual(count, len(musicdata)-1)
|
|---|
| 283 |
|
|---|
| 284 | self.cur = None
|
|---|
| 285 |
|
|---|
| 286 | def getGenre(self, priKey, priData):
|
|---|
| 287 | self.assertEqual(type(priData), type(""))
|
|---|
| 288 | genre = priData.split('|')[2]
|
|---|
| 289 |
|
|---|
| 290 | if verbose:
|
|---|
| 291 | print 'getGenre key: %r data: %r' % (priKey, priData)
|
|---|
| 292 |
|
|---|
| 293 | if genre == 'Blues':
|
|---|
| 294 | return db.DB_DONOTINDEX
|
|---|
| 295 | else:
|
|---|
| 296 | return genre
|
|---|
| 297 |
|
|---|
| 298 | def getGenreList(self, priKey, PriData) :
|
|---|
| 299 | v = self.getGenre(priKey, PriData)
|
|---|
| 300 | if type(v) == type("") :
|
|---|
| 301 | v = [v]
|
|---|
| 302 | return v
|
|---|
| 303 |
|
|---|
| 304 |
|
|---|
| 305 | #----------------------------------------------------------------------
|
|---|
| 306 |
|
|---|
| 307 |
|
|---|
| 308 | class AssociateHashTestCase(AssociateTestCase):
|
|---|
| 309 | dbtype = db.DB_HASH
|
|---|
| 310 |
|
|---|
| 311 | class AssociateBTreeTestCase(AssociateTestCase):
|
|---|
| 312 | dbtype = db.DB_BTREE
|
|---|
| 313 |
|
|---|
| 314 | class AssociateRecnoTestCase(AssociateTestCase):
|
|---|
| 315 | dbtype = db.DB_RECNO
|
|---|
| 316 | keytype = 0
|
|---|
| 317 |
|
|---|
| 318 | #----------------------------------------------------------------------
|
|---|
| 319 |
|
|---|
| 320 | class AssociateBTreeTxnTestCase(AssociateBTreeTestCase):
|
|---|
| 321 | envFlags = db.DB_INIT_TXN
|
|---|
| 322 | dbFlags = 0
|
|---|
| 323 |
|
|---|
| 324 | def txn_finish_test(self, sDB, txn):
|
|---|
| 325 | try:
|
|---|
| 326 | self.finish_test(sDB, txn=txn)
|
|---|
| 327 | finally:
|
|---|
| 328 | if self.cur:
|
|---|
| 329 | self.cur.close()
|
|---|
| 330 | self.cur = None
|
|---|
| 331 | if txn:
|
|---|
| 332 | txn.commit()
|
|---|
| 333 |
|
|---|
| 334 | def test13_associate_in_transaction(self):
|
|---|
| 335 | if verbose:
|
|---|
| 336 | print '\n', '-=' * 30
|
|---|
| 337 | print "Running %s.test13_associateAutoCommit..." % \
|
|---|
| 338 | self.__class__.__name__
|
|---|
| 339 |
|
|---|
| 340 | txn = self.env.txn_begin()
|
|---|
| 341 | try:
|
|---|
| 342 | self.createDB(txn=txn)
|
|---|
| 343 |
|
|---|
| 344 | self.secDB = db.DB(self.env)
|
|---|
| 345 | self.secDB.set_flags(db.DB_DUP)
|
|---|
| 346 | self.secDB.set_get_returns_none(2)
|
|---|
| 347 | self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
|---|
| 348 | db.DB_CREATE | db.DB_THREAD, txn=txn)
|
|---|
| 349 | self.getDB().associate(self.secDB, self.getGenre, txn=txn)
|
|---|
| 350 |
|
|---|
| 351 | self.addDataToDB(self.getDB(), txn=txn)
|
|---|
| 352 | except:
|
|---|
| 353 | txn.abort()
|
|---|
| 354 | raise
|
|---|
| 355 |
|
|---|
| 356 | self.txn_finish_test(self.secDB, txn=txn)
|
|---|
| 357 |
|
|---|
| 358 |
|
|---|
| 359 | #----------------------------------------------------------------------
|
|---|
| 360 |
|
|---|
| 361 | class ShelveAssociateTestCase(AssociateTestCase):
|
|---|
| 362 |
|
|---|
| 363 | def createDB(self):
|
|---|
| 364 | self.primary = dbshelve.open(self.filename,
|
|---|
| 365 | dbname="primary",
|
|---|
| 366 | dbenv=self.env,
|
|---|
| 367 | filetype=self.dbtype)
|
|---|
| 368 |
|
|---|
| 369 | def addDataToDB(self, d):
|
|---|
| 370 | for key, value in musicdata.items():
|
|---|
| 371 | if type(self.keytype) == type(''):
|
|---|
| 372 | key = "%02d" % key
|
|---|
| 373 | d.put(key, value) # save the value as is this time
|
|---|
| 374 |
|
|---|
| 375 |
|
|---|
| 376 | def getGenre(self, priKey, priData):
|
|---|
| 377 | self.assertEqual(type(priData), type(()))
|
|---|
| 378 | if verbose:
|
|---|
| 379 | print 'getGenre key: %r data: %r' % (priKey, priData)
|
|---|
| 380 | genre = priData[2]
|
|---|
| 381 | if genre == 'Blues':
|
|---|
| 382 | return db.DB_DONOTINDEX
|
|---|
| 383 | else:
|
|---|
| 384 | return genre
|
|---|
| 385 |
|
|---|
| 386 |
|
|---|
| 387 | class ShelveAssociateHashTestCase(ShelveAssociateTestCase):
|
|---|
| 388 | dbtype = db.DB_HASH
|
|---|
| 389 |
|
|---|
| 390 | class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase):
|
|---|
| 391 | dbtype = db.DB_BTREE
|
|---|
| 392 |
|
|---|
| 393 | class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase):
|
|---|
| 394 | dbtype = db.DB_RECNO
|
|---|
| 395 | keytype = 0
|
|---|
| 396 |
|
|---|
| 397 |
|
|---|
| 398 | #----------------------------------------------------------------------
|
|---|
| 399 |
|
|---|
| 400 | class ThreadedAssociateTestCase(AssociateTestCase):
|
|---|
| 401 |
|
|---|
| 402 | def addDataToDB(self, d):
|
|---|
| 403 | t1 = Thread(target = self.writer1,
|
|---|
| 404 | args = (d, ))
|
|---|
| 405 | t2 = Thread(target = self.writer2,
|
|---|
| 406 | args = (d, ))
|
|---|
| 407 |
|
|---|
| 408 | t1.setDaemon(True)
|
|---|
| 409 | t2.setDaemon(True)
|
|---|
| 410 | t1.start()
|
|---|
| 411 | t2.start()
|
|---|
| 412 | t1.join()
|
|---|
| 413 | t2.join()
|
|---|
| 414 |
|
|---|
| 415 | def writer1(self, d):
|
|---|
| 416 | for key, value in musicdata.items():
|
|---|
| 417 | if type(self.keytype) == type(''):
|
|---|
| 418 | key = "%02d" % key
|
|---|
| 419 | d.put(key, '|'.join(value))
|
|---|
| 420 |
|
|---|
| 421 | def writer2(self, d):
|
|---|
| 422 | for x in range(100, 600):
|
|---|
| 423 | key = 'z%2d' % x
|
|---|
| 424 | value = [key] * 4
|
|---|
| 425 | d.put(key, '|'.join(value))
|
|---|
| 426 |
|
|---|
| 427 |
|
|---|
| 428 | class ThreadedAssociateHashTestCase(ShelveAssociateTestCase):
|
|---|
| 429 | dbtype = db.DB_HASH
|
|---|
| 430 |
|
|---|
| 431 | class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase):
|
|---|
| 432 | dbtype = db.DB_BTREE
|
|---|
| 433 |
|
|---|
| 434 | class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase):
|
|---|
| 435 | dbtype = db.DB_RECNO
|
|---|
| 436 | keytype = 0
|
|---|
| 437 |
|
|---|
| 438 |
|
|---|
| 439 | #----------------------------------------------------------------------
|
|---|
| 440 |
|
|---|
| 441 | def test_suite():
|
|---|
| 442 | suite = unittest.TestSuite()
|
|---|
| 443 |
|
|---|
| 444 | suite.addTest(unittest.makeSuite(AssociateErrorTestCase))
|
|---|
| 445 |
|
|---|
| 446 | suite.addTest(unittest.makeSuite(AssociateHashTestCase))
|
|---|
| 447 | suite.addTest(unittest.makeSuite(AssociateBTreeTestCase))
|
|---|
| 448 | suite.addTest(unittest.makeSuite(AssociateRecnoTestCase))
|
|---|
| 449 |
|
|---|
| 450 | suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase))
|
|---|
| 451 |
|
|---|
| 452 | suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase))
|
|---|
| 453 | suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase))
|
|---|
| 454 | suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase))
|
|---|
| 455 |
|
|---|
| 456 | if have_threads:
|
|---|
| 457 | suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase))
|
|---|
| 458 | suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase))
|
|---|
| 459 | suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase))
|
|---|
| 460 |
|
|---|
| 461 | return suite
|
|---|
| 462 |
|
|---|
| 463 |
|
|---|
| 464 | if __name__ == '__main__':
|
|---|
| 465 | unittest.main(defaultTest='test_suite')
|
|---|
