Python code coverage for Lib/bsddb/test/test_basics.py

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