Import Upstream version 2.7.18
This commit is contained in:
geos_one
0
Lib/bsddb/test/__init__.py
Normal file
0
Lib/bsddb/test/__init__.py
Normal file
620
Lib/bsddb/test/test_all.py
Normal file
620
Lib/bsddb/test/test_all.py
Normal file
@@ -0,0 +1,620 @@
|
||||
"""Run all test cases.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import unittest
|
||||
try:
|
||||
# For Pythons w/distutils pybsddb
|
||||
import bsddb3 as bsddb
|
||||
except ImportError:
|
||||
# For Python 2.3
|
||||
import bsddb
|
||||
|
||||
|
||||
if sys.version_info[0] >= 3 :
|
||||
charset = "iso8859-1" # Full 8 bit
|
||||
|
||||
class logcursor_py3k(object) :
|
||||
def __init__(self, env) :
|
||||
self._logcursor = env.log_cursor()
|
||||
|
||||
def __getattr__(self, v) :
|
||||
return getattr(self._logcursor, v)
|
||||
|
||||
def __next__(self) :
|
||||
v = getattr(self._logcursor, "next")()
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
next = __next__
|
||||
|
||||
def first(self) :
|
||||
v = self._logcursor.first()
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
def last(self) :
|
||||
v = self._logcursor.last()
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
def prev(self) :
|
||||
v = self._logcursor.prev()
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
def current(self) :
|
||||
v = self._logcursor.current()
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
def set(self, lsn) :
|
||||
v = self._logcursor.set(lsn)
|
||||
if v is not None :
|
||||
v = (v[0], v[1].decode(charset))
|
||||
return v
|
||||
|
||||
class cursor_py3k(object) :
|
||||
def __init__(self, db, *args, **kwargs) :
|
||||
self._dbcursor = db.cursor(*args, **kwargs)
|
||||
|
||||
def __getattr__(self, v) :
|
||||
return getattr(self._dbcursor, v)
|
||||
|
||||
def _fix(self, v) :
|
||||
if v is None : return None
|
||||
key, value = v
|
||||
if isinstance(key, bytes) :
|
||||
key = key.decode(charset)
|
||||
return (key, value.decode(charset))
|
||||
|
||||
def __next__(self) :
|
||||
v = getattr(self._dbcursor, "next")()
|
||||
return self._fix(v)
|
||||
|
||||
next = __next__
|
||||
|
||||
def previous(self) :
|
||||
v = self._dbcursor.previous()
|
||||
return self._fix(v)
|
||||
|
||||
def last(self) :
|
||||
v = self._dbcursor.last()
|
||||
return self._fix(v)
|
||||
|
||||
def set(self, k) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
v = self._dbcursor.set(k)
|
||||
return self._fix(v)
|
||||
|
||||
def set_recno(self, num) :
|
||||
v = self._dbcursor.set_recno(num)
|
||||
return self._fix(v)
|
||||
|
||||
def set_range(self, k, dlen=-1, doff=-1) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
v = self._dbcursor.set_range(k, dlen=dlen, doff=doff)
|
||||
return self._fix(v)
|
||||
|
||||
def dup(self, flags=0) :
|
||||
cursor = self._dbcursor.dup(flags)
|
||||
return dup_cursor_py3k(cursor)
|
||||
|
||||
def next_dup(self) :
|
||||
v = self._dbcursor.next_dup()
|
||||
return self._fix(v)
|
||||
|
||||
def next_nodup(self) :
|
||||
v = self._dbcursor.next_nodup()
|
||||
return self._fix(v)
|
||||
|
||||
def put(self, key, data, flags=0, dlen=-1, doff=-1) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if isinstance(data, str) :
|
||||
value = bytes(data, charset)
|
||||
return self._dbcursor.put(key, data, flags=flags, dlen=dlen,
|
||||
doff=doff)
|
||||
|
||||
def current(self, flags=0, dlen=-1, doff=-1) :
|
||||
v = self._dbcursor.current(flags=flags, dlen=dlen, doff=doff)
|
||||
return self._fix(v)
|
||||
|
||||
def first(self) :
|
||||
v = self._dbcursor.first()
|
||||
return self._fix(v)
|
||||
|
||||
def pget(self, key=None, data=None, flags=0) :
|
||||
# Incorrect because key can be a bare number,
|
||||
# but enough to pass testsuite
|
||||
if isinstance(key, int) and (data is None) and (flags == 0) :
|
||||
flags = key
|
||||
key = None
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if isinstance(data, int) and (flags==0) :
|
||||
flags = data
|
||||
data = None
|
||||
if isinstance(data, str) :
|
||||
data = bytes(data, charset)
|
||||
v=self._dbcursor.pget(key=key, data=data, flags=flags)
|
||||
if v is not None :
|
||||
v1, v2, v3 = v
|
||||
if isinstance(v1, bytes) :
|
||||
v1 = v1.decode(charset)
|
||||
if isinstance(v2, bytes) :
|
||||
v2 = v2.decode(charset)
|
||||
|
||||
v = (v1, v2, v3.decode(charset))
|
||||
|
||||
return v
|
||||
|
||||
def join_item(self) :
|
||||
v = self._dbcursor.join_item()
|
||||
if v is not None :
|
||||
v = v.decode(charset)
|
||||
return v
|
||||
|
||||
def get(self, *args, **kwargs) :
|
||||
l = len(args)
|
||||
if l == 2 :
|
||||
k, f = args
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, "iso8859-1")
|
||||
args = (k, f)
|
||||
elif l == 3 :
|
||||
k, d, f = args
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
if isinstance(d, str) :
|
||||
d = bytes(d, charset)
|
||||
args =(k, d, f)
|
||||
|
||||
v = self._dbcursor.get(*args, **kwargs)
|
||||
if v is not None :
|
||||
k, v = v
|
||||
if isinstance(k, bytes) :
|
||||
k = k.decode(charset)
|
||||
v = (k, v.decode(charset))
|
||||
return v
|
||||
|
||||
def get_both(self, key, value) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if isinstance(value, str) :
|
||||
value = bytes(value, charset)
|
||||
v=self._dbcursor.get_both(key, value)
|
||||
return self._fix(v)
|
||||
|
||||
class dup_cursor_py3k(cursor_py3k) :
|
||||
def __init__(self, dbcursor) :
|
||||
self._dbcursor = dbcursor
|
||||
|
||||
class DB_py3k(object) :
|
||||
def __init__(self, *args, **kwargs) :
|
||||
args2=[]
|
||||
for i in args :
|
||||
if isinstance(i, DBEnv_py3k) :
|
||||
i = i._dbenv
|
||||
args2.append(i)
|
||||
args = tuple(args2)
|
||||
for k, v in kwargs.items() :
|
||||
if isinstance(v, DBEnv_py3k) :
|
||||
kwargs[k] = v._dbenv
|
||||
|
||||
self._db = bsddb._db.DB_orig(*args, **kwargs)
|
||||
|
||||
def __contains__(self, k) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
return getattr(self._db, "has_key")(k)
|
||||
|
||||
def __getitem__(self, k) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
v = self._db[k]
|
||||
if v is not None :
|
||||
v = v.decode(charset)
|
||||
return v
|
||||
|
||||
def __setitem__(self, k, v) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
if isinstance(v, str) :
|
||||
v = bytes(v, charset)
|
||||
self._db[k] = v
|
||||
|
||||
def __delitem__(self, k) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
del self._db[k]
|
||||
|
||||
def __getattr__(self, v) :
|
||||
return getattr(self._db, v)
|
||||
|
||||
def __len__(self) :
|
||||
return len(self._db)
|
||||
|
||||
def has_key(self, k, txn=None) :
|
||||
if isinstance(k, str) :
|
||||
k = bytes(k, charset)
|
||||
return self._db.has_key(k, txn=txn)
|
||||
|
||||
def set_re_delim(self, c) :
|
||||
if isinstance(c, str) : # We can use a numeric value byte too
|
||||
c = bytes(c, charset)
|
||||
return self._db.set_re_delim(c)
|
||||
|
||||
def set_re_pad(self, c) :
|
||||
if isinstance(c, str) : # We can use a numeric value byte too
|
||||
c = bytes(c, charset)
|
||||
return self._db.set_re_pad(c)
|
||||
|
||||
def get_re_source(self) :
|
||||
source = self._db.get_re_source()
|
||||
return source.decode(charset)
|
||||
|
||||
def put(self, key, data, txn=None, flags=0, dlen=-1, doff=-1) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if isinstance(data, str) :
|
||||
value = bytes(data, charset)
|
||||
return self._db.put(key, data, flags=flags, txn=txn, dlen=dlen,
|
||||
doff=doff)
|
||||
|
||||
def append(self, value, txn=None) :
|
||||
if isinstance(value, str) :
|
||||
value = bytes(value, charset)
|
||||
return self._db.append(value, txn=txn)
|
||||
|
||||
def get_size(self, key) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
return self._db.get_size(key)
|
||||
|
||||
def exists(self, key, *args, **kwargs) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
return self._db.exists(key, *args, **kwargs)
|
||||
|
||||
def get(self, key, default="MagicCookie", txn=None, flags=0, dlen=-1, doff=-1) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if default != "MagicCookie" : # Magic for 'test_get_none.py'
|
||||
v=self._db.get(key, default=default, txn=txn, flags=flags,
|
||||
dlen=dlen, doff=doff)
|
||||
else :
|
||||
v=self._db.get(key, txn=txn, flags=flags,
|
||||
dlen=dlen, doff=doff)
|
||||
if (v is not None) and isinstance(v, bytes) :
|
||||
v = v.decode(charset)
|
||||
return v
|
||||
|
||||
def pget(self, key, txn=None) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
v=self._db.pget(key, txn=txn)
|
||||
if v is not None :
|
||||
v1, v2 = v
|
||||
if isinstance(v1, bytes) :
|
||||
v1 = v1.decode(charset)
|
||||
|
||||
v = (v1, v2.decode(charset))
|
||||
return v
|
||||
|
||||
def get_both(self, key, value, txn=None, flags=0) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
if isinstance(value, str) :
|
||||
value = bytes(value, charset)
|
||||
v=self._db.get_both(key, value, txn=txn, flags=flags)
|
||||
if v is not None :
|
||||
v = v.decode(charset)
|
||||
return v
|
||||
|
||||
def delete(self, key, txn=None) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
return self._db.delete(key, txn=txn)
|
||||
|
||||
def keys(self) :
|
||||
k = self._db.keys()
|
||||
if len(k) and isinstance(k[0], bytes) :
|
||||
return [i.decode(charset) for i in self._db.keys()]
|
||||
else :
|
||||
return k
|
||||
|
||||
def items(self) :
|
||||
data = self._db.items()
|
||||
if not len(data) : return data
|
||||
data2 = []
|
||||
for k, v in data :
|
||||
if isinstance(k, bytes) :
|
||||
k = k.decode(charset)
|
||||
data2.append((k, v.decode(charset)))
|
||||
return data2
|
||||
|
||||
def associate(self, secondarydb, callback, flags=0, txn=None) :
|
||||
class associate_callback(object) :
|
||||
def __init__(self, callback) :
|
||||
self._callback = callback
|
||||
|
||||
def callback(self, key, data) :
|
||||
if isinstance(key, str) :
|
||||
key = key.decode(charset)
|
||||
data = data.decode(charset)
|
||||
key = self._callback(key, data)
|
||||
if (key != bsddb._db.DB_DONOTINDEX) :
|
||||
if isinstance(key, str) :
|
||||
key = bytes(key, charset)
|
||||
elif isinstance(key, list) :
|
||||
key2 = []
|
||||
for i in key :
|
||||
if isinstance(i, str) :
|
||||
i = bytes(i, charset)
|
||||
key2.append(i)
|
||||
key = key2
|
||||
return key
|
||||
|
||||
return self._db.associate(secondarydb._db,
|
||||
associate_callback(callback).callback, flags=flags,
|
||||
txn=txn)
|
||||
|
||||
def cursor(self, txn=None, flags=0) :
|
||||
return cursor_py3k(self._db, txn=txn, flags=flags)
|
||||
|
||||
def join(self, cursor_list) :
|
||||
cursor_list = [i._dbcursor for i in cursor_list]
|
||||
return dup_cursor_py3k(self._db.join(cursor_list))
|
||||
|
||||
class DBEnv_py3k(object) :
|
||||
def __init__(self, *args, **kwargs) :
|
||||
self._dbenv = bsddb._db.DBEnv_orig(*args, **kwargs)
|
||||
|
||||
def __getattr__(self, v) :
|
||||
return getattr(self._dbenv, v)
|
||||
|
||||
def log_cursor(self, flags=0) :
|
||||
return logcursor_py3k(self._dbenv)
|
||||
|
||||
def get_lg_dir(self) :
|
||||
return self._dbenv.get_lg_dir().decode(charset)
|
||||
|
||||
def get_tmp_dir(self) :
|
||||
return self._dbenv.get_tmp_dir().decode(charset)
|
||||
|
||||
def get_data_dirs(self) :
|
||||
return tuple(
|
||||
(i.decode(charset) for i in self._dbenv.get_data_dirs()))
|
||||
|
||||
class DBSequence_py3k(object) :
|
||||
def __init__(self, db, *args, **kwargs) :
|
||||
self._db=db
|
||||
self._dbsequence = bsddb._db.DBSequence_orig(db._db, *args, **kwargs)
|
||||
|
||||
def __getattr__(self, v) :
|
||||
return getattr(self._dbsequence, v)
|
||||
|
||||
def open(self, key, *args, **kwargs) :
|
||||
return self._dbsequence.open(bytes(key, charset), *args, **kwargs)
|
||||
|
||||
def get_key(self) :
|
||||
return self._dbsequence.get_key().decode(charset)
|
||||
|
||||
def get_dbp(self) :
|
||||
return self._db
|
||||
|
||||
bsddb._db.DBEnv_orig = bsddb._db.DBEnv
|
||||
bsddb._db.DB_orig = bsddb._db.DB
|
||||
if bsddb.db.version() <= (4, 3) :
|
||||
bsddb._db.DBSequence_orig = None
|
||||
else :
|
||||
bsddb._db.DBSequence_orig = bsddb._db.DBSequence
|
||||
|
||||
def do_proxy_db_py3k(flag) :
|
||||
flag2 = do_proxy_db_py3k.flag
|
||||
do_proxy_db_py3k.flag = flag
|
||||
if flag :
|
||||
bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = DBEnv_py3k
|
||||
bsddb.DB = bsddb.db.DB = bsddb._db.DB = DB_py3k
|
||||
bsddb._db.DBSequence = DBSequence_py3k
|
||||
else :
|
||||
bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = bsddb._db.DBEnv_orig
|
||||
bsddb.DB = bsddb.db.DB = bsddb._db.DB = bsddb._db.DB_orig
|
||||
bsddb._db.DBSequence = bsddb._db.DBSequence_orig
|
||||
return flag2
|
||||
|
||||
do_proxy_db_py3k.flag = False
|
||||
do_proxy_db_py3k(True)
|
||||
|
||||
try:
|
||||
# For Pythons w/distutils pybsddb
|
||||
from bsddb3 import db, dbtables, dbutils, dbshelve, \
|
||||
hashopen, btopen, rnopen, dbobj
|
||||
except ImportError:
|
||||
# For Python 2.3
|
||||
from bsddb import db, dbtables, dbutils, dbshelve, \
|
||||
hashopen, btopen, rnopen, dbobj
|
||||
|
||||
try:
|
||||
from bsddb3 import test_support
|
||||
except ImportError:
|
||||
if sys.version_info[0] < 3 :
|
||||
from test import test_support
|
||||
else :
|
||||
from test import support as test_support
|
||||
|
||||
|
||||
try:
|
||||
if sys.version_info[0] < 3 :
|
||||
from threading import Thread, currentThread
|
||||
del Thread, currentThread
|
||||
else :
|
||||
from threading import Thread, current_thread
|
||||
del Thread, current_thread
|
||||
have_threads = True
|
||||
except ImportError:
|
||||
have_threads = False
|
||||
|
||||
verbose = 0
|
||||
if 'verbose' in sys.argv:
|
||||
verbose = 1
|
||||
sys.argv.remove('verbose')
|
||||
|
||||
if 'silent' in sys.argv: # take care of old flag, just in case
|
||||
verbose = 0
|
||||
sys.argv.remove('silent')
|
||||
|
||||
|
||||
def print_versions():
|
||||
print
|
||||
print '-=' * 38
|
||||
print db.DB_VERSION_STRING
|
||||
print 'bsddb.db.version(): %s' % (db.version(), )
|
||||
if db.version() >= (5, 0) :
|
||||
print 'bsddb.db.full_version(): %s' %repr(db.full_version())
|
||||
print 'bsddb.db.__version__: %s' % db.__version__
|
||||
print 'bsddb.db.cvsid: %s' % db.cvsid
|
||||
|
||||
# Workaround for allowing generating an EGGs as a ZIP files.
|
||||
suffix="__"
|
||||
print 'py module: %s' % getattr(bsddb, "__file"+suffix)
|
||||
print 'extension module: %s' % getattr(bsddb, "__file"+suffix)
|
||||
|
||||
print 'python version: %s' % sys.version
|
||||
print 'My pid: %s' % os.getpid()
|
||||
print '-=' * 38
|
||||
|
||||
|
||||
def get_new_path(name) :
|
||||
get_new_path.mutex.acquire()
|
||||
try :
|
||||
import os
|
||||
path=os.path.join(get_new_path.prefix,
|
||||
name+"_"+str(os.getpid())+"_"+str(get_new_path.num))
|
||||
get_new_path.num+=1
|
||||
finally :
|
||||
get_new_path.mutex.release()
|
||||
return path
|
||||
|
||||
def get_new_environment_path() :
|
||||
path=get_new_path("environment")
|
||||
import os
|
||||
try:
|
||||
os.makedirs(path,mode=0700)
|
||||
except os.error:
|
||||
test_support.rmtree(path)
|
||||
os.makedirs(path)
|
||||
return path
|
||||
|
||||
def get_new_database_path() :
|
||||
path=get_new_path("database")
|
||||
import os
|
||||
if os.path.exists(path) :
|
||||
os.remove(path)
|
||||
return path
|
||||
|
||||
|
||||
# This path can be overridden via "set_test_path_prefix()".
|
||||
import os, os.path
|
||||
get_new_path.prefix=os.path.join(os.environ.get("TMPDIR",
|
||||
os.path.join(os.sep,"tmp")), "z-Berkeley_DB")
|
||||
get_new_path.num=0
|
||||
|
||||
def get_test_path_prefix() :
|
||||
return get_new_path.prefix
|
||||
|
||||
def set_test_path_prefix(path) :
|
||||
get_new_path.prefix=path
|
||||
|
||||
def remove_test_path_directory() :
|
||||
test_support.rmtree(get_new_path.prefix)
|
||||
|
||||
if have_threads :
|
||||
import threading
|
||||
get_new_path.mutex=threading.Lock()
|
||||
del threading
|
||||
else :
|
||||
class Lock(object) :
|
||||
def acquire(self) :
|
||||
pass
|
||||
def release(self) :
|
||||
pass
|
||||
get_new_path.mutex=Lock()
|
||||
del Lock
|
||||
|
||||
|
||||
|
||||
class PrintInfoFakeTest(unittest.TestCase):
|
||||
def testPrintVersions(self):
|
||||
print_versions()
|
||||
|
||||
|
||||
# This little hack is for when this module is run as main and all the
|
||||
# other modules import it so they will still be able to get the right
|
||||
# verbose setting. It's confusing but it works.
|
||||
if sys.version_info[0] < 3 :
|
||||
import test_all
|
||||
test_all.verbose = verbose
|
||||
else :
|
||||
import sys
|
||||
print >>sys.stderr, "Work to do!"
|
||||
|
||||
|
||||
def suite(module_prefix='', timing_check=None):
|
||||
test_modules = [
|
||||
'test_associate',
|
||||
'test_basics',
|
||||
'test_dbenv',
|
||||
'test_db',
|
||||
'test_compare',
|
||||
'test_compat',
|
||||
'test_cursor_pget_bug',
|
||||
'test_dbobj',
|
||||
'test_dbshelve',
|
||||
'test_dbtables',
|
||||
'test_distributed_transactions',
|
||||
'test_early_close',
|
||||
'test_fileid',
|
||||
'test_get_none',
|
||||
'test_join',
|
||||
'test_lock',
|
||||
'test_misc',
|
||||
'test_pickle',
|
||||
'test_queue',
|
||||
'test_recno',
|
||||
'test_replication',
|
||||
'test_sequence',
|
||||
'test_thread',
|
||||
]
|
||||
|
||||
alltests = unittest.TestSuite()
|
||||
for name in test_modules:
|
||||
#module = __import__(name)
|
||||
# Do it this way so that suite may be called externally via
|
||||
# python's Lib/test/test_bsddb3.
|
||||
module = __import__(module_prefix+name, globals(), locals(), name)
|
||||
|
||||
alltests.addTest(module.test_suite())
|
||||
if timing_check:
|
||||
alltests.addTest(unittest.makeSuite(timing_check))
|
||||
return alltests
|
||||
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(unittest.makeSuite(PrintInfoFakeTest))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
print_versions()
|
||||
unittest.main(defaultTest='suite')
|
||||
482
Lib/bsddb/test/test_associate.py
Normal file
482
Lib/bsddb/test/test_associate.py
Normal file
@@ -0,0 +1,482 @@
|
||||
"""
|
||||
TestCases for DB.associate.
|
||||
"""
|
||||
|
||||
import sys, os, string
|
||||
import time
|
||||
from pprint import pprint
|
||||
|
||||
import unittest
|
||||
from test_all import db, dbshelve, test_support, verbose, have_threads, \
|
||||
get_new_environment_path
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
musicdata = {
|
||||
1 : ("Bad English", "The Price Of Love", "Rock"),
|
||||
2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"),
|
||||
3 : ("George Michael", "Praying For Time", "Rock"),
|
||||
4 : ("Gloria Estefan", "Here We Are", "Rock"),
|
||||
5 : ("Linda Ronstadt", "Don't Know Much", "Rock"),
|
||||
6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"),
|
||||
7 : ("Paul Young", "Oh Girl", "Rock"),
|
||||
8 : ("Paula Abdul", "Opposites Attract", "Rock"),
|
||||
9 : ("Richard Marx", "Should've Known Better", "Rock"),
|
||||
10: ("Rod Stewart", "Forever Young", "Rock"),
|
||||
11: ("Roxette", "Dangerous", "Rock"),
|
||||
12: ("Sheena Easton", "The Lover In Me", "Rock"),
|
||||
13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"),
|
||||
14: ("Stevie B.", "Because I Love You", "Rock"),
|
||||
15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"),
|
||||
16: ("The Bangles", "Eternal Flame", "Rock"),
|
||||
17: ("Wilson Phillips", "Release Me", "Rock"),
|
||||
18: ("Billy Joel", "Blonde Over Blue", "Rock"),
|
||||
19: ("Billy Joel", "Famous Last Words", "Rock"),
|
||||
20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"),
|
||||
21: ("Billy Joel", "The River Of Dreams", "Rock"),
|
||||
22: ("Billy Joel", "Two Thousand Years", "Rock"),
|
||||
23: ("Janet Jackson", "Alright", "Rock"),
|
||||
24: ("Janet Jackson", "Black Cat", "Rock"),
|
||||
25: ("Janet Jackson", "Come Back To Me", "Rock"),
|
||||
26: ("Janet Jackson", "Escapade", "Rock"),
|
||||
27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"),
|
||||
28: ("Janet Jackson", "Miss You Much", "Rock"),
|
||||
29: ("Janet Jackson", "Rhythm Nation", "Rock"),
|
||||
30: ("Janet Jackson", "State Of The World", "Rock"),
|
||||
31: ("Janet Jackson", "The Knowledge", "Rock"),
|
||||
32: ("Spyro Gyra", "End of Romanticism", "Jazz"),
|
||||
33: ("Spyro Gyra", "Heliopolis", "Jazz"),
|
||||
34: ("Spyro Gyra", "Jubilee", "Jazz"),
|
||||
35: ("Spyro Gyra", "Little Linda", "Jazz"),
|
||||
36: ("Spyro Gyra", "Morning Dance", "Jazz"),
|
||||
37: ("Spyro Gyra", "Song for Lorraine", "Jazz"),
|
||||
38: ("Yes", "Owner Of A Lonely Heart", "Rock"),
|
||||
39: ("Yes", "Rhythm Of Love", "Rock"),
|
||||
40: ("Cusco", "Dream Catcher", "New Age"),
|
||||
41: ("Cusco", "Geronimos Laughter", "New Age"),
|
||||
42: ("Cusco", "Ghost Dance", "New Age"),
|
||||
43: ("Blue Man Group", "Drumbone", "New Age"),
|
||||
44: ("Blue Man Group", "Endless Column", "New Age"),
|
||||
45: ("Blue Man Group", "Klein Mandelbrot", "New Age"),
|
||||
46: ("Kenny G", "Silhouette", "Jazz"),
|
||||
47: ("Sade", "Smooth Operator", "Jazz"),
|
||||
48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)",
|
||||
"New Age"),
|
||||
49: ("David Arkenstone", "Stepping Stars", "New Age"),
|
||||
50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"),
|
||||
51: ("David Lanz", "Behind The Waterfall", "New Age"),
|
||||
52: ("David Lanz", "Cristofori's Dream", "New Age"),
|
||||
53: ("David Lanz", "Heartsounds", "New Age"),
|
||||
54: ("David Lanz", "Leaves on the Seine", "New Age"),
|
||||
99: ("unknown artist", "Unnamed song", "Unknown"),
|
||||
}
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class AssociateErrorTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
|
||||
def tearDown(self):
|
||||
self.env.close()
|
||||
self.env = None
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test00_associateDBError(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test00_associateDBError..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
dupDB = db.DB(self.env)
|
||||
dupDB.set_flags(db.DB_DUP)
|
||||
dupDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE)
|
||||
|
||||
secDB = db.DB(self.env)
|
||||
secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE)
|
||||
|
||||
# dupDB has been configured to allow duplicates, it can't
|
||||
# associate with a secondary. Berkeley DB will return an error.
|
||||
try:
|
||||
def f(a,b): return a+b
|
||||
dupDB.associate(secDB, f)
|
||||
except db.DBError:
|
||||
# good
|
||||
secDB.close()
|
||||
dupDB.close()
|
||||
else:
|
||||
secDB.close()
|
||||
dupDB.close()
|
||||
self.fail("DBError exception was expected")
|
||||
|
||||
@unittest.skipUnless(db.version() >= (4, 6), 'Needs 4.6+')
|
||||
def test_associateListError(self):
|
||||
db1 = db.DB(self.env)
|
||||
db1.open('bad.db', "a.db", db.DB_BTREE, db.DB_CREATE)
|
||||
db2 = db.DB(self.env)
|
||||
db2.open('bad.db', "b.db", db.DB_BTREE, db.DB_CREATE)
|
||||
|
||||
db1.associate(db2, lambda a, b: [0])
|
||||
|
||||
msg = "TypeError: The list returned by DB->associate callback" \
|
||||
" should be a list of strings."
|
||||
with test_support.captured_output("stderr") as s:
|
||||
db1.put("0", "1")
|
||||
db1.close()
|
||||
db2.close()
|
||||
self.assertEquals(s.getvalue().strip(), msg)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
class AssociateTestCase(unittest.TestCase):
|
||||
keytype = ''
|
||||
envFlags = 0
|
||||
dbFlags = 0
|
||||
|
||||
def setUp(self):
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOCK | db.DB_THREAD | self.envFlags)
|
||||
|
||||
def tearDown(self):
|
||||
self.closeDB()
|
||||
self.env.close()
|
||||
self.env = None
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def addDataToDB(self, d, txn=None):
|
||||
for key, value in musicdata.items():
|
||||
if type(self.keytype) == type(''):
|
||||
key = "%02d" % key
|
||||
d.put(key, '|'.join(value), txn=txn)
|
||||
|
||||
def createDB(self, txn=None):
|
||||
self.cur = None
|
||||
self.secDB = None
|
||||
self.primary = db.DB(self.env)
|
||||
self.primary.set_get_returns_none(2)
|
||||
self.primary.open(self.filename, "primary", self.dbtype,
|
||||
db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn)
|
||||
|
||||
def closeDB(self):
|
||||
if self.cur:
|
||||
self.cur.close()
|
||||
self.cur = None
|
||||
if self.secDB:
|
||||
self.secDB.close()
|
||||
self.secDB = None
|
||||
self.primary.close()
|
||||
self.primary = None
|
||||
|
||||
def getDB(self):
|
||||
return self.primary
|
||||
|
||||
|
||||
def _associateWithDB(self, getGenre):
|
||||
self.createDB()
|
||||
|
||||
self.secDB = db.DB(self.env)
|
||||
self.secDB.set_flags(db.DB_DUP)
|
||||
self.secDB.set_get_returns_none(2)
|
||||
self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
||||
db.DB_CREATE | db.DB_THREAD | self.dbFlags)
|
||||
self.getDB().associate(self.secDB, getGenre)
|
||||
|
||||
self.addDataToDB(self.getDB())
|
||||
|
||||
self.finish_test(self.secDB)
|
||||
|
||||
def test01_associateWithDB(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_associateWithDB..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
return self._associateWithDB(self.getGenre)
|
||||
|
||||
def _associateAfterDB(self, getGenre) :
|
||||
self.createDB()
|
||||
self.addDataToDB(self.getDB())
|
||||
|
||||
self.secDB = db.DB(self.env)
|
||||
self.secDB.set_flags(db.DB_DUP)
|
||||
self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
||||
db.DB_CREATE | db.DB_THREAD | self.dbFlags)
|
||||
|
||||
# adding the DB_CREATE flag will cause it to index existing records
|
||||
self.getDB().associate(self.secDB, getGenre, db.DB_CREATE)
|
||||
|
||||
self.finish_test(self.secDB)
|
||||
|
||||
def test02_associateAfterDB(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test02_associateAfterDB..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
return self._associateAfterDB(self.getGenre)
|
||||
|
||||
if db.version() >= (4, 6):
|
||||
def test03_associateWithDB(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test03_associateWithDB..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
return self._associateWithDB(self.getGenreList)
|
||||
|
||||
def test04_associateAfterDB(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test04_associateAfterDB..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
return self._associateAfterDB(self.getGenreList)
|
||||
|
||||
|
||||
def finish_test(self, secDB, txn=None):
|
||||
# 'Blues' should not be in the secondary database
|
||||
vals = secDB.pget('Blues', txn=txn)
|
||||
self.assertEqual(vals, None, vals)
|
||||
|
||||
vals = secDB.pget('Unknown', txn=txn)
|
||||
self.assertIn(vals[0], (99, '99'), vals)
|
||||
vals[1].index('Unknown')
|
||||
vals[1].index('Unnamed')
|
||||
vals[1].index('unknown')
|
||||
|
||||
if verbose:
|
||||
print "Primary key traversal:"
|
||||
self.cur = self.getDB().cursor(txn)
|
||||
count = 0
|
||||
rec = self.cur.first()
|
||||
while rec is not None:
|
||||
if type(self.keytype) == type(''):
|
||||
self.assertTrue(int(rec[0])) # for primary db, key is a number
|
||||
else:
|
||||
self.assertTrue(rec[0])
|
||||
self.assertIs(type(rec[0]), int)
|
||||
count = count + 1
|
||||
if verbose:
|
||||
print rec
|
||||
rec = getattr(self.cur, "next")()
|
||||
self.assertEqual(count, len(musicdata)) # all items accounted for
|
||||
|
||||
|
||||
if verbose:
|
||||
print "Secondary key traversal:"
|
||||
self.cur = secDB.cursor(txn)
|
||||
count = 0
|
||||
|
||||
# test cursor pget
|
||||
vals = self.cur.pget('Unknown', flags=db.DB_LAST)
|
||||
self.assertIn(vals[1], (99, '99'), vals)
|
||||
self.assertEqual(vals[0], 'Unknown')
|
||||
vals[2].index('Unknown')
|
||||
vals[2].index('Unnamed')
|
||||
vals[2].index('unknown')
|
||||
|
||||
vals = self.cur.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH)
|
||||
self.assertEqual(vals, None, vals)
|
||||
|
||||
rec = self.cur.first()
|
||||
self.assertEqual(rec[0], "Jazz")
|
||||
while rec is not None:
|
||||
count = count + 1
|
||||
if verbose:
|
||||
print rec
|
||||
rec = getattr(self.cur, "next")()
|
||||
# all items accounted for EXCEPT for 1 with "Blues" genre
|
||||
self.assertEqual(count, len(musicdata)-1)
|
||||
|
||||
self.cur = None
|
||||
|
||||
def getGenre(self, priKey, priData):
|
||||
self.assertEqual(type(priData), type(""))
|
||||
genre = priData.split('|')[2]
|
||||
|
||||
if verbose:
|
||||
print 'getGenre key: %r data: %r' % (priKey, priData)
|
||||
|
||||
if genre == 'Blues':
|
||||
return db.DB_DONOTINDEX
|
||||
else:
|
||||
return genre
|
||||
|
||||
def getGenreList(self, priKey, PriData) :
|
||||
v = self.getGenre(priKey, PriData)
|
||||
if type(v) == type("") :
|
||||
v = [v]
|
||||
return v
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
class AssociateHashTestCase(AssociateTestCase):
|
||||
dbtype = db.DB_HASH
|
||||
|
||||
class AssociateBTreeTestCase(AssociateTestCase):
|
||||
dbtype = db.DB_BTREE
|
||||
|
||||
class AssociateRecnoTestCase(AssociateTestCase):
|
||||
dbtype = db.DB_RECNO
|
||||
keytype = 0
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class AssociateBTreeTxnTestCase(AssociateBTreeTestCase):
|
||||
envFlags = db.DB_INIT_TXN
|
||||
dbFlags = 0
|
||||
|
||||
def txn_finish_test(self, sDB, txn):
|
||||
try:
|
||||
self.finish_test(sDB, txn=txn)
|
||||
finally:
|
||||
if self.cur:
|
||||
self.cur.close()
|
||||
self.cur = None
|
||||
if txn:
|
||||
txn.commit()
|
||||
|
||||
def test13_associate_in_transaction(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test13_associateAutoCommit..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
txn = self.env.txn_begin()
|
||||
try:
|
||||
self.createDB(txn=txn)
|
||||
|
||||
self.secDB = db.DB(self.env)
|
||||
self.secDB.set_flags(db.DB_DUP)
|
||||
self.secDB.set_get_returns_none(2)
|
||||
self.secDB.open(self.filename, "secondary", db.DB_BTREE,
|
||||
db.DB_CREATE | db.DB_THREAD, txn=txn)
|
||||
self.getDB().associate(self.secDB, self.getGenre, txn=txn)
|
||||
|
||||
self.addDataToDB(self.getDB(), txn=txn)
|
||||
except:
|
||||
txn.abort()
|
||||
raise
|
||||
|
||||
self.txn_finish_test(self.secDB, txn=txn)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class ShelveAssociateTestCase(AssociateTestCase):
|
||||
|
||||
def createDB(self):
|
||||
self.primary = dbshelve.open(self.filename,
|
||||
dbname="primary",
|
||||
dbenv=self.env,
|
||||
filetype=self.dbtype)
|
||||
|
||||
def addDataToDB(self, d):
|
||||
for key, value in musicdata.items():
|
||||
if type(self.keytype) == type(''):
|
||||
key = "%02d" % key
|
||||
d.put(key, value) # save the value as is this time
|
||||
|
||||
|
||||
def getGenre(self, priKey, priData):
|
||||
self.assertEqual(type(priData), type(()))
|
||||
if verbose:
|
||||
print 'getGenre key: %r data: %r' % (priKey, priData)
|
||||
genre = priData[2]
|
||||
if genre == 'Blues':
|
||||
return db.DB_DONOTINDEX
|
||||
else:
|
||||
return genre
|
||||
|
||||
|
||||
class ShelveAssociateHashTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_HASH
|
||||
|
||||
class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_BTREE
|
||||
|
||||
class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_RECNO
|
||||
keytype = 0
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class ThreadedAssociateTestCase(AssociateTestCase):
|
||||
|
||||
def addDataToDB(self, d):
|
||||
t1 = Thread(target = self.writer1,
|
||||
args = (d, ))
|
||||
t2 = Thread(target = self.writer2,
|
||||
args = (d, ))
|
||||
|
||||
t1.setDaemon(True)
|
||||
t2.setDaemon(True)
|
||||
t1.start()
|
||||
t2.start()
|
||||
t1.join()
|
||||
t2.join()
|
||||
|
||||
def writer1(self, d):
|
||||
for key, value in musicdata.items():
|
||||
if type(self.keytype) == type(''):
|
||||
key = "%02d" % key
|
||||
d.put(key, '|'.join(value))
|
||||
|
||||
def writer2(self, d):
|
||||
for x in range(100, 600):
|
||||
key = 'z%2d' % x
|
||||
value = [key] * 4
|
||||
d.put(key, '|'.join(value))
|
||||
|
||||
|
||||
class ThreadedAssociateHashTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_HASH
|
||||
|
||||
class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_BTREE
|
||||
|
||||
class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase):
|
||||
dbtype = db.DB_RECNO
|
||||
keytype = 0
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(unittest.makeSuite(AssociateErrorTestCase))
|
||||
|
||||
suite.addTest(unittest.makeSuite(AssociateHashTestCase))
|
||||
suite.addTest(unittest.makeSuite(AssociateBTreeTestCase))
|
||||
suite.addTest(unittest.makeSuite(AssociateRecnoTestCase))
|
||||
|
||||
suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase))
|
||||
|
||||
suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase))
|
||||
suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase))
|
||||
suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase))
|
||||
|
||||
if have_threads:
|
||||
suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase))
|
||||
suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase))
|
||||
suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase))
|
||||
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
1158
Lib/bsddb/test/test_basics.py
Normal file
1158
Lib/bsddb/test/test_basics.py
Normal file
File diff suppressed because it is too large
Load Diff
447
Lib/bsddb/test/test_compare.py
Normal file
447
Lib/bsddb/test/test_compare.py
Normal file
@@ -0,0 +1,447 @@
|
||||
"""
|
||||
TestCases for python DB duplicate and Btree key comparison function.
|
||||
"""
|
||||
|
||||
import sys, os, re
|
||||
import test_all
|
||||
from cStringIO import StringIO
|
||||
|
||||
import unittest
|
||||
|
||||
from test_all import db, dbshelve, test_support, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
|
||||
# Needed for python 3. "cmp" vanished in 3.0.1
|
||||
def cmp(a, b) :
|
||||
if a==b : return 0
|
||||
if a<b : return -1
|
||||
return 1
|
||||
|
||||
lexical_cmp = cmp
|
||||
|
||||
def lowercase_cmp(left, right) :
|
||||
return cmp(left.lower(), right.lower())
|
||||
|
||||
def make_reverse_comparator(cmp) :
|
||||
def reverse(left, right, delegate=cmp) :
|
||||
return - delegate(left, right)
|
||||
return reverse
|
||||
|
||||
_expected_lexical_test_data = ['', 'CCCP', 'a', 'aaa', 'b', 'c', 'cccce', 'ccccf']
|
||||
_expected_lowercase_test_data = ['', 'a', 'aaa', 'b', 'c', 'CC', 'cccce', 'ccccf', 'CCCP']
|
||||
|
||||
class ComparatorTests(unittest.TestCase) :
|
||||
def comparator_test_helper(self, comparator, expected_data) :
|
||||
data = expected_data[:]
|
||||
|
||||
import sys
|
||||
if sys.version_info < (2, 6) :
|
||||
data.sort(cmp=comparator)
|
||||
else : # Insertion Sort. Please, improve
|
||||
data2 = []
|
||||
for i in data :
|
||||
for j, k in enumerate(data2) :
|
||||
r = comparator(k, i)
|
||||
if r == 1 :
|
||||
data2.insert(j, i)
|
||||
break
|
||||
else :
|
||||
data2.append(i)
|
||||
data = data2
|
||||
|
||||
self.assertEqual(data, expected_data,
|
||||
"comparator `%s' is not right: %s vs. %s"
|
||||
% (comparator, expected_data, data))
|
||||
def test_lexical_comparator(self) :
|
||||
self.comparator_test_helper(lexical_cmp, _expected_lexical_test_data)
|
||||
def test_reverse_lexical_comparator(self) :
|
||||
rev = _expected_lexical_test_data[:]
|
||||
rev.reverse()
|
||||
self.comparator_test_helper(make_reverse_comparator(lexical_cmp),
|
||||
rev)
|
||||
def test_lowercase_comparator(self) :
|
||||
self.comparator_test_helper(lowercase_cmp,
|
||||
_expected_lowercase_test_data)
|
||||
|
||||
class AbstractBtreeKeyCompareTestCase(unittest.TestCase) :
|
||||
env = None
|
||||
db = None
|
||||
|
||||
if (sys.version_info < (2, 7)) or ((sys.version_info >= (3,0)) and
|
||||
(sys.version_info < (3, 2))) :
|
||||
def assertLess(self, a, b, msg=None) :
|
||||
return self.assertTrue(a<b, msg=msg)
|
||||
|
||||
def setUp(self) :
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.homeDir = get_new_environment_path()
|
||||
env = db.DBEnv()
|
||||
env.open(self.homeDir,
|
||||
db.DB_CREATE | db.DB_INIT_MPOOL
|
||||
| db.DB_INIT_LOCK | db.DB_THREAD)
|
||||
self.env = env
|
||||
|
||||
def tearDown(self) :
|
||||
self.closeDB()
|
||||
if self.env is not None:
|
||||
self.env.close()
|
||||
self.env = None
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def addDataToDB(self, data) :
|
||||
i = 0
|
||||
for item in data:
|
||||
self.db.put(item, str(i))
|
||||
i = i + 1
|
||||
|
||||
def createDB(self, key_comparator) :
|
||||
self.db = db.DB(self.env)
|
||||
self.setupDB(key_comparator)
|
||||
self.db.open(self.filename, "test", db.DB_BTREE, db.DB_CREATE)
|
||||
|
||||
def setupDB(self, key_comparator) :
|
||||
self.db.set_bt_compare(key_comparator)
|
||||
|
||||
def closeDB(self) :
|
||||
if self.db is not None:
|
||||
self.db.close()
|
||||
self.db = None
|
||||
|
||||
def startTest(self) :
|
||||
pass
|
||||
|
||||
def finishTest(self, expected = None) :
|
||||
if expected is not None:
|
||||
self.check_results(expected)
|
||||
self.closeDB()
|
||||
|
||||
def check_results(self, expected) :
|
||||
curs = self.db.cursor()
|
||||
try:
|
||||
index = 0
|
||||
rec = curs.first()
|
||||
while rec:
|
||||
key, ignore = rec
|
||||
self.assertLess(index, len(expected),
|
||||
"to many values returned from cursor")
|
||||
self.assertEqual(expected[index], key,
|
||||
"expected value `%s' at %d but got `%s'"
|
||||
% (expected[index], index, key))
|
||||
index = index + 1
|
||||
rec = curs.next()
|
||||
self.assertEqual(index, len(expected),
|
||||
"not enough values returned from cursor")
|
||||
finally:
|
||||
curs.close()
|
||||
|
||||
class BtreeKeyCompareTestCase(AbstractBtreeKeyCompareTestCase) :
|
||||
def runCompareTest(self, comparator, data) :
|
||||
self.startTest()
|
||||
self.createDB(comparator)
|
||||
self.addDataToDB(data)
|
||||
self.finishTest(data)
|
||||
|
||||
def test_lexical_ordering(self) :
|
||||
self.runCompareTest(lexical_cmp, _expected_lexical_test_data)
|
||||
|
||||
def test_reverse_lexical_ordering(self) :
|
||||
expected_rev_data = _expected_lexical_test_data[:]
|
||||
expected_rev_data.reverse()
|
||||
self.runCompareTest(make_reverse_comparator(lexical_cmp),
|
||||
expected_rev_data)
|
||||
|
||||
def test_compare_function_useless(self) :
|
||||
self.startTest()
|
||||
def socialist_comparator(l, r) :
|
||||
return 0
|
||||
self.createDB(socialist_comparator)
|
||||
self.addDataToDB(['b', 'a', 'd'])
|
||||
# all things being equal the first key will be the only key
|
||||
# in the database... (with the last key's value fwiw)
|
||||
self.finishTest(['b'])
|
||||
|
||||
|
||||
class BtreeExceptionsTestCase(AbstractBtreeKeyCompareTestCase) :
|
||||
def test_raises_non_callable(self) :
|
||||
self.startTest()
|
||||
self.assertRaises(TypeError, self.createDB, 'abc')
|
||||
self.assertRaises(TypeError, self.createDB, None)
|
||||
self.finishTest()
|
||||
|
||||
def test_set_bt_compare_with_function(self) :
|
||||
self.startTest()
|
||||
self.createDB(lexical_cmp)
|
||||
self.finishTest()
|
||||
|
||||
def check_results(self, results) :
|
||||
pass
|
||||
|
||||
def test_compare_function_incorrect(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
return 1
|
||||
# verify that set_bt_compare checks that comparator('', '') == 0
|
||||
self.assertRaises(TypeError, self.createDB, bad_comparator)
|
||||
self.finishTest()
|
||||
|
||||
def verifyStderr(self, method, successRe) :
|
||||
"""
|
||||
Call method() while capturing sys.stderr output internally and
|
||||
call self.fail() if successRe.search() does not match the stderr
|
||||
output. This is used to test for uncatchable exceptions.
|
||||
"""
|
||||
stdErr = sys.stderr
|
||||
sys.stderr = StringIO()
|
||||
try:
|
||||
method()
|
||||
finally:
|
||||
temp = sys.stderr
|
||||
sys.stderr = stdErr
|
||||
errorOut = temp.getvalue()
|
||||
if not successRe.search(errorOut) :
|
||||
self.fail("unexpected stderr output:\n"+errorOut)
|
||||
if sys.version_info < (3, 0) : # XXX: How to do this in Py3k ???
|
||||
sys.exc_traceback = sys.last_traceback = None
|
||||
|
||||
def _test_compare_function_exception(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
if l == r:
|
||||
# pass the set_bt_compare test
|
||||
return 0
|
||||
raise RuntimeError, "i'm a naughty comparison function"
|
||||
self.createDB(bad_comparator)
|
||||
#print "\n*** test should print 2 uncatchable tracebacks ***"
|
||||
self.addDataToDB(['a', 'b', 'c']) # this should raise, but...
|
||||
self.finishTest()
|
||||
|
||||
def test_compare_function_exception(self) :
|
||||
self.verifyStderr(
|
||||
self._test_compare_function_exception,
|
||||
re.compile('(^RuntimeError:.* naughty.*){2}', re.M|re.S)
|
||||
)
|
||||
|
||||
def _test_compare_function_bad_return(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
if l == r:
|
||||
# pass the set_bt_compare test
|
||||
return 0
|
||||
return l
|
||||
self.createDB(bad_comparator)
|
||||
#print "\n*** test should print 2 errors about returning an int ***"
|
||||
self.addDataToDB(['a', 'b', 'c']) # this should raise, but...
|
||||
self.finishTest()
|
||||
|
||||
def test_compare_function_bad_return(self) :
|
||||
self.verifyStderr(
|
||||
self._test_compare_function_bad_return,
|
||||
re.compile('(^TypeError:.* return an int.*){2}', re.M|re.S)
|
||||
)
|
||||
|
||||
|
||||
def test_cannot_assign_twice(self) :
|
||||
|
||||
def my_compare(a, b) :
|
||||
return 0
|
||||
|
||||
self.startTest()
|
||||
self.createDB(my_compare)
|
||||
self.assertRaises(RuntimeError, self.db.set_bt_compare, my_compare)
|
||||
|
||||
class AbstractDuplicateCompareTestCase(unittest.TestCase) :
|
||||
env = None
|
||||
db = None
|
||||
|
||||
if (sys.version_info < (2, 7)) or ((sys.version_info >= (3,0)) and
|
||||
(sys.version_info < (3, 2))) :
|
||||
def assertLess(self, a, b, msg=None) :
|
||||
return self.assertTrue(a<b, msg=msg)
|
||||
|
||||
def setUp(self) :
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.homeDir = get_new_environment_path()
|
||||
env = db.DBEnv()
|
||||
env.open(self.homeDir,
|
||||
db.DB_CREATE | db.DB_INIT_MPOOL
|
||||
| db.DB_INIT_LOCK | db.DB_THREAD)
|
||||
self.env = env
|
||||
|
||||
def tearDown(self) :
|
||||
self.closeDB()
|
||||
if self.env is not None:
|
||||
self.env.close()
|
||||
self.env = None
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def addDataToDB(self, data) :
|
||||
for item in data:
|
||||
self.db.put("key", item)
|
||||
|
||||
def createDB(self, dup_comparator) :
|
||||
self.db = db.DB(self.env)
|
||||
self.setupDB(dup_comparator)
|
||||
self.db.open(self.filename, "test", db.DB_BTREE, db.DB_CREATE)
|
||||
|
||||
def setupDB(self, dup_comparator) :
|
||||
self.db.set_flags(db.DB_DUPSORT)
|
||||
self.db.set_dup_compare(dup_comparator)
|
||||
|
||||
def closeDB(self) :
|
||||
if self.db is not None:
|
||||
self.db.close()
|
||||
self.db = None
|
||||
|
||||
def startTest(self) :
|
||||
pass
|
||||
|
||||
def finishTest(self, expected = None) :
|
||||
if expected is not None:
|
||||
self.check_results(expected)
|
||||
self.closeDB()
|
||||
|
||||
def check_results(self, expected) :
|
||||
curs = self.db.cursor()
|
||||
try:
|
||||
index = 0
|
||||
rec = curs.first()
|
||||
while rec:
|
||||
ignore, data = rec
|
||||
self.assertLess(index, len(expected),
|
||||
"to many values returned from cursor")
|
||||
self.assertEqual(expected[index], data,
|
||||
"expected value `%s' at %d but got `%s'"
|
||||
% (expected[index], index, data))
|
||||
index = index + 1
|
||||
rec = curs.next()
|
||||
self.assertEqual(index, len(expected),
|
||||
"not enough values returned from cursor")
|
||||
finally:
|
||||
curs.close()
|
||||
|
||||
class DuplicateCompareTestCase(AbstractDuplicateCompareTestCase) :
|
||||
def runCompareTest(self, comparator, data) :
|
||||
self.startTest()
|
||||
self.createDB(comparator)
|
||||
self.addDataToDB(data)
|
||||
self.finishTest(data)
|
||||
|
||||
def test_lexical_ordering(self) :
|
||||
self.runCompareTest(lexical_cmp, _expected_lexical_test_data)
|
||||
|
||||
def test_reverse_lexical_ordering(self) :
|
||||
expected_rev_data = _expected_lexical_test_data[:]
|
||||
expected_rev_data.reverse()
|
||||
self.runCompareTest(make_reverse_comparator(lexical_cmp),
|
||||
expected_rev_data)
|
||||
|
||||
class DuplicateExceptionsTestCase(AbstractDuplicateCompareTestCase) :
|
||||
def test_raises_non_callable(self) :
|
||||
self.startTest()
|
||||
self.assertRaises(TypeError, self.createDB, 'abc')
|
||||
self.assertRaises(TypeError, self.createDB, None)
|
||||
self.finishTest()
|
||||
|
||||
def test_set_dup_compare_with_function(self) :
|
||||
self.startTest()
|
||||
self.createDB(lexical_cmp)
|
||||
self.finishTest()
|
||||
|
||||
def check_results(self, results) :
|
||||
pass
|
||||
|
||||
def test_compare_function_incorrect(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
return 1
|
||||
# verify that set_dup_compare checks that comparator('', '') == 0
|
||||
self.assertRaises(TypeError, self.createDB, bad_comparator)
|
||||
self.finishTest()
|
||||
|
||||
def test_compare_function_useless(self) :
|
||||
self.startTest()
|
||||
def socialist_comparator(l, r) :
|
||||
return 0
|
||||
self.createDB(socialist_comparator)
|
||||
# DUPSORT does not allow "duplicate duplicates"
|
||||
self.assertRaises(db.DBKeyExistError, self.addDataToDB, ['b', 'a', 'd'])
|
||||
self.finishTest()
|
||||
|
||||
def verifyStderr(self, method, successRe) :
|
||||
"""
|
||||
Call method() while capturing sys.stderr output internally and
|
||||
call self.fail() if successRe.search() does not match the stderr
|
||||
output. This is used to test for uncatchable exceptions.
|
||||
"""
|
||||
stdErr = sys.stderr
|
||||
sys.stderr = StringIO()
|
||||
try:
|
||||
method()
|
||||
finally:
|
||||
temp = sys.stderr
|
||||
sys.stderr = stdErr
|
||||
errorOut = temp.getvalue()
|
||||
if not successRe.search(errorOut) :
|
||||
self.fail("unexpected stderr output:\n"+errorOut)
|
||||
if sys.version_info < (3, 0) : # XXX: How to do this in Py3k ???
|
||||
sys.exc_traceback = sys.last_traceback = None
|
||||
|
||||
def _test_compare_function_exception(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
if l == r:
|
||||
# pass the set_dup_compare test
|
||||
return 0
|
||||
raise RuntimeError, "i'm a naughty comparison function"
|
||||
self.createDB(bad_comparator)
|
||||
#print "\n*** test should print 2 uncatchable tracebacks ***"
|
||||
self.addDataToDB(['a', 'b', 'c']) # this should raise, but...
|
||||
self.finishTest()
|
||||
|
||||
def test_compare_function_exception(self) :
|
||||
self.verifyStderr(
|
||||
self._test_compare_function_exception,
|
||||
re.compile('(^RuntimeError:.* naughty.*){2}', re.M|re.S)
|
||||
)
|
||||
|
||||
def _test_compare_function_bad_return(self) :
|
||||
self.startTest()
|
||||
def bad_comparator(l, r) :
|
||||
if l == r:
|
||||
# pass the set_dup_compare test
|
||||
return 0
|
||||
return l
|
||||
self.createDB(bad_comparator)
|
||||
#print "\n*** test should print 2 errors about returning an int ***"
|
||||
self.addDataToDB(['a', 'b', 'c']) # this should raise, but...
|
||||
self.finishTest()
|
||||
|
||||
def test_compare_function_bad_return(self) :
|
||||
self.verifyStderr(
|
||||
self._test_compare_function_bad_return,
|
||||
re.compile('(^TypeError:.* return an int.*){2}', re.M|re.S)
|
||||
)
|
||||
|
||||
|
||||
def test_cannot_assign_twice(self) :
|
||||
|
||||
def my_compare(a, b) :
|
||||
return 0
|
||||
|
||||
self.startTest()
|
||||
self.createDB(my_compare)
|
||||
self.assertRaises(RuntimeError, self.db.set_dup_compare, my_compare)
|
||||
|
||||
def test_suite() :
|
||||
res = unittest.TestSuite()
|
||||
|
||||
res.addTest(unittest.makeSuite(ComparatorTests))
|
||||
res.addTest(unittest.makeSuite(BtreeExceptionsTestCase))
|
||||
res.addTest(unittest.makeSuite(BtreeKeyCompareTestCase))
|
||||
res.addTest(unittest.makeSuite(DuplicateExceptionsTestCase))
|
||||
res.addTest(unittest.makeSuite(DuplicateCompareTestCase))
|
||||
return res
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest = 'suite')
|
||||
184
Lib/bsddb/test/test_compat.py
Normal file
184
Lib/bsddb/test/test_compat.py
Normal file
@@ -0,0 +1,184 @@
|
||||
"""
|
||||
Test cases adapted from the test_bsddb.py module in Python's
|
||||
regression test suite.
|
||||
"""
|
||||
|
||||
import os, string
|
||||
import unittest
|
||||
|
||||
from test_all import db, hashopen, btopen, rnopen, verbose, \
|
||||
get_new_database_path
|
||||
|
||||
|
||||
class CompatibilityTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.filename = get_new_database_path()
|
||||
|
||||
def tearDown(self):
|
||||
try:
|
||||
os.remove(self.filename)
|
||||
except os.error:
|
||||
pass
|
||||
|
||||
|
||||
def test01_btopen(self):
|
||||
self.do_bthash_test(btopen, 'btopen')
|
||||
|
||||
def test02_hashopen(self):
|
||||
self.do_bthash_test(hashopen, 'hashopen')
|
||||
|
||||
def test03_rnopen(self):
|
||||
data = "The quick brown fox jumped over the lazy dog.".split()
|
||||
if verbose:
|
||||
print "\nTesting: rnopen"
|
||||
|
||||
f = rnopen(self.filename, 'c')
|
||||
for x in range(len(data)):
|
||||
f[x+1] = data[x]
|
||||
|
||||
getTest = (f[1], f[2], f[3])
|
||||
if verbose:
|
||||
print '%s %s %s' % getTest
|
||||
|
||||
self.assertEqual(getTest[1], 'quick', 'data mismatch!')
|
||||
|
||||
rv = f.set_location(3)
|
||||
if rv != (3, 'brown'):
|
||||
self.fail('recno database set_location failed: '+repr(rv))
|
||||
|
||||
f[25] = 'twenty-five'
|
||||
f.close()
|
||||
del f
|
||||
|
||||
f = rnopen(self.filename, 'w')
|
||||
f[20] = 'twenty'
|
||||
|
||||
def noRec(f):
|
||||
rec = f[15]
|
||||
self.assertRaises(KeyError, noRec, f)
|
||||
|
||||
def badKey(f):
|
||||
rec = f['a string']
|
||||
self.assertRaises(TypeError, badKey, f)
|
||||
|
||||
del f[3]
|
||||
|
||||
rec = f.first()
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
try:
|
||||
rec = f.next()
|
||||
except KeyError:
|
||||
break
|
||||
|
||||
f.close()
|
||||
|
||||
|
||||
def test04_n_flag(self):
|
||||
f = hashopen(self.filename, 'n')
|
||||
f.close()
|
||||
|
||||
|
||||
def do_bthash_test(self, factory, what):
|
||||
if verbose:
|
||||
print '\nTesting: ', what
|
||||
|
||||
f = factory(self.filename, 'c')
|
||||
if verbose:
|
||||
print 'creation...'
|
||||
|
||||
# truth test
|
||||
if f:
|
||||
if verbose: print "truth test: true"
|
||||
else:
|
||||
if verbose: print "truth test: false"
|
||||
|
||||
f['0'] = ''
|
||||
f['a'] = 'Guido'
|
||||
f['b'] = 'van'
|
||||
f['c'] = 'Rossum'
|
||||
f['d'] = 'invented'
|
||||
# 'e' intentionally left out
|
||||
f['f'] = 'Python'
|
||||
if verbose:
|
||||
print '%s %s %s' % (f['a'], f['b'], f['c'])
|
||||
|
||||
if verbose:
|
||||
print 'key ordering...'
|
||||
start = f.set_location(f.first()[0])
|
||||
if start != ('0', ''):
|
||||
self.fail("incorrect first() result: "+repr(start))
|
||||
while 1:
|
||||
try:
|
||||
rec = f.next()
|
||||
except KeyError:
|
||||
self.assertEqual(rec, f.last(), 'Error, last <> last!')
|
||||
f.previous()
|
||||
break
|
||||
if verbose:
|
||||
print rec
|
||||
|
||||
self.assertTrue(f.has_key('f'), 'Error, missing key!')
|
||||
|
||||
# test that set_location() returns the next nearest key, value
|
||||
# on btree databases and raises KeyError on others.
|
||||
if factory == btopen:
|
||||
e = f.set_location('e')
|
||||
if e != ('f', 'Python'):
|
||||
self.fail('wrong key,value returned: '+repr(e))
|
||||
else:
|
||||
try:
|
||||
e = f.set_location('e')
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
self.fail("set_location on non-existent key did not raise KeyError")
|
||||
|
||||
f.sync()
|
||||
f.close()
|
||||
# truth test
|
||||
try:
|
||||
if f:
|
||||
if verbose: print "truth test: true"
|
||||
else:
|
||||
if verbose: print "truth test: false"
|
||||
except db.DBError:
|
||||
pass
|
||||
else:
|
||||
self.fail("Exception expected")
|
||||
|
||||
del f
|
||||
|
||||
if verbose:
|
||||
print 'modification...'
|
||||
f = factory(self.filename, 'w')
|
||||
f['d'] = 'discovered'
|
||||
|
||||
if verbose:
|
||||
print 'access...'
|
||||
for key in f.keys():
|
||||
word = f[key]
|
||||
if verbose:
|
||||
print word
|
||||
|
||||
def noRec(f):
|
||||
rec = f['no such key']
|
||||
self.assertRaises(KeyError, noRec, f)
|
||||
|
||||
def badKey(f):
|
||||
rec = f[15]
|
||||
self.assertRaises(TypeError, badKey, f)
|
||||
|
||||
f.close()
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(CompatibilityTestCase)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
54
Lib/bsddb/test/test_cursor_pget_bug.py
Normal file
54
Lib/bsddb/test/test_cursor_pget_bug.py
Normal file
@@ -0,0 +1,54 @@
|
||||
import unittest
|
||||
import os, glob
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, \
|
||||
get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class pget_bugTestCase(unittest.TestCase):
|
||||
"""Verify that cursor.pget works properly"""
|
||||
db_name = 'test-cursor_pget.db'
|
||||
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
self.primary_db = db.DB(self.env)
|
||||
self.primary_db.open(self.db_name, 'primary', db.DB_BTREE, db.DB_CREATE)
|
||||
self.secondary_db = db.DB(self.env)
|
||||
self.secondary_db.set_flags(db.DB_DUP)
|
||||
self.secondary_db.open(self.db_name, 'secondary', db.DB_BTREE, db.DB_CREATE)
|
||||
self.primary_db.associate(self.secondary_db, lambda key, data: data)
|
||||
self.primary_db.put('salad', 'eggs')
|
||||
self.primary_db.put('spam', 'ham')
|
||||
self.primary_db.put('omelet', 'eggs')
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
self.secondary_db.close()
|
||||
self.primary_db.close()
|
||||
self.env.close()
|
||||
del self.secondary_db
|
||||
del self.primary_db
|
||||
del self.env
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test_pget(self):
|
||||
cursor = self.secondary_db.cursor()
|
||||
|
||||
self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET))
|
||||
self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP))
|
||||
self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
|
||||
|
||||
self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET))
|
||||
self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
|
||||
|
||||
cursor.close()
|
||||
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(pget_bugTestCase)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
163
Lib/bsddb/test/test_db.py
Normal file
163
Lib/bsddb/test/test_db.py
Normal file
@@ -0,0 +1,163 @@
|
||||
import unittest
|
||||
import os, glob
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, \
|
||||
get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DB(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.path = get_new_database_path()
|
||||
self.db = db.DB()
|
||||
|
||||
def tearDown(self):
|
||||
self.db.close()
|
||||
del self.db
|
||||
test_support.unlink(self.path)
|
||||
|
||||
class DB_general(DB) :
|
||||
def test_get_open_flags(self) :
|
||||
self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE)
|
||||
self.assertEqual(db.DB_CREATE, self.db.get_open_flags())
|
||||
|
||||
def test_get_open_flags2(self) :
|
||||
self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE |
|
||||
db.DB_THREAD)
|
||||
self.assertEqual(db.DB_CREATE | db.DB_THREAD, self.db.get_open_flags())
|
||||
|
||||
def test_get_dbname_filename(self) :
|
||||
self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE)
|
||||
self.assertEqual((self.path, None), self.db.get_dbname())
|
||||
|
||||
def test_get_dbname_filename_database(self) :
|
||||
name = "jcea-random-name"
|
||||
self.db.open(self.path, dbname=name, dbtype=db.DB_HASH,
|
||||
flags = db.DB_CREATE)
|
||||
self.assertEqual((self.path, name), self.db.get_dbname())
|
||||
|
||||
def test_bt_minkey(self) :
|
||||
for i in [17, 108, 1030] :
|
||||
self.db.set_bt_minkey(i)
|
||||
self.assertEqual(i, self.db.get_bt_minkey())
|
||||
|
||||
def test_lorder(self) :
|
||||
self.db.set_lorder(1234)
|
||||
self.assertEqual(1234, self.db.get_lorder())
|
||||
self.db.set_lorder(4321)
|
||||
self.assertEqual(4321, self.db.get_lorder())
|
||||
self.assertRaises(db.DBInvalidArgError, self.db.set_lorder, 9182)
|
||||
|
||||
if db.version() >= (4, 6) :
|
||||
def test_priority(self) :
|
||||
flags = [db.DB_PRIORITY_VERY_LOW, db.DB_PRIORITY_LOW,
|
||||
db.DB_PRIORITY_DEFAULT, db.DB_PRIORITY_HIGH,
|
||||
db.DB_PRIORITY_VERY_HIGH]
|
||||
for flag in flags :
|
||||
self.db.set_priority(flag)
|
||||
self.assertEqual(flag, self.db.get_priority())
|
||||
|
||||
def test_get_transactional(self) :
|
||||
self.assertFalse(self.db.get_transactional())
|
||||
self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE)
|
||||
self.assertFalse(self.db.get_transactional())
|
||||
|
||||
class DB_hash(DB) :
|
||||
def test_h_ffactor(self) :
|
||||
for ffactor in [4, 16, 256] :
|
||||
self.db.set_h_ffactor(ffactor)
|
||||
self.assertEqual(ffactor, self.db.get_h_ffactor())
|
||||
|
||||
def test_h_nelem(self) :
|
||||
for nelem in [1, 2, 4] :
|
||||
nelem = nelem*1024*1024 # Millions
|
||||
self.db.set_h_nelem(nelem)
|
||||
self.assertEqual(nelem, self.db.get_h_nelem())
|
||||
|
||||
def test_pagesize(self) :
|
||||
for i in xrange(9, 17) : # From 512 to 65536
|
||||
i = 1<<i
|
||||
self.db.set_pagesize(i)
|
||||
self.assertEqual(i, self.db.get_pagesize())
|
||||
|
||||
# The valid values goes from 512 to 65536
|
||||
# Test 131072 bytes...
|
||||
self.assertRaises(db.DBInvalidArgError, self.db.set_pagesize, 1<<17)
|
||||
# Test 256 bytes...
|
||||
self.assertRaises(db.DBInvalidArgError, self.db.set_pagesize, 1<<8)
|
||||
|
||||
class DB_txn(DB) :
|
||||
def setUp(self) :
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOG | db.DB_INIT_TXN)
|
||||
self.db = db.DB(self.env)
|
||||
|
||||
def tearDown(self) :
|
||||
self.db.close()
|
||||
del self.db
|
||||
self.env.close()
|
||||
del self.env
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test_flags(self) :
|
||||
self.db.set_flags(db.DB_CHKSUM)
|
||||
self.assertEqual(db.DB_CHKSUM, self.db.get_flags())
|
||||
self.db.set_flags(db.DB_TXN_NOT_DURABLE)
|
||||
self.assertEqual(db.DB_TXN_NOT_DURABLE | db.DB_CHKSUM,
|
||||
self.db.get_flags())
|
||||
|
||||
def test_get_transactional(self) :
|
||||
self.assertFalse(self.db.get_transactional())
|
||||
# DB_AUTO_COMMIT = Implicit transaction
|
||||
self.db.open("XXX", dbtype=db.DB_HASH,
|
||||
flags = db.DB_CREATE | db.DB_AUTO_COMMIT)
|
||||
self.assertTrue(self.db.get_transactional())
|
||||
|
||||
class DB_recno(DB) :
|
||||
def test_re_pad(self) :
|
||||
for i in [' ', '*'] : # Check chars
|
||||
self.db.set_re_pad(i)
|
||||
self.assertEqual(ord(i), self.db.get_re_pad())
|
||||
for i in [97, 65] : # Check integers
|
||||
self.db.set_re_pad(i)
|
||||
self.assertEqual(i, self.db.get_re_pad())
|
||||
|
||||
def test_re_delim(self) :
|
||||
for i in [' ', '*'] : # Check chars
|
||||
self.db.set_re_delim(i)
|
||||
self.assertEqual(ord(i), self.db.get_re_delim())
|
||||
for i in [97, 65] : # Check integers
|
||||
self.db.set_re_delim(i)
|
||||
self.assertEqual(i, self.db.get_re_delim())
|
||||
|
||||
def test_re_source(self) :
|
||||
for i in ["test", "test2", "test3"] :
|
||||
self.db.set_re_source(i)
|
||||
self.assertEqual(i, self.db.get_re_source())
|
||||
|
||||
class DB_queue(DB) :
|
||||
def test_re_len(self) :
|
||||
for i in [33, 65, 300, 2000] :
|
||||
self.db.set_re_len(i)
|
||||
self.assertEqual(i, self.db.get_re_len())
|
||||
|
||||
def test_q_extentsize(self) :
|
||||
for i in [1, 60, 100] :
|
||||
self.db.set_q_extentsize(i)
|
||||
self.assertEqual(i, self.db.get_q_extentsize())
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(unittest.makeSuite(DB_general))
|
||||
suite.addTest(unittest.makeSuite(DB_txn))
|
||||
suite.addTest(unittest.makeSuite(DB_hash))
|
||||
suite.addTest(unittest.makeSuite(DB_recno))
|
||||
suite.addTest(unittest.makeSuite(DB_queue))
|
||||
|
||||
return suite
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
525
Lib/bsddb/test/test_dbenv.py
Normal file
525
Lib/bsddb/test/test_dbenv.py
Normal file
@@ -0,0 +1,525 @@
|
||||
import unittest
|
||||
import os, glob
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, \
|
||||
get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DBEnv(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
|
||||
def tearDown(self):
|
||||
self.env.close()
|
||||
del self.env
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
class DBEnv_general(DBEnv) :
|
||||
def test_get_open_flags(self) :
|
||||
flags = db.DB_CREATE | db.DB_INIT_MPOOL
|
||||
self.env.open(self.homeDir, flags)
|
||||
self.assertEqual(flags, self.env.get_open_flags())
|
||||
|
||||
def test_get_open_flags2(self) :
|
||||
flags = db.DB_CREATE | db.DB_INIT_MPOOL | \
|
||||
db.DB_INIT_LOCK | db.DB_THREAD
|
||||
self.env.open(self.homeDir, flags)
|
||||
self.assertEqual(flags, self.env.get_open_flags())
|
||||
|
||||
if db.version() >= (4, 7) :
|
||||
def test_lk_partitions(self) :
|
||||
for i in [10, 20, 40] :
|
||||
self.env.set_lk_partitions(i)
|
||||
self.assertEqual(i, self.env.get_lk_partitions())
|
||||
|
||||
def test_getset_intermediate_dir_mode(self) :
|
||||
self.assertEqual(None, self.env.get_intermediate_dir_mode())
|
||||
for mode in ["rwx------", "rw-rw-rw-", "rw-r--r--"] :
|
||||
self.env.set_intermediate_dir_mode(mode)
|
||||
self.assertEqual(mode, self.env.get_intermediate_dir_mode())
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.set_intermediate_dir_mode, "abcde")
|
||||
|
||||
if db.version() >= (4, 6) :
|
||||
def test_thread(self) :
|
||||
for i in [16, 100, 1000] :
|
||||
self.env.set_thread_count(i)
|
||||
self.assertEqual(i, self.env.get_thread_count())
|
||||
|
||||
def test_cache_max(self) :
|
||||
for size in [64, 128] :
|
||||
size = size*1024*1024 # Megabytes
|
||||
self.env.set_cache_max(0, size)
|
||||
size2 = self.env.get_cache_max()
|
||||
self.assertEqual(0, size2[0])
|
||||
self.assertLessEqual(size, size2[1])
|
||||
self.assertGreater(2*size, size2[1])
|
||||
|
||||
if db.version() >= (4, 4) :
|
||||
def test_mutex_stat(self) :
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOCK)
|
||||
stat = self.env.mutex_stat()
|
||||
self.assertIn("mutex_inuse_max", stat)
|
||||
|
||||
def test_lg_filemode(self) :
|
||||
for i in [0600, 0660, 0666] :
|
||||
self.env.set_lg_filemode(i)
|
||||
self.assertEqual(i, self.env.get_lg_filemode())
|
||||
|
||||
def test_mp_max_openfd(self) :
|
||||
for i in [17, 31, 42] :
|
||||
self.env.set_mp_max_openfd(i)
|
||||
self.assertEqual(i, self.env.get_mp_max_openfd())
|
||||
|
||||
def test_mp_max_write(self) :
|
||||
for i in [100, 200, 300] :
|
||||
for j in [1, 2, 3] :
|
||||
j *= 1000000
|
||||
self.env.set_mp_max_write(i, j)
|
||||
v=self.env.get_mp_max_write()
|
||||
self.assertEqual((i, j), v)
|
||||
|
||||
def test_invalid_txn(self) :
|
||||
# This environment doesn't support transactions
|
||||
self.assertRaises(db.DBInvalidArgError, self.env.txn_begin)
|
||||
|
||||
def test_mp_mmapsize(self) :
|
||||
for i in [16, 32, 64] :
|
||||
i *= 1024*1024
|
||||
self.env.set_mp_mmapsize(i)
|
||||
self.assertEqual(i, self.env.get_mp_mmapsize())
|
||||
|
||||
def test_tmp_dir(self) :
|
||||
for i in ["a", "bb", "ccc"] :
|
||||
self.env.set_tmp_dir(i)
|
||||
self.assertEqual(i, self.env.get_tmp_dir())
|
||||
|
||||
def test_flags(self) :
|
||||
self.env.set_flags(db.DB_AUTO_COMMIT, 1)
|
||||
self.assertEqual(db.DB_AUTO_COMMIT, self.env.get_flags())
|
||||
self.env.set_flags(db.DB_TXN_NOSYNC, 1)
|
||||
self.assertEqual(db.DB_AUTO_COMMIT | db.DB_TXN_NOSYNC,
|
||||
self.env.get_flags())
|
||||
self.env.set_flags(db.DB_AUTO_COMMIT, 0)
|
||||
self.assertEqual(db.DB_TXN_NOSYNC, self.env.get_flags())
|
||||
self.env.set_flags(db.DB_TXN_NOSYNC, 0)
|
||||
self.assertEqual(0, self.env.get_flags())
|
||||
|
||||
def test_lk_max_objects(self) :
|
||||
for i in [1000, 2000, 3000] :
|
||||
self.env.set_lk_max_objects(i)
|
||||
self.assertEqual(i, self.env.get_lk_max_objects())
|
||||
|
||||
def test_lk_max_locks(self) :
|
||||
for i in [1000, 2000, 3000] :
|
||||
self.env.set_lk_max_locks(i)
|
||||
self.assertEqual(i, self.env.get_lk_max_locks())
|
||||
|
||||
def test_lk_max_lockers(self) :
|
||||
for i in [1000, 2000, 3000] :
|
||||
self.env.set_lk_max_lockers(i)
|
||||
self.assertEqual(i, self.env.get_lk_max_lockers())
|
||||
|
||||
def test_lg_regionmax(self) :
|
||||
for i in [128, 256, 1000] :
|
||||
i = i*1024*1024
|
||||
self.env.set_lg_regionmax(i)
|
||||
j = self.env.get_lg_regionmax()
|
||||
self.assertLessEqual(i, j)
|
||||
self.assertGreater(2*i, j)
|
||||
|
||||
def test_lk_detect(self) :
|
||||
flags= [db.DB_LOCK_DEFAULT, db.DB_LOCK_EXPIRE, db.DB_LOCK_MAXLOCKS,
|
||||
db.DB_LOCK_MINLOCKS, db.DB_LOCK_MINWRITE,
|
||||
db.DB_LOCK_OLDEST, db.DB_LOCK_RANDOM, db.DB_LOCK_YOUNGEST]
|
||||
|
||||
flags.append(db.DB_LOCK_MAXWRITE)
|
||||
|
||||
for i in flags :
|
||||
self.env.set_lk_detect(i)
|
||||
self.assertEqual(i, self.env.get_lk_detect())
|
||||
|
||||
def test_lg_dir(self) :
|
||||
for i in ["a", "bb", "ccc", "dddd"] :
|
||||
self.env.set_lg_dir(i)
|
||||
self.assertEqual(i, self.env.get_lg_dir())
|
||||
|
||||
def test_lg_bsize(self) :
|
||||
log_size = 70*1024
|
||||
self.env.set_lg_bsize(log_size)
|
||||
self.assertGreaterEqual(self.env.get_lg_bsize(), log_size)
|
||||
self.assertLess(self.env.get_lg_bsize(), 4*log_size)
|
||||
self.env.set_lg_bsize(4*log_size)
|
||||
self.assertGreaterEqual(self.env.get_lg_bsize(), 4*log_size)
|
||||
|
||||
def test_setget_data_dirs(self) :
|
||||
dirs = ("a", "b", "c", "d")
|
||||
for i in dirs :
|
||||
self.env.set_data_dir(i)
|
||||
self.assertEqual(dirs, self.env.get_data_dirs())
|
||||
|
||||
def test_setget_cachesize(self) :
|
||||
cachesize = (0, 512*1024*1024, 3)
|
||||
self.env.set_cachesize(*cachesize)
|
||||
self.assertEqual(cachesize, self.env.get_cachesize())
|
||||
|
||||
cachesize = (0, 1*1024*1024, 5)
|
||||
self.env.set_cachesize(*cachesize)
|
||||
cachesize2 = self.env.get_cachesize()
|
||||
self.assertEqual(cachesize[0], cachesize2[0])
|
||||
self.assertEqual(cachesize[2], cachesize2[2])
|
||||
# Berkeley DB expands the cache 25% accounting overhead,
|
||||
# if the cache is small.
|
||||
self.assertEqual(125, int(100.0*cachesize2[1]/cachesize[1]))
|
||||
|
||||
# You can not change configuration after opening
|
||||
# the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
cachesize = (0, 2*1024*1024, 1)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.set_cachesize, *cachesize)
|
||||
cachesize3 = self.env.get_cachesize()
|
||||
self.assertEqual(cachesize2[0], cachesize3[0])
|
||||
self.assertEqual(cachesize2[2], cachesize3[2])
|
||||
# In Berkeley DB 5.1, the cachesize can change when opening the Env
|
||||
self.assertLessEqual(cachesize2[1], cachesize3[1])
|
||||
|
||||
def test_set_cachesize_dbenv_db(self) :
|
||||
# You can not configure the cachesize using
|
||||
# the database handle, if you are using an environment.
|
||||
d = db.DB(self.env)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
d.set_cachesize, 0, 1024*1024, 1)
|
||||
|
||||
def test_setget_shm_key(self) :
|
||||
shm_key=137
|
||||
self.env.set_shm_key(shm_key)
|
||||
self.assertEqual(shm_key, self.env.get_shm_key())
|
||||
self.env.set_shm_key(shm_key+1)
|
||||
self.assertEqual(shm_key+1, self.env.get_shm_key())
|
||||
|
||||
# You can not change configuration after opening
|
||||
# the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
# If we try to reconfigure cache after opening the
|
||||
# environment, core dump.
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.set_shm_key, shm_key)
|
||||
self.assertEqual(shm_key+1, self.env.get_shm_key())
|
||||
|
||||
if db.version() >= (4, 4) :
|
||||
def test_mutex_setget_max(self) :
|
||||
v = self.env.mutex_get_max()
|
||||
v2 = v*2+1
|
||||
|
||||
self.env.mutex_set_max(v2)
|
||||
self.assertEqual(v2, self.env.mutex_get_max())
|
||||
|
||||
self.env.mutex_set_max(v)
|
||||
self.assertEqual(v, self.env.mutex_get_max())
|
||||
|
||||
# You can not change configuration after opening
|
||||
# the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.mutex_set_max, v2)
|
||||
|
||||
def test_mutex_setget_increment(self) :
|
||||
v = self.env.mutex_get_increment()
|
||||
v2 = 127
|
||||
|
||||
self.env.mutex_set_increment(v2)
|
||||
self.assertEqual(v2, self.env.mutex_get_increment())
|
||||
|
||||
self.env.mutex_set_increment(v)
|
||||
self.assertEqual(v, self.env.mutex_get_increment())
|
||||
|
||||
# You can not change configuration after opening
|
||||
# the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.mutex_set_increment, v2)
|
||||
|
||||
def test_mutex_setget_tas_spins(self) :
|
||||
self.env.mutex_set_tas_spins(0) # Default = BDB decides
|
||||
v = self.env.mutex_get_tas_spins()
|
||||
v2 = v*2+1
|
||||
|
||||
self.env.mutex_set_tas_spins(v2)
|
||||
self.assertEqual(v2, self.env.mutex_get_tas_spins())
|
||||
|
||||
self.env.mutex_set_tas_spins(v)
|
||||
self.assertEqual(v, self.env.mutex_get_tas_spins())
|
||||
|
||||
# In this case, you can change configuration
|
||||
# after opening the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE)
|
||||
self.env.mutex_set_tas_spins(v2)
|
||||
|
||||
def test_mutex_setget_align(self) :
|
||||
v = self.env.mutex_get_align()
|
||||
v2 = 64
|
||||
if v == 64 :
|
||||
v2 = 128
|
||||
|
||||
self.env.mutex_set_align(v2)
|
||||
self.assertEqual(v2, self.env.mutex_get_align())
|
||||
|
||||
# Requires a nonzero power of two
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.mutex_set_align, 0)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.mutex_set_align, 17)
|
||||
|
||||
self.env.mutex_set_align(2*v2)
|
||||
self.assertEqual(2*v2, self.env.mutex_get_align())
|
||||
|
||||
# You can not change configuration after opening
|
||||
# the environment.
|
||||
self.env.open(self.homeDir, db.DB_CREATE)
|
||||
self.assertRaises(db.DBInvalidArgError,
|
||||
self.env.mutex_set_align, v2)
|
||||
|
||||
|
||||
class DBEnv_log(DBEnv) :
|
||||
def setUp(self):
|
||||
DBEnv.setUp(self)
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG)
|
||||
|
||||
def test_log_file(self) :
|
||||
log_file = self.env.log_file((1, 1))
|
||||
self.assertEqual("log.0000000001", log_file[-14:])
|
||||
|
||||
if db.version() >= (4, 4) :
|
||||
# The version with transactions is checked in other test object
|
||||
def test_log_printf(self) :
|
||||
msg = "This is a test..."
|
||||
self.env.log_printf(msg)
|
||||
logc = self.env.log_cursor()
|
||||
self.assertIn(msg, logc.last()[1])
|
||||
|
||||
if db.version() >= (4, 7) :
|
||||
def test_log_config(self) :
|
||||
self.env.log_set_config(db.DB_LOG_DSYNC | db.DB_LOG_ZERO, 1)
|
||||
self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC))
|
||||
self.assertTrue(self.env.log_get_config(db.DB_LOG_ZERO))
|
||||
self.env.log_set_config(db.DB_LOG_ZERO, 0)
|
||||
self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC))
|
||||
self.assertFalse(self.env.log_get_config(db.DB_LOG_ZERO))
|
||||
|
||||
|
||||
class DBEnv_log_txn(DBEnv) :
|
||||
def setUp(self):
|
||||
DBEnv.setUp(self)
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOG | db.DB_INIT_TXN)
|
||||
|
||||
if (db.version() >= (4, 5)) and (db.version() < (5, 2)) :
|
||||
def test_tx_max(self) :
|
||||
txns=[]
|
||||
def tx() :
|
||||
for i in xrange(self.env.get_tx_max()) :
|
||||
txns.append(self.env.txn_begin())
|
||||
|
||||
tx()
|
||||
self.assertRaises(MemoryError, tx)
|
||||
|
||||
# Abort the transactions before garbage collection,
|
||||
# to avoid "warnings".
|
||||
for i in txns :
|
||||
i.abort()
|
||||
|
||||
if db.version() >= (4, 4) :
|
||||
# The version without transactions is checked in other test object
|
||||
def test_log_printf(self) :
|
||||
msg = "This is a test..."
|
||||
txn = self.env.txn_begin()
|
||||
self.env.log_printf(msg, txn=txn)
|
||||
txn.commit()
|
||||
logc = self.env.log_cursor()
|
||||
logc.last() # Skip the commit
|
||||
self.assertIn(msg, logc.prev()[1])
|
||||
|
||||
msg = "This is another test..."
|
||||
txn = self.env.txn_begin()
|
||||
self.env.log_printf(msg, txn=txn)
|
||||
txn.abort() # Do not store the new message
|
||||
logc.last() # Skip the abort
|
||||
self.assertNotIn(msg, logc.prev()[1])
|
||||
|
||||
msg = "This is a third test..."
|
||||
txn = self.env.txn_begin()
|
||||
self.env.log_printf(msg, txn=txn)
|
||||
txn.commit() # Do not store the new message
|
||||
logc.last() # Skip the commit
|
||||
self.assertIn(msg, logc.prev()[1])
|
||||
|
||||
|
||||
class DBEnv_memp(DBEnv):
|
||||
def setUp(self):
|
||||
DBEnv.setUp(self)
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG)
|
||||
self.db = db.DB(self.env)
|
||||
self.db.open("test", db.DB_HASH, db.DB_CREATE, 0660)
|
||||
|
||||
def tearDown(self):
|
||||
self.db.close()
|
||||
del self.db
|
||||
DBEnv.tearDown(self)
|
||||
|
||||
def test_memp_1_trickle(self) :
|
||||
self.db.put("hi", "bye")
|
||||
self.assertGreater(self.env.memp_trickle(100), 0)
|
||||
|
||||
# Preserve the order, do "memp_trickle" test first
|
||||
def test_memp_2_sync(self) :
|
||||
self.db.put("hi", "bye")
|
||||
self.env.memp_sync() # Full flush
|
||||
# Nothing to do...
|
||||
self.assertEqual(self.env.memp_trickle(100), 0)
|
||||
|
||||
self.db.put("hi", "bye2")
|
||||
self.env.memp_sync((1, 0)) # NOP, probably
|
||||
# Something to do... or not
|
||||
self.assertGreaterEqual(self.env.memp_trickle(100), 0)
|
||||
|
||||
self.db.put("hi", "bye3")
|
||||
self.env.memp_sync((123, 99)) # Full flush
|
||||
# Nothing to do...
|
||||
self.assertEqual(self.env.memp_trickle(100), 0)
|
||||
|
||||
def test_memp_stat_1(self) :
|
||||
stats = self.env.memp_stat() # No param
|
||||
self.assertEqual(len(stats), 2)
|
||||
self.assertIn("cache_miss", stats[0])
|
||||
stats = self.env.memp_stat(db.DB_STAT_CLEAR) # Positional param
|
||||
self.assertIn("cache_miss", stats[0])
|
||||
stats = self.env.memp_stat(flags=0) # Keyword param
|
||||
self.assertIn("cache_miss", stats[0])
|
||||
|
||||
def test_memp_stat_2(self) :
|
||||
stats=self.env.memp_stat()[1]
|
||||
self.assertEqual(len(stats), 1)
|
||||
self.assertIn("test", stats)
|
||||
self.assertIn("page_in", stats["test"])
|
||||
|
||||
class DBEnv_logcursor(DBEnv):
|
||||
def setUp(self):
|
||||
DBEnv.setUp(self)
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOG | db.DB_INIT_TXN)
|
||||
txn = self.env.txn_begin()
|
||||
self.db = db.DB(self.env)
|
||||
self.db.open("test", db.DB_HASH, db.DB_CREATE, 0660, txn=txn)
|
||||
txn.commit()
|
||||
for i in ["2", "8", "20"] :
|
||||
txn = self.env.txn_begin()
|
||||
self.db.put(key = i, data = i*int(i), txn=txn)
|
||||
txn.commit()
|
||||
|
||||
def tearDown(self):
|
||||
self.db.close()
|
||||
del self.db
|
||||
DBEnv.tearDown(self)
|
||||
|
||||
def _check_return(self, value) :
|
||||
self.assertIsInstance(value, tuple)
|
||||
self.assertEqual(len(value), 2)
|
||||
self.assertIsInstance(value[0], tuple)
|
||||
self.assertEqual(len(value[0]), 2)
|
||||
self.assertIsInstance(value[0][0], int)
|
||||
self.assertIsInstance(value[0][1], int)
|
||||
self.assertIsInstance(value[1], str)
|
||||
|
||||
# Preserve test order
|
||||
def test_1_first(self) :
|
||||
logc = self.env.log_cursor()
|
||||
v = logc.first()
|
||||
self._check_return(v)
|
||||
self.assertLess((1, 1), v[0])
|
||||
self.assertGreater(len(v[1]), 0)
|
||||
|
||||
def test_2_last(self) :
|
||||
logc = self.env.log_cursor()
|
||||
lsn_first = logc.first()[0]
|
||||
v = logc.last()
|
||||
self._check_return(v)
|
||||
self.assertLess(lsn_first, v[0])
|
||||
|
||||
def test_3_next(self) :
|
||||
logc = self.env.log_cursor()
|
||||
lsn_last = logc.last()[0]
|
||||
self.assertEqual(logc.next(), None)
|
||||
lsn_first = logc.first()[0]
|
||||
v = logc.next()
|
||||
self._check_return(v)
|
||||
self.assertLess(lsn_first, v[0])
|
||||
self.assertGreater(lsn_last, v[0])
|
||||
|
||||
v2 = logc.next()
|
||||
self.assertGreater(v2[0], v[0])
|
||||
self.assertGreater(lsn_last, v2[0])
|
||||
|
||||
v3 = logc.next()
|
||||
self.assertGreater(v3[0], v2[0])
|
||||
self.assertGreater(lsn_last, v3[0])
|
||||
|
||||
def test_4_prev(self) :
|
||||
logc = self.env.log_cursor()
|
||||
lsn_first = logc.first()[0]
|
||||
self.assertEqual(logc.prev(), None)
|
||||
lsn_last = logc.last()[0]
|
||||
v = logc.prev()
|
||||
self._check_return(v)
|
||||
self.assertLess(lsn_first, v[0])
|
||||
self.assertGreater(lsn_last, v[0])
|
||||
|
||||
v2 = logc.prev()
|
||||
self.assertLess(v2[0], v[0])
|
||||
self.assertLess(lsn_first, v2[0])
|
||||
|
||||
v3 = logc.prev()
|
||||
self.assertLess(v3[0], v2[0])
|
||||
self.assertLess(lsn_first, v3[0])
|
||||
|
||||
def test_5_current(self) :
|
||||
logc = self.env.log_cursor()
|
||||
logc.first()
|
||||
v = logc.next()
|
||||
self.assertEqual(v, logc.current())
|
||||
|
||||
def test_6_set(self) :
|
||||
logc = self.env.log_cursor()
|
||||
logc.first()
|
||||
v = logc.next()
|
||||
self.assertNotEqual(v, logc.next())
|
||||
self.assertNotEqual(v, logc.next())
|
||||
self.assertEqual(v, logc.set(v[0]))
|
||||
|
||||
def test_explicit_close(self) :
|
||||
logc = self.env.log_cursor()
|
||||
logc.close()
|
||||
self.assertRaises(db.DBCursorClosedError, logc.next)
|
||||
|
||||
def test_implicit_close(self) :
|
||||
logc = [self.env.log_cursor() for i in xrange(10)]
|
||||
self.env.close() # This close should close too all its tree
|
||||
for i in logc :
|
||||
self.assertRaises(db.DBCursorClosedError, i.next)
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(unittest.makeSuite(DBEnv_general))
|
||||
suite.addTest(unittest.makeSuite(DBEnv_memp))
|
||||
suite.addTest(unittest.makeSuite(DBEnv_logcursor))
|
||||
suite.addTest(unittest.makeSuite(DBEnv_log))
|
||||
suite.addTest(unittest.makeSuite(DBEnv_log_txn))
|
||||
|
||||
return suite
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
70
Lib/bsddb/test/test_dbobj.py
Normal file
70
Lib/bsddb/test/test_dbobj.py
Normal file
@@ -0,0 +1,70 @@
|
||||
|
||||
import os, string
|
||||
import unittest
|
||||
|
||||
from test_all import db, dbobj, test_support, get_new_environment_path, \
|
||||
get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class dbobjTestCase(unittest.TestCase):
|
||||
"""Verify that dbobj.DB and dbobj.DBEnv work properly"""
|
||||
db_name = 'test-dbobj.db'
|
||||
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
|
||||
def tearDown(self):
|
||||
if hasattr(self, 'db'):
|
||||
del self.db
|
||||
if hasattr(self, 'env'):
|
||||
del self.env
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test01_both(self):
|
||||
class TestDBEnv(dbobj.DBEnv): pass
|
||||
class TestDB(dbobj.DB):
|
||||
def put(self, key, *args, **kwargs):
|
||||
key = key.upper()
|
||||
# call our parent classes put method with an upper case key
|
||||
return dbobj.DB.put(self, key, *args, **kwargs)
|
||||
self.env = TestDBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
self.db = TestDB(self.env)
|
||||
self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE)
|
||||
self.db.put('spam', 'eggs')
|
||||
self.assertEqual(self.db.get('spam'), None,
|
||||
"overridden dbobj.DB.put() method failed [1]")
|
||||
self.assertEqual(self.db.get('SPAM'), 'eggs',
|
||||
"overridden dbobj.DB.put() method failed [2]")
|
||||
self.db.close()
|
||||
self.env.close()
|
||||
|
||||
def test02_dbobj_dict_interface(self):
|
||||
self.env = dbobj.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
self.db = dbobj.DB(self.env)
|
||||
self.db.open(self.db_name+'02', db.DB_HASH, db.DB_CREATE)
|
||||
# __setitem__
|
||||
self.db['spam'] = 'eggs'
|
||||
# __len__
|
||||
self.assertEqual(len(self.db), 1)
|
||||
# __getitem__
|
||||
self.assertEqual(self.db['spam'], 'eggs')
|
||||
# __del__
|
||||
del self.db['spam']
|
||||
self.assertEqual(self.db.get('spam'), None, "dbobj __del__ failed")
|
||||
self.db.close()
|
||||
self.env.close()
|
||||
|
||||
def test03_dbobj_type_before_open(self):
|
||||
# Ensure this doesn't cause a segfault.
|
||||
self.assertRaises(db.DBInvalidArgError, db.DB().type)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(dbobjTestCase)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
398
Lib/bsddb/test/test_dbshelve.py
Normal file
398
Lib/bsddb/test/test_dbshelve.py
Normal file
@@ -0,0 +1,398 @@
|
||||
"""
|
||||
TestCases for checking dbShelve objects.
|
||||
"""
|
||||
|
||||
import os, string, sys
|
||||
import random
|
||||
import unittest
|
||||
|
||||
|
||||
from test_all import db, dbshelve, test_support, verbose, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
# We want the objects to be comparable so we can test dbshelve.values
|
||||
# later on.
|
||||
class DataClass:
|
||||
def __init__(self):
|
||||
self.value = random.random()
|
||||
|
||||
def __repr__(self) : # For Python 3.0 comparison
|
||||
return "DataClass %f" %self.value
|
||||
|
||||
def __cmp__(self, other): # For Python 2.x comparison
|
||||
return cmp(self.value, other)
|
||||
|
||||
|
||||
class DBShelveTestCase(unittest.TestCase):
|
||||
if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
|
||||
(sys.version_info < (3, 2))) :
|
||||
def assertIn(self, a, b, msg=None) :
|
||||
return self.assertTrue(a in b, msg=msg)
|
||||
|
||||
|
||||
def setUp(self):
|
||||
if sys.version_info[0] >= 3 :
|
||||
from test_all import do_proxy_db_py3k
|
||||
self._flag_proxy_db_py3k = do_proxy_db_py3k(False)
|
||||
self.filename = get_new_database_path()
|
||||
self.do_open()
|
||||
|
||||
def tearDown(self):
|
||||
if sys.version_info[0] >= 3 :
|
||||
from test_all import do_proxy_db_py3k
|
||||
do_proxy_db_py3k(self._flag_proxy_db_py3k)
|
||||
self.do_close()
|
||||
test_support.unlink(self.filename)
|
||||
|
||||
def mk(self, key):
|
||||
"""Turn key into an appropriate key type for this db"""
|
||||
# override in child class for RECNO
|
||||
if sys.version_info[0] < 3 :
|
||||
return key
|
||||
else :
|
||||
return bytes(key, "iso8859-1") # 8 bits
|
||||
|
||||
def populateDB(self, d):
|
||||
for x in string.ascii_letters:
|
||||
d[self.mk('S' + x)] = 10 * x # add a string
|
||||
d[self.mk('I' + x)] = ord(x) # add an integer
|
||||
d[self.mk('L' + x)] = [x] * 10 # add a list
|
||||
|
||||
inst = DataClass() # add an instance
|
||||
inst.S = 10 * x
|
||||
inst.I = ord(x)
|
||||
inst.L = [x] * 10
|
||||
d[self.mk('O' + x)] = inst
|
||||
|
||||
|
||||
# overridable in derived classes to affect how the shelf is created/opened
|
||||
def do_open(self):
|
||||
self.d = dbshelve.open(self.filename)
|
||||
|
||||
# and closed...
|
||||
def do_close(self):
|
||||
self.d.close()
|
||||
|
||||
|
||||
|
||||
def test01_basics(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_basics..." % self.__class__.__name__
|
||||
|
||||
self.populateDB(self.d)
|
||||
self.d.sync()
|
||||
self.do_close()
|
||||
self.do_open()
|
||||
d = self.d
|
||||
|
||||
l = len(d)
|
||||
k = d.keys()
|
||||
s = d.stat()
|
||||
f = d.fd()
|
||||
|
||||
if verbose:
|
||||
print "length:", l
|
||||
print "keys:", k
|
||||
print "stats:", s
|
||||
|
||||
self.assertEqual(0, d.has_key(self.mk('bad key')))
|
||||
self.assertEqual(1, d.has_key(self.mk('IA')))
|
||||
self.assertEqual(1, d.has_key(self.mk('OA')))
|
||||
|
||||
d.delete(self.mk('IA'))
|
||||
del d[self.mk('OA')]
|
||||
self.assertEqual(0, d.has_key(self.mk('IA')))
|
||||
self.assertEqual(0, d.has_key(self.mk('OA')))
|
||||
self.assertEqual(len(d), l-2)
|
||||
|
||||
values = []
|
||||
for key in d.keys():
|
||||
value = d[key]
|
||||
values.append(value)
|
||||
if verbose:
|
||||
print "%s: %s" % (key, value)
|
||||
self.checkrec(key, value)
|
||||
|
||||
dbvalues = d.values()
|
||||
self.assertEqual(len(dbvalues), len(d.keys()))
|
||||
if sys.version_info < (2, 6) :
|
||||
values.sort()
|
||||
dbvalues.sort()
|
||||
self.assertEqual(values, dbvalues)
|
||||
else : # XXX: Convert all to strings. Please, improve
|
||||
values.sort(key=lambda x : str(x))
|
||||
dbvalues.sort(key=lambda x : str(x))
|
||||
self.assertEqual(repr(values), repr(dbvalues))
|
||||
|
||||
items = d.items()
|
||||
self.assertEqual(len(items), len(values))
|
||||
|
||||
for key, value in items:
|
||||
self.checkrec(key, value)
|
||||
|
||||
self.assertEqual(d.get(self.mk('bad key')), None)
|
||||
self.assertEqual(d.get(self.mk('bad key'), None), None)
|
||||
self.assertEqual(d.get(self.mk('bad key'), 'a string'), 'a string')
|
||||
self.assertEqual(d.get(self.mk('bad key'), [1, 2, 3]), [1, 2, 3])
|
||||
|
||||
d.set_get_returns_none(0)
|
||||
self.assertRaises(db.DBNotFoundError, d.get, self.mk('bad key'))
|
||||
d.set_get_returns_none(1)
|
||||
|
||||
d.put(self.mk('new key'), 'new data')
|
||||
self.assertEqual(d.get(self.mk('new key')), 'new data')
|
||||
self.assertEqual(d[self.mk('new key')], 'new data')
|
||||
|
||||
|
||||
|
||||
def test02_cursors(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test02_cursors..." % self.__class__.__name__
|
||||
|
||||
self.populateDB(self.d)
|
||||
d = self.d
|
||||
|
||||
count = 0
|
||||
c = d.cursor()
|
||||
rec = c.first()
|
||||
while rec is not None:
|
||||
count = count + 1
|
||||
if verbose:
|
||||
print rec
|
||||
key, value = rec
|
||||
self.checkrec(key, value)
|
||||
# Hack to avoid conversion by 2to3 tool
|
||||
rec = getattr(c, "next")()
|
||||
del c
|
||||
|
||||
self.assertEqual(count, len(d))
|
||||
|
||||
count = 0
|
||||
c = d.cursor()
|
||||
rec = c.last()
|
||||
while rec is not None:
|
||||
count = count + 1
|
||||
if verbose:
|
||||
print rec
|
||||
key, value = rec
|
||||
self.checkrec(key, value)
|
||||
rec = c.prev()
|
||||
|
||||
self.assertEqual(count, len(d))
|
||||
|
||||
c.set(self.mk('SS'))
|
||||
key, value = c.current()
|
||||
self.checkrec(key, value)
|
||||
del c
|
||||
|
||||
|
||||
def test03_append(self):
|
||||
# NOTE: this is overridden in RECNO subclass, don't change its name.
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test03_append..." % self.__class__.__name__
|
||||
|
||||
self.assertRaises(dbshelve.DBShelveError,
|
||||
self.d.append, 'unit test was here')
|
||||
|
||||
|
||||
def test04_iterable(self) :
|
||||
self.populateDB(self.d)
|
||||
d = self.d
|
||||
keys = d.keys()
|
||||
keyset = set(keys)
|
||||
self.assertEqual(len(keyset), len(keys))
|
||||
|
||||
for key in d :
|
||||
self.assertIn(key, keyset)
|
||||
keyset.remove(key)
|
||||
self.assertEqual(len(keyset), 0)
|
||||
|
||||
def checkrec(self, key, value):
|
||||
# override this in a subclass if the key type is different
|
||||
|
||||
if sys.version_info[0] >= 3 :
|
||||
if isinstance(key, bytes) :
|
||||
key = key.decode("iso8859-1") # 8 bits
|
||||
|
||||
x = key[1]
|
||||
if key[0] == 'S':
|
||||
self.assertEqual(type(value), str)
|
||||
self.assertEqual(value, 10 * x)
|
||||
|
||||
elif key[0] == 'I':
|
||||
self.assertEqual(type(value), int)
|
||||
self.assertEqual(value, ord(x))
|
||||
|
||||
elif key[0] == 'L':
|
||||
self.assertEqual(type(value), list)
|
||||
self.assertEqual(value, [x] * 10)
|
||||
|
||||
elif key[0] == 'O':
|
||||
if sys.version_info[0] < 3 :
|
||||
from types import InstanceType
|
||||
self.assertEqual(type(value), InstanceType)
|
||||
else :
|
||||
self.assertEqual(type(value), DataClass)
|
||||
|
||||
self.assertEqual(value.S, 10 * x)
|
||||
self.assertEqual(value.I, ord(x))
|
||||
self.assertEqual(value.L, [x] * 10)
|
||||
|
||||
else:
|
||||
self.fail('Unknown key type, fix the test')
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class BasicShelveTestCase(DBShelveTestCase):
|
||||
def do_open(self):
|
||||
self.d = dbshelve.DBShelf()
|
||||
self.d.open(self.filename, self.dbtype, self.dbflags)
|
||||
|
||||
def do_close(self):
|
||||
self.d.close()
|
||||
|
||||
|
||||
class BTreeShelveTestCase(BasicShelveTestCase):
|
||||
dbtype = db.DB_BTREE
|
||||
dbflags = db.DB_CREATE
|
||||
|
||||
|
||||
class HashShelveTestCase(BasicShelveTestCase):
|
||||
dbtype = db.DB_HASH
|
||||
dbflags = db.DB_CREATE
|
||||
|
||||
|
||||
class ThreadBTreeShelveTestCase(BasicShelveTestCase):
|
||||
dbtype = db.DB_BTREE
|
||||
dbflags = db.DB_CREATE | db.DB_THREAD
|
||||
|
||||
|
||||
class ThreadHashShelveTestCase(BasicShelveTestCase):
|
||||
dbtype = db.DB_HASH
|
||||
dbflags = db.DB_CREATE | db.DB_THREAD
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class BasicEnvShelveTestCase(DBShelveTestCase):
|
||||
def do_open(self):
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir,
|
||||
self.envflags | db.DB_INIT_MPOOL | db.DB_CREATE)
|
||||
|
||||
self.filename = os.path.split(self.filename)[1]
|
||||
self.d = dbshelve.DBShelf(self.env)
|
||||
self.d.open(self.filename, self.dbtype, self.dbflags)
|
||||
|
||||
|
||||
def do_close(self):
|
||||
self.d.close()
|
||||
self.env.close()
|
||||
|
||||
|
||||
def setUp(self) :
|
||||
self.homeDir = get_new_environment_path()
|
||||
DBShelveTestCase.setUp(self)
|
||||
|
||||
def tearDown(self):
|
||||
if sys.version_info[0] >= 3 :
|
||||
from test_all import do_proxy_db_py3k
|
||||
do_proxy_db_py3k(self._flag_proxy_db_py3k)
|
||||
self.do_close()
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
|
||||
class EnvBTreeShelveTestCase(BasicEnvShelveTestCase):
|
||||
envflags = 0
|
||||
dbtype = db.DB_BTREE
|
||||
dbflags = db.DB_CREATE
|
||||
|
||||
|
||||
class EnvHashShelveTestCase(BasicEnvShelveTestCase):
|
||||
envflags = 0
|
||||
dbtype = db.DB_HASH
|
||||
dbflags = db.DB_CREATE
|
||||
|
||||
|
||||
class EnvThreadBTreeShelveTestCase(BasicEnvShelveTestCase):
|
||||
envflags = db.DB_THREAD
|
||||
dbtype = db.DB_BTREE
|
||||
dbflags = db.DB_CREATE | db.DB_THREAD
|
||||
|
||||
|
||||
class EnvThreadHashShelveTestCase(BasicEnvShelveTestCase):
|
||||
envflags = db.DB_THREAD
|
||||
dbtype = db.DB_HASH
|
||||
dbflags = db.DB_CREATE | db.DB_THREAD
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# test cases for a DBShelf in a RECNO DB.
|
||||
|
||||
class RecNoShelveTestCase(BasicShelveTestCase):
|
||||
dbtype = db.DB_RECNO
|
||||
dbflags = db.DB_CREATE
|
||||
|
||||
def setUp(self):
|
||||
BasicShelveTestCase.setUp(self)
|
||||
|
||||
# pool to assign integer key values out of
|
||||
self.key_pool = list(range(1, 5000))
|
||||
self.key_map = {} # map string keys to the number we gave them
|
||||
self.intkey_map = {} # reverse map of above
|
||||
|
||||
def mk(self, key):
|
||||
if key not in self.key_map:
|
||||
self.key_map[key] = self.key_pool.pop(0)
|
||||
self.intkey_map[self.key_map[key]] = key
|
||||
return self.key_map[key]
|
||||
|
||||
def checkrec(self, intkey, value):
|
||||
key = self.intkey_map[intkey]
|
||||
BasicShelveTestCase.checkrec(self, key, value)
|
||||
|
||||
def test03_append(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test03_append..." % self.__class__.__name__
|
||||
|
||||
self.d[1] = 'spam'
|
||||
self.d[5] = 'eggs'
|
||||
self.assertEqual(6, self.d.append('spam'))
|
||||
self.assertEqual(7, self.d.append('baked beans'))
|
||||
self.assertEqual('spam', self.d.get(6))
|
||||
self.assertEqual('spam', self.d.get(1))
|
||||
self.assertEqual('baked beans', self.d.get(7))
|
||||
self.assertEqual('eggs', self.d.get(5))
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(unittest.makeSuite(DBShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(BTreeShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(HashShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(ThreadBTreeShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(ThreadHashShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(EnvBTreeShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(EnvHashShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(EnvThreadBTreeShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(EnvThreadHashShelveTestCase))
|
||||
suite.addTest(unittest.makeSuite(RecNoShelveTestCase))
|
||||
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
407
Lib/bsddb/test/test_dbtables.py
Normal file
407
Lib/bsddb/test/test_dbtables.py
Normal file
@@ -0,0 +1,407 @@
|
||||
#-----------------------------------------------------------------------
|
||||
# A test suite for the table interface built on bsddb.db
|
||||
#-----------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (C) 2000, 2001 by Autonomous Zone Industries
|
||||
# Copyright (C) 2002 Gregory P. Smith
|
||||
#
|
||||
# March 20, 2000
|
||||
#
|
||||
# License: This is free software. You may use this software for any
|
||||
# purpose including modification/redistribution, so long as
|
||||
# this header remains intact and that you do not claim any
|
||||
# rights of ownership or authorship of this software. This
|
||||
# software has been tested, but no warranty is expressed or
|
||||
# implied.
|
||||
#
|
||||
# -- Gregory P. Smith <greg@krypto.org>
|
||||
#
|
||||
# $Id$
|
||||
|
||||
import os, re, sys
|
||||
|
||||
if sys.version_info[0] < 3 :
|
||||
try:
|
||||
import cPickle
|
||||
pickle = cPickle
|
||||
except ImportError:
|
||||
import pickle
|
||||
else :
|
||||
import pickle
|
||||
|
||||
import unittest
|
||||
from test_all import db, dbtables, test_support, verbose, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class TableDBTestCase(unittest.TestCase):
|
||||
db_name = 'test-table.db'
|
||||
|
||||
def setUp(self):
|
||||
import sys
|
||||
if sys.version_info[0] >= 3 :
|
||||
from test_all import do_proxy_db_py3k
|
||||
self._flag_proxy_db_py3k = do_proxy_db_py3k(False)
|
||||
|
||||
self.testHomeDir = get_new_environment_path()
|
||||
self.tdb = dbtables.bsdTableDB(
|
||||
filename='tabletest.db', dbhome=self.testHomeDir, create=1)
|
||||
|
||||
def tearDown(self):
|
||||
self.tdb.close()
|
||||
import sys
|
||||
if sys.version_info[0] >= 3 :
|
||||
from test_all import do_proxy_db_py3k
|
||||
do_proxy_db_py3k(self._flag_proxy_db_py3k)
|
||||
test_support.rmtree(self.testHomeDir)
|
||||
|
||||
def test01(self):
|
||||
tabname = "test01"
|
||||
colname = 'cool numbers'
|
||||
try:
|
||||
self.tdb.Drop(tabname)
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
self.tdb.CreateTable(tabname, [colname])
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159, 1)})
|
||||
else :
|
||||
self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159,
|
||||
1).decode("iso8859-1")}) # 8 bits
|
||||
|
||||
if verbose:
|
||||
self.tdb._db_print()
|
||||
|
||||
values = self.tdb.Select(
|
||||
tabname, [colname], conditions={colname: None})
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
colval = pickle.loads(values[0][colname])
|
||||
else :
|
||||
colval = pickle.loads(bytes(values[0][colname], "iso8859-1"))
|
||||
self.assertGreater(colval, 3.141)
|
||||
self.assertLess(colval, 3.142)
|
||||
|
||||
|
||||
def test02(self):
|
||||
tabname = "test02"
|
||||
col0 = 'coolness factor'
|
||||
col1 = 'but can it fly?'
|
||||
col2 = 'Species'
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
testinfo = [
|
||||
{col0: pickle.dumps(8, 1), col1: 'no', col2: 'Penguin'},
|
||||
{col0: pickle.dumps(-1, 1), col1: 'no', col2: 'Turkey'},
|
||||
{col0: pickle.dumps(9, 1), col1: 'yes', col2: 'SR-71A Blackbird'}
|
||||
]
|
||||
else :
|
||||
testinfo = [
|
||||
{col0: pickle.dumps(8, 1).decode("iso8859-1"),
|
||||
col1: 'no', col2: 'Penguin'},
|
||||
{col0: pickle.dumps(-1, 1).decode("iso8859-1"),
|
||||
col1: 'no', col2: 'Turkey'},
|
||||
{col0: pickle.dumps(9, 1).decode("iso8859-1"),
|
||||
col1: 'yes', col2: 'SR-71A Blackbird'}
|
||||
]
|
||||
|
||||
try:
|
||||
self.tdb.Drop(tabname)
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
self.tdb.CreateTable(tabname, [col0, col1, col2])
|
||||
for row in testinfo :
|
||||
self.tdb.Insert(tabname, row)
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
values = self.tdb.Select(tabname, [col2],
|
||||
conditions={col0: lambda x: pickle.loads(x) >= 8})
|
||||
else :
|
||||
values = self.tdb.Select(tabname, [col2],
|
||||
conditions={col0: lambda x:
|
||||
pickle.loads(bytes(x, "iso8859-1")) >= 8})
|
||||
|
||||
self.assertEqual(len(values), 2)
|
||||
if values[0]['Species'] == 'Penguin' :
|
||||
self.assertEqual(values[1]['Species'], 'SR-71A Blackbird')
|
||||
elif values[0]['Species'] == 'SR-71A Blackbird' :
|
||||
self.assertEqual(values[1]['Species'], 'Penguin')
|
||||
else :
|
||||
if verbose:
|
||||
print "values= %r" % (values,)
|
||||
raise RuntimeError("Wrong values returned!")
|
||||
|
||||
def test03(self):
|
||||
tabname = "test03"
|
||||
try:
|
||||
self.tdb.Drop(tabname)
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
if verbose:
|
||||
print '...before CreateTable...'
|
||||
self.tdb._db_print()
|
||||
self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e'])
|
||||
if verbose:
|
||||
print '...after CreateTable...'
|
||||
self.tdb._db_print()
|
||||
self.tdb.Drop(tabname)
|
||||
if verbose:
|
||||
print '...after Drop...'
|
||||
self.tdb._db_print()
|
||||
self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e'])
|
||||
|
||||
try:
|
||||
self.tdb.Insert(tabname,
|
||||
{'a': "",
|
||||
'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1),
|
||||
'f': "Zero"})
|
||||
self.fail('Expected an exception')
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
|
||||
try:
|
||||
self.tdb.Select(tabname, [], conditions={'foo': '123'})
|
||||
self.fail('Expected an exception')
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
|
||||
self.tdb.Insert(tabname,
|
||||
{'a': '42',
|
||||
'b': "bad",
|
||||
'c': "meep",
|
||||
'e': 'Fuzzy wuzzy was a bear'})
|
||||
self.tdb.Insert(tabname,
|
||||
{'a': '581750',
|
||||
'b': "good",
|
||||
'd': "bla",
|
||||
'c': "black",
|
||||
'e': 'fuzzy was here'})
|
||||
self.tdb.Insert(tabname,
|
||||
{'a': '800000',
|
||||
'b': "good",
|
||||
'd': "bla",
|
||||
'c': "black",
|
||||
'e': 'Fuzzy wuzzy is a bear'})
|
||||
|
||||
if verbose:
|
||||
self.tdb._db_print()
|
||||
|
||||
# this should return two rows
|
||||
values = self.tdb.Select(tabname, ['b', 'a', 'd'],
|
||||
conditions={'e': re.compile('wuzzy').search,
|
||||
'a': re.compile('^[0-9]+$').match})
|
||||
self.assertEqual(len(values), 2)
|
||||
|
||||
# now lets delete one of them and try again
|
||||
self.tdb.Delete(tabname, conditions={'b': dbtables.ExactCond('good')})
|
||||
values = self.tdb.Select(
|
||||
tabname, ['a', 'd', 'b'],
|
||||
conditions={'e': dbtables.PrefixCond('Fuzzy')})
|
||||
self.assertEqual(len(values), 1)
|
||||
self.assertEqual(values[0]['d'], None)
|
||||
|
||||
values = self.tdb.Select(tabname, ['b'],
|
||||
conditions={'c': lambda c: c == 'meep'})
|
||||
self.assertEqual(len(values), 1)
|
||||
self.assertEqual(values[0]['b'], "bad")
|
||||
|
||||
|
||||
def test04_MultiCondSelect(self):
|
||||
tabname = "test04_MultiCondSelect"
|
||||
try:
|
||||
self.tdb.Drop(tabname)
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e'])
|
||||
|
||||
try:
|
||||
self.tdb.Insert(tabname,
|
||||
{'a': "",
|
||||
'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1),
|
||||
'f': "Zero"})
|
||||
self.fail('Expected an exception')
|
||||
except dbtables.TableDBError:
|
||||
pass
|
||||
|
||||
self.tdb.Insert(tabname, {'a': "A", 'b': "B", 'c': "C", 'd': "D",
|
||||
'e': "E"})
|
||||
self.tdb.Insert(tabname, {'a': "-A", 'b': "-B", 'c': "-C", 'd': "-D",
|
||||
'e': "-E"})
|
||||
self.tdb.Insert(tabname, {'a': "A-", 'b': "B-", 'c': "C-", 'd': "D-",
|
||||
'e': "E-"})
|
||||
|
||||
if verbose:
|
||||
self.tdb._db_print()
|
||||
|
||||
# This select should return 0 rows. it is designed to test
|
||||
# the bug identified and fixed in sourceforge bug # 590449
|
||||
# (Big Thanks to "Rob Tillotson (n9mtb)" for tracking this down
|
||||
# and supplying a fix!! This one caused many headaches to say
|
||||
# the least...)
|
||||
values = self.tdb.Select(tabname, ['b', 'a', 'd'],
|
||||
conditions={'e': dbtables.ExactCond('E'),
|
||||
'a': dbtables.ExactCond('A'),
|
||||
'd': dbtables.PrefixCond('-')
|
||||
} )
|
||||
self.assertEqual(len(values), 0, values)
|
||||
|
||||
|
||||
def test_CreateOrExtend(self):
|
||||
tabname = "test_CreateOrExtend"
|
||||
|
||||
self.tdb.CreateOrExtendTable(
|
||||
tabname, ['name', 'taste', 'filling', 'alcohol content', 'price'])
|
||||
try:
|
||||
self.tdb.Insert(tabname,
|
||||
{'taste': 'crap',
|
||||
'filling': 'no',
|
||||
'is it Guinness?': 'no'})
|
||||
self.fail("Insert should've failed due to bad column name")
|
||||
except:
|
||||
pass
|
||||
self.tdb.CreateOrExtendTable(tabname,
|
||||
['name', 'taste', 'is it Guinness?'])
|
||||
|
||||
# these should both succeed as the table should contain the union of both sets of columns.
|
||||
self.tdb.Insert(tabname, {'taste': 'crap', 'filling': 'no',
|
||||
'is it Guinness?': 'no'})
|
||||
self.tdb.Insert(tabname, {'taste': 'great', 'filling': 'yes',
|
||||
'is it Guinness?': 'yes',
|
||||
'name': 'Guinness'})
|
||||
|
||||
|
||||
def test_CondObjs(self):
|
||||
tabname = "test_CondObjs"
|
||||
|
||||
self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e', 'p'])
|
||||
|
||||
self.tdb.Insert(tabname, {'a': "the letter A",
|
||||
'b': "the letter B",
|
||||
'c': "is for cookie"})
|
||||
self.tdb.Insert(tabname, {'a': "is for aardvark",
|
||||
'e': "the letter E",
|
||||
'c': "is for cookie",
|
||||
'd': "is for dog"})
|
||||
self.tdb.Insert(tabname, {'a': "the letter A",
|
||||
'e': "the letter E",
|
||||
'c': "is for cookie",
|
||||
'p': "is for Python"})
|
||||
|
||||
values = self.tdb.Select(
|
||||
tabname, ['p', 'e'],
|
||||
conditions={'e': dbtables.PrefixCond('the l')})
|
||||
self.assertEqual(len(values), 2, values)
|
||||
self.assertEqual(values[0]['e'], values[1]['e'], values)
|
||||
self.assertNotEqual(values[0]['p'], values[1]['p'], values)
|
||||
|
||||
values = self.tdb.Select(
|
||||
tabname, ['d', 'a'],
|
||||
conditions={'a': dbtables.LikeCond('%aardvark%')})
|
||||
self.assertEqual(len(values), 1, values)
|
||||
self.assertEqual(values[0]['d'], "is for dog", values)
|
||||
self.assertEqual(values[0]['a'], "is for aardvark", values)
|
||||
|
||||
values = self.tdb.Select(tabname, None,
|
||||
{'b': dbtables.Cond(),
|
||||
'e':dbtables.LikeCond('%letter%'),
|
||||
'a':dbtables.PrefixCond('is'),
|
||||
'd':dbtables.ExactCond('is for dog'),
|
||||
'c':dbtables.PrefixCond('is for'),
|
||||
'p':lambda s: not s})
|
||||
self.assertEqual(len(values), 1, values)
|
||||
self.assertEqual(values[0]['d'], "is for dog", values)
|
||||
self.assertEqual(values[0]['a'], "is for aardvark", values)
|
||||
|
||||
def test_Delete(self):
|
||||
tabname = "test_Delete"
|
||||
self.tdb.CreateTable(tabname, ['x', 'y', 'z'])
|
||||
|
||||
# prior to 2001-05-09 there was a bug where Delete() would
|
||||
# fail if it encountered any rows that did not have values in
|
||||
# every column.
|
||||
# Hunted and Squashed by <Donwulff> (Jukka Santala - donwulff@nic.fi)
|
||||
self.tdb.Insert(tabname, {'x': 'X1', 'y':'Y1'})
|
||||
self.tdb.Insert(tabname, {'x': 'X2', 'y':'Y2', 'z': 'Z2'})
|
||||
|
||||
self.tdb.Delete(tabname, conditions={'x': dbtables.PrefixCond('X')})
|
||||
values = self.tdb.Select(tabname, ['y'],
|
||||
conditions={'x': dbtables.PrefixCond('X')})
|
||||
self.assertEqual(len(values), 0)
|
||||
|
||||
def test_Modify(self):
|
||||
tabname = "test_Modify"
|
||||
self.tdb.CreateTable(tabname, ['Name', 'Type', 'Access'])
|
||||
|
||||
self.tdb.Insert(tabname, {'Name': 'Index to MP3 files.doc',
|
||||
'Type': 'Word', 'Access': '8'})
|
||||
self.tdb.Insert(tabname, {'Name': 'Nifty.MP3', 'Access': '1'})
|
||||
self.tdb.Insert(tabname, {'Type': 'Unknown', 'Access': '0'})
|
||||
|
||||
def set_type(type):
|
||||
if type is None:
|
||||
return 'MP3'
|
||||
return type
|
||||
|
||||
def increment_access(count):
|
||||
return str(int(count)+1)
|
||||
|
||||
def remove_value(value):
|
||||
return None
|
||||
|
||||
self.tdb.Modify(tabname,
|
||||
conditions={'Access': dbtables.ExactCond('0')},
|
||||
mappings={'Access': remove_value})
|
||||
self.tdb.Modify(tabname,
|
||||
conditions={'Name': dbtables.LikeCond('%MP3%')},
|
||||
mappings={'Type': set_type})
|
||||
self.tdb.Modify(tabname,
|
||||
conditions={'Name': dbtables.LikeCond('%')},
|
||||
mappings={'Access': increment_access})
|
||||
|
||||
try:
|
||||
self.tdb.Modify(tabname,
|
||||
conditions={'Name': dbtables.LikeCond('%')},
|
||||
mappings={'Access': 'What is your quest?'})
|
||||
except TypeError:
|
||||
# success, the string value in mappings isn't callable
|
||||
pass
|
||||
else:
|
||||
raise RuntimeError, "why was TypeError not raised for bad callable?"
|
||||
|
||||
# Delete key in select conditions
|
||||
values = self.tdb.Select(
|
||||
tabname, None,
|
||||
conditions={'Type': dbtables.ExactCond('Unknown')})
|
||||
self.assertEqual(len(values), 1, values)
|
||||
self.assertEqual(values[0]['Name'], None, values)
|
||||
self.assertEqual(values[0]['Access'], None, values)
|
||||
|
||||
# Modify value by select conditions
|
||||
values = self.tdb.Select(
|
||||
tabname, None,
|
||||
conditions={'Name': dbtables.ExactCond('Nifty.MP3')})
|
||||
self.assertEqual(len(values), 1, values)
|
||||
self.assertEqual(values[0]['Type'], "MP3", values)
|
||||
self.assertEqual(values[0]['Access'], "2", values)
|
||||
|
||||
# Make sure change applied only to select conditions
|
||||
values = self.tdb.Select(
|
||||
tabname, None, conditions={'Name': dbtables.LikeCond('%doc%')})
|
||||
self.assertEqual(len(values), 1, values)
|
||||
self.assertEqual(values[0]['Type'], "Word", values)
|
||||
self.assertEqual(values[0]['Access'], "9", values)
|
||||
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(unittest.makeSuite(TableDBTestCase))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
152
Lib/bsddb/test/test_distributed_transactions.py
Normal file
152
Lib/bsddb/test/test_distributed_transactions.py
Normal file
@@ -0,0 +1,152 @@
|
||||
"""TestCases for distributed transactions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, \
|
||||
get_new_database_path
|
||||
|
||||
from test_all import verbose
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DBTxn_distributed(unittest.TestCase):
|
||||
num_txns=1234
|
||||
nosync=True
|
||||
must_open_db=False
|
||||
def _create_env(self, must_open_db) :
|
||||
self.dbenv = db.DBEnv()
|
||||
self.dbenv.set_tx_max(self.num_txns)
|
||||
self.dbenv.set_lk_max_lockers(self.num_txns*2)
|
||||
self.dbenv.set_lk_max_locks(self.num_txns*2)
|
||||
self.dbenv.set_lk_max_objects(self.num_txns*2)
|
||||
if self.nosync :
|
||||
self.dbenv.set_flags(db.DB_TXN_NOSYNC,True)
|
||||
self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_THREAD |
|
||||
db.DB_RECOVER |
|
||||
db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOCK, 0666)
|
||||
self.db = db.DB(self.dbenv)
|
||||
self.db.set_re_len(db.DB_GID_SIZE)
|
||||
if must_open_db :
|
||||
txn=self.dbenv.txn_begin()
|
||||
self.db.open(self.filename,
|
||||
db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0666,
|
||||
txn=txn)
|
||||
txn.commit()
|
||||
|
||||
def setUp(self) :
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.filename = "test"
|
||||
return self._create_env(must_open_db=True)
|
||||
|
||||
def _destroy_env(self):
|
||||
if self.nosync or (db.version()[:2] == (4,6)): # Known bug
|
||||
self.dbenv.log_flush()
|
||||
self.db.close()
|
||||
self.dbenv.close()
|
||||
|
||||
def tearDown(self):
|
||||
self._destroy_env()
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def _recreate_env(self,must_open_db) :
|
||||
self._destroy_env()
|
||||
self._create_env(must_open_db)
|
||||
|
||||
def test01_distributed_transactions(self) :
|
||||
txns=set()
|
||||
adapt = lambda x : x
|
||||
import sys
|
||||
if sys.version_info[0] >= 3 :
|
||||
adapt = lambda x : bytes(x, "ascii")
|
||||
# Create transactions, "prepare" them, and
|
||||
# let them be garbage collected.
|
||||
for i in xrange(self.num_txns) :
|
||||
txn = self.dbenv.txn_begin()
|
||||
gid = "%%%dd" %db.DB_GID_SIZE
|
||||
gid = adapt(gid %i)
|
||||
self.db.put(i, gid, txn=txn, flags=db.DB_APPEND)
|
||||
txns.add(gid)
|
||||
txn.prepare(gid)
|
||||
del txn
|
||||
|
||||
self._recreate_env(self.must_open_db)
|
||||
|
||||
# Get "to be recovered" transactions but
|
||||
# let them be garbage collected.
|
||||
recovered_txns=self.dbenv.txn_recover()
|
||||
self.assertEqual(self.num_txns,len(recovered_txns))
|
||||
for gid,txn in recovered_txns :
|
||||
self.assertIn(gid, txns)
|
||||
del txn
|
||||
del recovered_txns
|
||||
|
||||
self._recreate_env(self.must_open_db)
|
||||
|
||||
# Get "to be recovered" transactions. Commit, abort and
|
||||
# discard them.
|
||||
recovered_txns=self.dbenv.txn_recover()
|
||||
self.assertEqual(self.num_txns,len(recovered_txns))
|
||||
discard_txns=set()
|
||||
committed_txns=set()
|
||||
state=0
|
||||
for gid,txn in recovered_txns :
|
||||
if state==0 or state==1:
|
||||
committed_txns.add(gid)
|
||||
txn.commit()
|
||||
elif state==2 :
|
||||
txn.abort()
|
||||
elif state==3 :
|
||||
txn.discard()
|
||||
discard_txns.add(gid)
|
||||
state=-1
|
||||
state+=1
|
||||
del txn
|
||||
del recovered_txns
|
||||
|
||||
self._recreate_env(self.must_open_db)
|
||||
|
||||
# Verify the discarded transactions are still
|
||||
# around, and dispose them.
|
||||
recovered_txns=self.dbenv.txn_recover()
|
||||
self.assertEqual(len(discard_txns),len(recovered_txns))
|
||||
for gid,txn in recovered_txns :
|
||||
txn.abort()
|
||||
del txn
|
||||
del recovered_txns
|
||||
|
||||
self._recreate_env(must_open_db=True)
|
||||
|
||||
# Be sure there are not pending transactions.
|
||||
# Check also database size.
|
||||
recovered_txns=self.dbenv.txn_recover()
|
||||
self.assertEqual(len(recovered_txns), 0)
|
||||
self.assertEqual(len(committed_txns),self.db.stat()["nkeys"])
|
||||
|
||||
class DBTxn_distributedSYNC(DBTxn_distributed):
|
||||
nosync=False
|
||||
|
||||
class DBTxn_distributed_must_open_db(DBTxn_distributed):
|
||||
must_open_db=True
|
||||
|
||||
class DBTxn_distributedSYNC_must_open_db(DBTxn_distributed):
|
||||
nosync=False
|
||||
must_open_db=True
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
if db.version() >= (4,5) :
|
||||
suite.addTest(unittest.makeSuite(DBTxn_distributed))
|
||||
suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC))
|
||||
if db.version() >= (4,6) :
|
||||
suite.addTest(unittest.makeSuite(DBTxn_distributed_must_open_db))
|
||||
suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC_must_open_db))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
215
Lib/bsddb/test/test_early_close.py
Normal file
215
Lib/bsddb/test/test_early_close.py
Normal file
@@ -0,0 +1,215 @@
|
||||
"""TestCases for checking that it does not segfault when a DBEnv object
|
||||
is closed before its DB objects.
|
||||
"""
|
||||
|
||||
import os, sys
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path
|
||||
|
||||
# We're going to get warnings in this module about trying to close the db when
|
||||
# its env is already closed. Let's just ignore those.
|
||||
try:
|
||||
import warnings
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
warnings.filterwarnings('ignore',
|
||||
message='DB could not be closed in',
|
||||
category=RuntimeWarning)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DBEnvClosedEarlyCrash(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.filename = "test"
|
||||
|
||||
def tearDown(self):
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test01_close_dbenv_before_db(self):
|
||||
dbenv = db.DBEnv()
|
||||
dbenv.open(self.homeDir,
|
||||
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
|
||||
0666)
|
||||
|
||||
d = db.DB(dbenv)
|
||||
d2 = db.DB(dbenv)
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
|
||||
self.assertRaises(db.DBNoSuchFileError, d2.open,
|
||||
self.filename+"2", db.DB_BTREE, db.DB_THREAD, 0666)
|
||||
|
||||
d.put("test","this is a test")
|
||||
self.assertEqual(d.get("test"), "this is a test", "put!=get")
|
||||
dbenv.close() # This "close" should close the child db handle also
|
||||
self.assertRaises(db.DBError, d.get, "test")
|
||||
|
||||
def test02_close_dbenv_before_dbcursor(self):
|
||||
dbenv = db.DBEnv()
|
||||
dbenv.open(self.homeDir,
|
||||
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
|
||||
0666)
|
||||
|
||||
d = db.DB(dbenv)
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
|
||||
d.put("test","this is a test")
|
||||
d.put("test2","another test")
|
||||
d.put("test3","another one")
|
||||
self.assertEqual(d.get("test"), "this is a test", "put!=get")
|
||||
c=d.cursor()
|
||||
c.first()
|
||||
c.next()
|
||||
d.close() # This "close" should close the child db handle also
|
||||
# db.close should close the child cursor
|
||||
self.assertRaises(db.DBError,c.next)
|
||||
|
||||
d = db.DB(dbenv)
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
c=d.cursor()
|
||||
c.first()
|
||||
c.next()
|
||||
dbenv.close()
|
||||
# The "close" should close the child db handle also, with cursors
|
||||
self.assertRaises(db.DBError, c.next)
|
||||
|
||||
def test03_close_db_before_dbcursor_without_env(self):
|
||||
import os.path
|
||||
path=os.path.join(self.homeDir,self.filename)
|
||||
d = db.DB()
|
||||
d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
|
||||
d.put("test","this is a test")
|
||||
d.put("test2","another test")
|
||||
d.put("test3","another one")
|
||||
self.assertEqual(d.get("test"), "this is a test", "put!=get")
|
||||
c=d.cursor()
|
||||
c.first()
|
||||
c.next()
|
||||
d.close()
|
||||
# The "close" should close the child db handle also
|
||||
self.assertRaises(db.DBError, c.next)
|
||||
|
||||
def test04_close_massive(self):
|
||||
dbenv = db.DBEnv()
|
||||
dbenv.open(self.homeDir,
|
||||
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
|
||||
0666)
|
||||
|
||||
dbs=[db.DB(dbenv) for i in xrange(16)]
|
||||
cursors=[]
|
||||
for i in dbs :
|
||||
i.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
|
||||
dbs[10].put("test","this is a test")
|
||||
dbs[10].put("test2","another test")
|
||||
dbs[10].put("test3","another one")
|
||||
self.assertEqual(dbs[4].get("test"), "this is a test", "put!=get")
|
||||
|
||||
for i in dbs :
|
||||
cursors.extend([i.cursor() for j in xrange(32)])
|
||||
|
||||
for i in dbs[::3] :
|
||||
i.close()
|
||||
for i in cursors[::3] :
|
||||
i.close()
|
||||
|
||||
# Check for missing exception in DB! (after DB close)
|
||||
self.assertRaises(db.DBError, dbs[9].get, "test")
|
||||
|
||||
# Check for missing exception in DBCursor! (after DB close)
|
||||
self.assertRaises(db.DBError, cursors[101].first)
|
||||
|
||||
cursors[80].first()
|
||||
cursors[80].next()
|
||||
dbenv.close() # This "close" should close the child db handle also
|
||||
# Check for missing exception! (after DBEnv close)
|
||||
self.assertRaises(db.DBError, cursors[80].next)
|
||||
|
||||
def test05_close_dbenv_delete_db_success(self):
|
||||
dbenv = db.DBEnv()
|
||||
dbenv.open(self.homeDir,
|
||||
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
|
||||
0666)
|
||||
|
||||
d = db.DB(dbenv)
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
|
||||
dbenv.close() # This "close" should close the child db handle also
|
||||
|
||||
del d
|
||||
try:
|
||||
import gc
|
||||
except ImportError:
|
||||
gc = None
|
||||
if gc:
|
||||
# force d.__del__ [DB_dealloc] to be called
|
||||
gc.collect()
|
||||
|
||||
def test06_close_txn_before_dup_cursor(self) :
|
||||
dbenv = db.DBEnv()
|
||||
dbenv.open(self.homeDir,db.DB_INIT_TXN | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOG | db.DB_CREATE)
|
||||
d = db.DB(dbenv)
|
||||
txn = dbenv.txn_begin()
|
||||
d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE,
|
||||
txn=txn)
|
||||
d.put("XXX", "yyy", txn=txn)
|
||||
txn.commit()
|
||||
txn = dbenv.txn_begin()
|
||||
c1 = d.cursor(txn)
|
||||
c2 = c1.dup()
|
||||
self.assertEqual(("XXX", "yyy"), c1.first())
|
||||
|
||||
# Not interested in warnings about implicit close.
|
||||
import warnings
|
||||
if sys.version_info < (2, 6) :
|
||||
# Completely resetting the warning state is
|
||||
# problematic with python >=2.6 with -3 (py3k warning),
|
||||
# because some stdlib modules selectively ignores warnings.
|
||||
warnings.simplefilter("ignore")
|
||||
txn.commit()
|
||||
warnings.resetwarnings()
|
||||
else :
|
||||
# When we drop support for python 2.4
|
||||
# we could use: (in 2.5 we need a __future__ statement)
|
||||
#
|
||||
# with warnings.catch_warnings():
|
||||
# warnings.simplefilter("ignore")
|
||||
# txn.commit()
|
||||
#
|
||||
# We can not use "with" as is, because it would be invalid syntax
|
||||
# in python 2.4 and (with no __future__) 2.5.
|
||||
# Here we simulate "with" following PEP 343 :
|
||||
w = warnings.catch_warnings()
|
||||
w.__enter__()
|
||||
try :
|
||||
warnings.simplefilter("ignore")
|
||||
txn.commit()
|
||||
finally :
|
||||
w.__exit__()
|
||||
|
||||
self.assertRaises(db.DBCursorClosedError, c2.first)
|
||||
|
||||
def test07_close_db_before_sequence(self):
|
||||
import os.path
|
||||
path=os.path.join(self.homeDir,self.filename)
|
||||
d = db.DB()
|
||||
d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
|
||||
dbs=db.DBSequence(d)
|
||||
d.close() # This "close" should close the child DBSequence also
|
||||
dbs.close() # If not closed, core dump (in Berkeley DB 4.6.*)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(unittest.makeSuite(DBEnvClosedEarlyCrash))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
61
Lib/bsddb/test/test_fileid.py
Normal file
61
Lib/bsddb/test/test_fileid.py
Normal file
@@ -0,0 +1,61 @@
|
||||
"""TestCase for reseting File ID.
|
||||
"""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, get_new_database_path
|
||||
|
||||
class FileidResetTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.db_path_1 = get_new_database_path()
|
||||
self.db_path_2 = get_new_database_path()
|
||||
self.db_env_path = get_new_environment_path()
|
||||
|
||||
def test_fileid_reset(self):
|
||||
# create DB 1
|
||||
self.db1 = db.DB()
|
||||
self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=(db.DB_CREATE|db.DB_EXCL))
|
||||
self.db1.put('spam', 'eggs')
|
||||
self.db1.close()
|
||||
|
||||
shutil.copy(self.db_path_1, self.db_path_2)
|
||||
|
||||
self.db2 = db.DB()
|
||||
self.db2.open(self.db_path_2, dbtype=db.DB_HASH)
|
||||
self.db2.put('spam', 'spam')
|
||||
self.db2.close()
|
||||
|
||||
self.db_env = db.DBEnv()
|
||||
self.db_env.open(self.db_env_path, db.DB_CREATE|db.DB_INIT_MPOOL)
|
||||
|
||||
# use fileid_reset() here
|
||||
self.db_env.fileid_reset(self.db_path_2)
|
||||
|
||||
self.db1 = db.DB(self.db_env)
|
||||
self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=db.DB_RDONLY)
|
||||
self.assertEqual(self.db1.get('spam'), 'eggs')
|
||||
|
||||
self.db2 = db.DB(self.db_env)
|
||||
self.db2.open(self.db_path_2, dbtype=db.DB_HASH, flags=db.DB_RDONLY)
|
||||
self.assertEqual(self.db2.get('spam'), 'spam')
|
||||
|
||||
self.db1.close()
|
||||
self.db2.close()
|
||||
|
||||
self.db_env.close()
|
||||
|
||||
def tearDown(self):
|
||||
test_support.unlink(self.db_path_1)
|
||||
test_support.unlink(self.db_path_2)
|
||||
test_support.rmtree(self.db_env_path)
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
if db.version() >= (4, 4):
|
||||
suite.addTest(unittest.makeSuite(FileidResetTestCase))
|
||||
return suite
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
92
Lib/bsddb/test/test_get_none.py
Normal file
92
Lib/bsddb/test/test_get_none.py
Normal file
@@ -0,0 +1,92 @@
|
||||
"""
|
||||
TestCases for checking set_get_returns_none.
|
||||
"""
|
||||
|
||||
import os, string
|
||||
import unittest
|
||||
|
||||
from test_all import db, verbose, get_new_database_path
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class GetReturnsNoneTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.filename = get_new_database_path()
|
||||
|
||||
def tearDown(self):
|
||||
try:
|
||||
os.remove(self.filename)
|
||||
except os.error:
|
||||
pass
|
||||
|
||||
|
||||
def test01_get_returns_none(self):
|
||||
d = db.DB()
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE)
|
||||
d.set_get_returns_none(1)
|
||||
|
||||
for x in string.ascii_letters:
|
||||
d.put(x, x * 40)
|
||||
|
||||
data = d.get('bad key')
|
||||
self.assertEqual(data, None)
|
||||
|
||||
data = d.get(string.ascii_letters[0])
|
||||
self.assertEqual(data, string.ascii_letters[0]*40)
|
||||
|
||||
count = 0
|
||||
c = d.cursor()
|
||||
rec = c.first()
|
||||
while rec:
|
||||
count = count + 1
|
||||
rec = c.next()
|
||||
|
||||
self.assertEqual(rec, None)
|
||||
self.assertEqual(count, len(string.ascii_letters))
|
||||
|
||||
c.close()
|
||||
d.close()
|
||||
|
||||
|
||||
def test02_get_raises_exception(self):
|
||||
d = db.DB()
|
||||
d.open(self.filename, db.DB_BTREE, db.DB_CREATE)
|
||||
d.set_get_returns_none(0)
|
||||
|
||||
for x in string.ascii_letters:
|
||||
d.put(x, x * 40)
|
||||
|
||||
self.assertRaises(db.DBNotFoundError, d.get, 'bad key')
|
||||
self.assertRaises(KeyError, d.get, 'bad key')
|
||||
|
||||
data = d.get(string.ascii_letters[0])
|
||||
self.assertEqual(data, string.ascii_letters[0]*40)
|
||||
|
||||
count = 0
|
||||
exceptionHappened = 0
|
||||
c = d.cursor()
|
||||
rec = c.first()
|
||||
while rec:
|
||||
count = count + 1
|
||||
try:
|
||||
rec = c.next()
|
||||
except db.DBNotFoundError: # end of the records
|
||||
exceptionHappened = 1
|
||||
break
|
||||
|
||||
self.assertNotEqual(rec, None)
|
||||
self.assertTrue(exceptionHappened)
|
||||
self.assertEqual(count, len(string.ascii_letters))
|
||||
|
||||
c.close()
|
||||
d.close()
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(GetReturnsNoneTestCase)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
99
Lib/bsddb/test/test_join.py
Normal file
99
Lib/bsddb/test/test_join.py
Normal file
@@ -0,0 +1,99 @@
|
||||
"""TestCases for using the DB.join and DBCursor.join_item methods.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import unittest
|
||||
|
||||
from test_all import db, dbshelve, test_support, verbose, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
ProductIndex = [
|
||||
('apple', "Convenience Store"),
|
||||
('blueberry', "Farmer's Market"),
|
||||
('shotgun', "S-Mart"), # Aisle 12
|
||||
('pear', "Farmer's Market"),
|
||||
('chainsaw', "S-Mart"), # "Shop smart. Shop S-Mart!"
|
||||
('strawberry', "Farmer's Market"),
|
||||
]
|
||||
|
||||
ColorIndex = [
|
||||
('blue', "blueberry"),
|
||||
('red', "apple"),
|
||||
('red', "chainsaw"),
|
||||
('red', "strawberry"),
|
||||
('yellow', "peach"),
|
||||
('yellow', "pear"),
|
||||
('black', "shotgun"),
|
||||
]
|
||||
|
||||
class JoinTestCase(unittest.TestCase):
|
||||
keytype = ''
|
||||
|
||||
def setUp(self):
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK )
|
||||
|
||||
def tearDown(self):
|
||||
self.env.close()
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test01_join(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_join..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
# create and populate primary index
|
||||
priDB = db.DB(self.env)
|
||||
priDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE)
|
||||
map(lambda t, priDB=priDB: priDB.put(*t), ProductIndex)
|
||||
|
||||
# create and populate secondary index
|
||||
secDB = db.DB(self.env)
|
||||
secDB.set_flags(db.DB_DUP | db.DB_DUPSORT)
|
||||
secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE)
|
||||
map(lambda t, secDB=secDB: secDB.put(*t), ColorIndex)
|
||||
|
||||
sCursor = None
|
||||
jCursor = None
|
||||
try:
|
||||
# lets look up all of the red Products
|
||||
sCursor = secDB.cursor()
|
||||
# Don't do the .set() in an assert, or you can get a bogus failure
|
||||
# when running python -O
|
||||
tmp = sCursor.set('red')
|
||||
self.assertTrue(tmp)
|
||||
|
||||
# FIXME: jCursor doesn't properly hold a reference to its
|
||||
# cursors, if they are closed before jcursor is used it
|
||||
# can cause a crash.
|
||||
jCursor = priDB.join([sCursor])
|
||||
|
||||
if jCursor.get(0) != ('apple', "Convenience Store"):
|
||||
self.fail("join cursor positioned wrong")
|
||||
if jCursor.join_item() != 'chainsaw':
|
||||
self.fail("DBCursor.join_item returned wrong item")
|
||||
if jCursor.get(0)[0] != 'strawberry':
|
||||
self.fail("join cursor returned wrong thing")
|
||||
if jCursor.get(0): # there were only three red items to return
|
||||
self.fail("join cursor returned too many items")
|
||||
finally:
|
||||
if jCursor:
|
||||
jCursor.close()
|
||||
if sCursor:
|
||||
sCursor.close()
|
||||
priDB.close()
|
||||
secDB.close()
|
||||
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(unittest.makeSuite(JoinTestCase))
|
||||
|
||||
return suite
|
||||
191
Lib/bsddb/test/test_lock.py
Normal file
191
Lib/bsddb/test/test_lock.py
Normal file
@@ -0,0 +1,191 @@
|
||||
"""
|
||||
TestCases for testing the locking sub-system.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import time
|
||||
|
||||
import unittest
|
||||
from test_all import db, test_support, verbose, have_threads, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
if have_threads :
|
||||
from threading import Thread
|
||||
if sys.version_info[0] < 3 :
|
||||
from threading import currentThread
|
||||
else :
|
||||
from threading import current_thread as currentThread
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class LockingTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_THREAD | db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOCK | db.DB_CREATE)
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
self.env.close()
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
|
||||
def test01_simple(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_simple..." % self.__class__.__name__
|
||||
|
||||
anID = self.env.lock_id()
|
||||
if verbose:
|
||||
print "locker ID: %s" % anID
|
||||
lock = self.env.lock_get(anID, "some locked thing", db.DB_LOCK_WRITE)
|
||||
if verbose:
|
||||
print "Acquired lock: %s" % lock
|
||||
self.env.lock_put(lock)
|
||||
if verbose:
|
||||
print "Released lock: %s" % lock
|
||||
self.env.lock_id_free(anID)
|
||||
|
||||
|
||||
def test02_threaded(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test02_threaded..." % self.__class__.__name__
|
||||
|
||||
threads = []
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_WRITE,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_READ,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_READ,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_WRITE,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_READ,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_READ,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_WRITE,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_WRITE,)))
|
||||
threads.append(Thread(target = self.theThread,
|
||||
args=(db.DB_LOCK_WRITE,)))
|
||||
|
||||
for t in threads:
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
|
||||
def test03_lock_timeout(self):
|
||||
self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT)
|
||||
self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 0)
|
||||
self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT)
|
||||
self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 0)
|
||||
self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT)
|
||||
self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 123456)
|
||||
self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT)
|
||||
self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 7890123)
|
||||
|
||||
def test04_lock_timeout2(self):
|
||||
self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT)
|
||||
self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT)
|
||||
self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT)
|
||||
self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT)
|
||||
|
||||
def deadlock_detection() :
|
||||
while not deadlock_detection.end :
|
||||
deadlock_detection.count = \
|
||||
self.env.lock_detect(db.DB_LOCK_EXPIRE)
|
||||
if deadlock_detection.count :
|
||||
while not deadlock_detection.end :
|
||||
pass
|
||||
break
|
||||
time.sleep(0.01)
|
||||
|
||||
deadlock_detection.end=False
|
||||
deadlock_detection.count=0
|
||||
t=Thread(target=deadlock_detection)
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
self.env.set_timeout(100000, db.DB_SET_LOCK_TIMEOUT)
|
||||
anID = self.env.lock_id()
|
||||
anID2 = self.env.lock_id()
|
||||
self.assertNotEqual(anID, anID2)
|
||||
lock = self.env.lock_get(anID, "shared lock", db.DB_LOCK_WRITE)
|
||||
start_time=time.time()
|
||||
self.assertRaises(db.DBLockNotGrantedError,
|
||||
self.env.lock_get,anID2, "shared lock", db.DB_LOCK_READ)
|
||||
end_time=time.time()
|
||||
deadlock_detection.end=True
|
||||
# Floating point rounding
|
||||
if sys.platform == 'win32':
|
||||
# bpo-30850: On Windows, tolerate 50 ms whereas 100 ms is expected.
|
||||
# The lock sometimes times out after only 58 ms. Windows clocks
|
||||
# have a bad resolution and bad accuracy.
|
||||
min_dt = 0.050
|
||||
else:
|
||||
min_dt = 0.0999
|
||||
self.assertGreaterEqual(end_time-start_time, min_dt)
|
||||
self.env.lock_put(lock)
|
||||
t.join()
|
||||
|
||||
self.env.lock_id_free(anID)
|
||||
self.env.lock_id_free(anID2)
|
||||
|
||||
if db.version() >= (4,6):
|
||||
self.assertGreater(deadlock_detection.count, 0)
|
||||
|
||||
def theThread(self, lockType):
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
if lockType == db.DB_LOCK_WRITE:
|
||||
lt = "write"
|
||||
else:
|
||||
lt = "read"
|
||||
|
||||
anID = self.env.lock_id()
|
||||
if verbose:
|
||||
print "%s: locker ID: %s" % (name, anID)
|
||||
|
||||
for i in xrange(1000) :
|
||||
lock = self.env.lock_get(anID, "some locked thing", lockType)
|
||||
if verbose:
|
||||
print "%s: Acquired %s lock: %s" % (name, lt, lock)
|
||||
|
||||
self.env.lock_put(lock)
|
||||
if verbose:
|
||||
print "%s: Released %s lock: %s" % (name, lt, lock)
|
||||
|
||||
self.env.lock_id_free(anID)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
if have_threads:
|
||||
suite.addTest(unittest.makeSuite(LockingTestCase))
|
||||
else:
|
||||
suite.addTest(unittest.makeSuite(LockingTestCase, 'test01'))
|
||||
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
138
Lib/bsddb/test/test_misc.py
Normal file
138
Lib/bsddb/test/test_misc.py
Normal file
@@ -0,0 +1,138 @@
|
||||
"""Miscellaneous bsddb module test cases
|
||||
"""
|
||||
|
||||
import os, sys
|
||||
import unittest
|
||||
|
||||
from test_all import db, dbshelve, hashopen, test_support, get_new_environment_path, get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class MiscTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.filename = get_new_database_path()
|
||||
self.homeDir = get_new_environment_path()
|
||||
|
||||
def tearDown(self):
|
||||
test_support.unlink(self.filename)
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test01_badpointer(self):
|
||||
dbs = dbshelve.open(self.filename)
|
||||
dbs.close()
|
||||
self.assertRaises(db.DBError, dbs.get, "foo")
|
||||
|
||||
def test02_db_home(self):
|
||||
env = db.DBEnv()
|
||||
# check for crash fixed when db_home is used before open()
|
||||
self.assertIsNone(env.db_home)
|
||||
env.open(self.homeDir, db.DB_CREATE)
|
||||
if sys.version_info[0] < 3 :
|
||||
self.assertEqual(self.homeDir, env.db_home)
|
||||
else :
|
||||
self.assertEqual(bytes(self.homeDir, "ascii"), env.db_home)
|
||||
|
||||
def test03_repr_closed_db(self):
|
||||
db = hashopen(self.filename)
|
||||
db.close()
|
||||
rp = repr(db)
|
||||
self.assertEqual(rp, "{}")
|
||||
|
||||
def test04_repr_db(self) :
|
||||
db = hashopen(self.filename)
|
||||
d = {}
|
||||
for i in xrange(100) :
|
||||
db[repr(i)] = repr(100*i)
|
||||
d[repr(i)] = repr(100*i)
|
||||
db.close()
|
||||
db = hashopen(self.filename)
|
||||
rp = repr(db)
|
||||
self.assertEqual(rp, repr(d))
|
||||
db.close()
|
||||
|
||||
# http://sourceforge.net/tracker/index.php?func=detail&aid=1708868&group_id=13900&atid=313900
|
||||
#
|
||||
# See the bug report for details.
|
||||
#
|
||||
# The problem was that make_key_dbt() was not allocating a copy of
|
||||
# string keys but FREE_DBT() was always being told to free it when the
|
||||
# database was opened with DB_THREAD.
|
||||
def test05_double_free_make_key_dbt(self):
|
||||
try:
|
||||
db1 = db.DB()
|
||||
db1.open(self.filename, None, db.DB_BTREE,
|
||||
db.DB_CREATE | db.DB_THREAD)
|
||||
|
||||
curs = db1.cursor()
|
||||
t = curs.get("/foo", db.DB_SET)
|
||||
# double free happened during exit from DBC_get
|
||||
finally:
|
||||
db1.close()
|
||||
test_support.unlink(self.filename)
|
||||
|
||||
def test06_key_with_null_bytes(self):
|
||||
try:
|
||||
db1 = db.DB()
|
||||
db1.open(self.filename, None, db.DB_HASH, db.DB_CREATE)
|
||||
db1['a'] = 'eh?'
|
||||
db1['a\x00'] = 'eh zed.'
|
||||
db1['a\x00a'] = 'eh zed eh?'
|
||||
db1['aaa'] = 'eh eh eh!'
|
||||
keys = db1.keys()
|
||||
keys.sort()
|
||||
self.assertEqual(['a', 'a\x00', 'a\x00a', 'aaa'], keys)
|
||||
self.assertEqual(db1['a'], 'eh?')
|
||||
self.assertEqual(db1['a\x00'], 'eh zed.')
|
||||
self.assertEqual(db1['a\x00a'], 'eh zed eh?')
|
||||
self.assertEqual(db1['aaa'], 'eh eh eh!')
|
||||
finally:
|
||||
db1.close()
|
||||
test_support.unlink(self.filename)
|
||||
|
||||
def test07_DB_set_flags_persists(self):
|
||||
try:
|
||||
db1 = db.DB()
|
||||
db1.set_flags(db.DB_DUPSORT)
|
||||
db1.open(self.filename, db.DB_HASH, db.DB_CREATE)
|
||||
db1['a'] = 'eh'
|
||||
db1['a'] = 'A'
|
||||
self.assertEqual([('a', 'A')], db1.items())
|
||||
db1.put('a', 'Aa')
|
||||
self.assertEqual([('a', 'A'), ('a', 'Aa')], db1.items())
|
||||
db1.close()
|
||||
db1 = db.DB()
|
||||
# no set_flags call, we're testing that it reads and obeys
|
||||
# the flags on open.
|
||||
db1.open(self.filename, db.DB_HASH)
|
||||
self.assertEqual([('a', 'A'), ('a', 'Aa')], db1.items())
|
||||
# if it read the flags right this will replace all values
|
||||
# for key 'a' instead of adding a new one. (as a dict should)
|
||||
db1['a'] = 'new A'
|
||||
self.assertEqual([('a', 'new A')], db1.items())
|
||||
finally:
|
||||
db1.close()
|
||||
test_support.unlink(self.filename)
|
||||
|
||||
|
||||
def test08_ExceptionTypes(self) :
|
||||
self.assertTrue(issubclass(db.DBError, Exception))
|
||||
for i, j in db.__dict__.items() :
|
||||
if i.startswith("DB") and i.endswith("Error") :
|
||||
self.assertTrue(issubclass(j, db.DBError), msg=i)
|
||||
if i not in ("DBKeyEmptyError", "DBNotFoundError") :
|
||||
self.assertFalse(issubclass(j, KeyError), msg=i)
|
||||
|
||||
# This two exceptions have two bases
|
||||
self.assertTrue(issubclass(db.DBKeyEmptyError, KeyError))
|
||||
self.assertTrue(issubclass(db.DBNotFoundError, KeyError))
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(MiscTestCase)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
68
Lib/bsddb/test/test_pickle.py
Normal file
68
Lib/bsddb/test/test_pickle.py
Normal file
@@ -0,0 +1,68 @@
|
||||
|
||||
import os
|
||||
import pickle
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] < 3 :
|
||||
try:
|
||||
import cPickle
|
||||
except ImportError:
|
||||
cPickle = None
|
||||
else :
|
||||
cPickle = None
|
||||
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class pickleTestCase(unittest.TestCase):
|
||||
"""Verify that DBError can be pickled and unpickled"""
|
||||
db_name = 'test-dbobj.db'
|
||||
|
||||
def setUp(self):
|
||||
self.homeDir = get_new_environment_path()
|
||||
|
||||
def tearDown(self):
|
||||
if hasattr(self, 'db'):
|
||||
del self.db
|
||||
if hasattr(self, 'env'):
|
||||
del self.env
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def _base_test_pickle_DBError(self, pickle):
|
||||
self.env = db.DBEnv()
|
||||
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
|
||||
self.db = db.DB(self.env)
|
||||
self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE)
|
||||
self.db.put('spam', 'eggs')
|
||||
self.assertEqual(self.db['spam'], 'eggs')
|
||||
try:
|
||||
self.db.put('spam', 'ham', flags=db.DB_NOOVERWRITE)
|
||||
except db.DBError, egg:
|
||||
pickledEgg = pickle.dumps(egg)
|
||||
#print repr(pickledEgg)
|
||||
rottenEgg = pickle.loads(pickledEgg)
|
||||
if rottenEgg.args != egg.args or type(rottenEgg) != type(egg):
|
||||
raise Exception, (rottenEgg, '!=', egg)
|
||||
else:
|
||||
raise Exception, "where's my DBError exception?!?"
|
||||
|
||||
self.db.close()
|
||||
self.env.close()
|
||||
|
||||
def test01_pickle_DBError(self):
|
||||
self._base_test_pickle_DBError(pickle=pickle)
|
||||
|
||||
if cPickle:
|
||||
def test02_cPickle_DBError(self):
|
||||
self._base_test_pickle_DBError(pickle=cPickle)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(pickleTestCase)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
163
Lib/bsddb/test/test_queue.py
Normal file
163
Lib/bsddb/test/test_queue.py
Normal file
@@ -0,0 +1,163 @@
|
||||
"""
|
||||
TestCases for exercising a Queue DB.
|
||||
"""
|
||||
|
||||
import os, string
|
||||
from pprint import pprint
|
||||
import unittest
|
||||
|
||||
from test_all import db, verbose, get_new_database_path
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class SimpleQueueTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.filename = get_new_database_path()
|
||||
|
||||
def tearDown(self):
|
||||
try:
|
||||
os.remove(self.filename)
|
||||
except os.error:
|
||||
pass
|
||||
|
||||
|
||||
def test01_basic(self):
|
||||
# Basic Queue tests using the deprecated DBCursor.consume method.
|
||||
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_basic..." % self.__class__.__name__
|
||||
|
||||
d = db.DB()
|
||||
d.set_re_len(40) # Queues must be fixed length
|
||||
d.open(self.filename, db.DB_QUEUE, db.DB_CREATE)
|
||||
|
||||
if verbose:
|
||||
print "before appends" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
for x in string.ascii_letters:
|
||||
d.append(x * 40)
|
||||
|
||||
self.assertEqual(len(d), len(string.ascii_letters))
|
||||
|
||||
d.put(100, "some more data")
|
||||
d.put(101, "and some more ")
|
||||
d.put(75, "out of order")
|
||||
d.put(1, "replacement data")
|
||||
|
||||
self.assertEqual(len(d), len(string.ascii_letters)+3)
|
||||
|
||||
if verbose:
|
||||
print "before close" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
d.close()
|
||||
del d
|
||||
d = db.DB()
|
||||
d.open(self.filename)
|
||||
|
||||
if verbose:
|
||||
print "after open" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
# Test "txn" as a positional parameter
|
||||
d.append("one more", None)
|
||||
# Test "txn" as a keyword parameter
|
||||
d.append("another one", txn=None)
|
||||
|
||||
c = d.cursor()
|
||||
|
||||
if verbose:
|
||||
print "after append" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
rec = c.consume()
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
rec = c.consume()
|
||||
c.close()
|
||||
|
||||
if verbose:
|
||||
print "after consume loop" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
self.assertEqual(len(d), 0, \
|
||||
"if you see this message then you need to rebuild " \
|
||||
"Berkeley DB 3.1.17 with the patch in patches/qam_stat.diff")
|
||||
|
||||
d.close()
|
||||
|
||||
|
||||
|
||||
def test02_basicPost32(self):
|
||||
# Basic Queue tests using the new DB.consume method in DB 3.2+
|
||||
# (No cursor needed)
|
||||
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test02_basicPost32..." % self.__class__.__name__
|
||||
|
||||
d = db.DB()
|
||||
d.set_re_len(40) # Queues must be fixed length
|
||||
d.open(self.filename, db.DB_QUEUE, db.DB_CREATE)
|
||||
|
||||
if verbose:
|
||||
print "before appends" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
for x in string.ascii_letters:
|
||||
d.append(x * 40)
|
||||
|
||||
self.assertEqual(len(d), len(string.ascii_letters))
|
||||
|
||||
d.put(100, "some more data")
|
||||
d.put(101, "and some more ")
|
||||
d.put(75, "out of order")
|
||||
d.put(1, "replacement data")
|
||||
|
||||
self.assertEqual(len(d), len(string.ascii_letters)+3)
|
||||
|
||||
if verbose:
|
||||
print "before close" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
d.close()
|
||||
del d
|
||||
d = db.DB()
|
||||
d.open(self.filename)
|
||||
#d.set_get_returns_none(true)
|
||||
|
||||
if verbose:
|
||||
print "after open" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
d.append("one more")
|
||||
|
||||
if verbose:
|
||||
print "after append" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
rec = d.consume()
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
rec = d.consume()
|
||||
|
||||
if verbose:
|
||||
print "after consume loop" + '-' * 30
|
||||
pprint(d.stat())
|
||||
|
||||
d.close()
|
||||
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(SimpleQueueTestCase)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
319
Lib/bsddb/test/test_recno.py
Normal file
319
Lib/bsddb/test/test_recno.py
Normal file
@@ -0,0 +1,319 @@
|
||||
"""TestCases for exercising a Recno DB.
|
||||
"""
|
||||
|
||||
import os, sys
|
||||
import errno
|
||||
from pprint import pprint
|
||||
import string
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class SimpleRecnoTestCase(unittest.TestCase):
|
||||
if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
|
||||
(sys.version_info < (3, 2))) :
|
||||
def assertIsInstance(self, obj, datatype, msg=None) :
|
||||
return self.assertEqual(type(obj), datatype, msg=msg)
|
||||
def assertGreaterEqual(self, a, b, msg=None) :
|
||||
return self.assertGreaterEqual(a, b, msg=msg)
|
||||
|
||||
|
||||
def setUp(self):
|
||||
self.filename = get_new_database_path()
|
||||
self.homeDir = None
|
||||
|
||||
def tearDown(self):
|
||||
test_support.unlink(self.filename)
|
||||
if self.homeDir:
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test01_basic(self):
|
||||
d = db.DB()
|
||||
|
||||
get_returns_none = d.set_get_returns_none(2)
|
||||
d.set_get_returns_none(get_returns_none)
|
||||
|
||||
d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
|
||||
|
||||
for x in string.ascii_letters:
|
||||
recno = d.append(x * 60)
|
||||
self.assertIsInstance(recno, int)
|
||||
self.assertGreaterEqual(recno, 1)
|
||||
if verbose:
|
||||
print recno,
|
||||
|
||||
if verbose: print
|
||||
|
||||
stat = d.stat()
|
||||
if verbose:
|
||||
pprint(stat)
|
||||
|
||||
for recno in range(1, len(d)+1):
|
||||
data = d[recno]
|
||||
if verbose:
|
||||
print data
|
||||
|
||||
self.assertIsInstance(data, str)
|
||||
self.assertEqual(data, d.get(recno))
|
||||
|
||||
try:
|
||||
data = d[0] # This should raise a KeyError!?!?!
|
||||
except db.DBInvalidArgError, val:
|
||||
if sys.version_info < (2, 6) :
|
||||
self.assertEqual(val[0], db.EINVAL)
|
||||
else :
|
||||
self.assertEqual(val.args[0], db.EINVAL)
|
||||
if verbose: print val
|
||||
else:
|
||||
self.fail("expected exception")
|
||||
|
||||
# test that has_key raises DB exceptions (fixed in pybsddb 4.3.2)
|
||||
try:
|
||||
d.has_key(0)
|
||||
except db.DBError, val:
|
||||
pass
|
||||
else:
|
||||
self.fail("has_key did not raise a proper exception")
|
||||
|
||||
try:
|
||||
data = d[100]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
self.fail("expected exception")
|
||||
|
||||
try:
|
||||
data = d.get(100)
|
||||
except db.DBNotFoundError, val:
|
||||
if get_returns_none:
|
||||
self.fail("unexpected exception")
|
||||
else:
|
||||
self.assertEqual(data, None)
|
||||
|
||||
keys = d.keys()
|
||||
if verbose:
|
||||
print keys
|
||||
self.assertIsInstance(keys, list)
|
||||
self.assertIsInstance(keys[0], int)
|
||||
self.assertEqual(len(keys), len(d))
|
||||
|
||||
items = d.items()
|
||||
if verbose:
|
||||
pprint(items)
|
||||
self.assertIsInstance(items, list)
|
||||
self.assertIsInstance(items[0], tuple)
|
||||
self.assertEqual(len(items[0]), 2)
|
||||
self.assertIsInstance(items[0][0], int)
|
||||
self.assertIsInstance(items[0][1], str)
|
||||
self.assertEqual(len(items), len(d))
|
||||
|
||||
self.assertTrue(d.has_key(25))
|
||||
|
||||
del d[25]
|
||||
self.assertFalse(d.has_key(25))
|
||||
|
||||
d.delete(13)
|
||||
self.assertFalse(d.has_key(13))
|
||||
|
||||
data = d.get_both(26, "z" * 60)
|
||||
self.assertEqual(data, "z" * 60, 'was %r' % data)
|
||||
if verbose:
|
||||
print data
|
||||
|
||||
fd = d.fd()
|
||||
if verbose:
|
||||
print fd
|
||||
|
||||
c = d.cursor()
|
||||
rec = c.first()
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
rec = c.next()
|
||||
|
||||
c.set(50)
|
||||
rec = c.current()
|
||||
if verbose:
|
||||
print rec
|
||||
|
||||
c.put(-1, "a replacement record", db.DB_CURRENT)
|
||||
|
||||
c.set(50)
|
||||
rec = c.current()
|
||||
self.assertEqual(rec, (50, "a replacement record"))
|
||||
if verbose:
|
||||
print rec
|
||||
|
||||
rec = c.set_range(30)
|
||||
if verbose:
|
||||
print rec
|
||||
|
||||
# test that non-existent key lookups work (and that
|
||||
# DBC_set_range doesn't have a memleak under valgrind)
|
||||
rec = c.set_range(999999)
|
||||
self.assertEqual(rec, None)
|
||||
if verbose:
|
||||
print rec
|
||||
|
||||
c.close()
|
||||
d.close()
|
||||
|
||||
d = db.DB()
|
||||
d.open(self.filename)
|
||||
c = d.cursor()
|
||||
|
||||
# put a record beyond the consecutive end of the recno's
|
||||
d[100] = "way out there"
|
||||
self.assertEqual(d[100], "way out there")
|
||||
|
||||
try:
|
||||
data = d[99]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
self.fail("expected exception")
|
||||
|
||||
try:
|
||||
d.get(99)
|
||||
except db.DBKeyEmptyError, val:
|
||||
if get_returns_none:
|
||||
self.fail("unexpected DBKeyEmptyError exception")
|
||||
else:
|
||||
if sys.version_info < (2, 6) :
|
||||
self.assertEqual(val[0], db.DB_KEYEMPTY)
|
||||
else :
|
||||
self.assertEqual(val.args[0], db.DB_KEYEMPTY)
|
||||
if verbose: print val
|
||||
else:
|
||||
if not get_returns_none:
|
||||
self.fail("expected exception")
|
||||
|
||||
rec = c.set(40)
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
rec = c.next()
|
||||
|
||||
c.close()
|
||||
d.close()
|
||||
|
||||
def test02_WithSource(self):
|
||||
"""
|
||||
A Recno file that is given a "backing source file" is essentially a
|
||||
simple ASCII file. Normally each record is delimited by \n and so is
|
||||
just a line in the file, but you can set a different record delimiter
|
||||
if needed.
|
||||
"""
|
||||
homeDir = get_new_environment_path()
|
||||
self.homeDir = homeDir
|
||||
source = os.path.join(homeDir, 'test_recno.txt')
|
||||
if not os.path.isdir(homeDir):
|
||||
os.mkdir(homeDir)
|
||||
f = open(source, 'w') # create the file
|
||||
f.close()
|
||||
|
||||
d = db.DB()
|
||||
# This is the default value, just checking if both int
|
||||
d.set_re_delim(0x0A)
|
||||
d.set_re_delim('\n') # and char can be used...
|
||||
d.set_re_source(source)
|
||||
d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
|
||||
|
||||
data = "The quick brown fox jumped over the lazy dog".split()
|
||||
for datum in data:
|
||||
d.append(datum)
|
||||
d.sync()
|
||||
d.close()
|
||||
|
||||
# get the text from the backing source
|
||||
f = open(source, 'r')
|
||||
text = f.read()
|
||||
f.close()
|
||||
text = text.strip()
|
||||
if verbose:
|
||||
print text
|
||||
print data
|
||||
print text.split('\n')
|
||||
|
||||
self.assertEqual(text.split('\n'), data)
|
||||
|
||||
# open as a DB again
|
||||
d = db.DB()
|
||||
d.set_re_source(source)
|
||||
d.open(self.filename, db.DB_RECNO)
|
||||
|
||||
d[3] = 'reddish-brown'
|
||||
d[8] = 'comatose'
|
||||
|
||||
d.sync()
|
||||
d.close()
|
||||
|
||||
f = open(source, 'r')
|
||||
text = f.read()
|
||||
f.close()
|
||||
text = text.strip()
|
||||
if verbose:
|
||||
print text
|
||||
print text.split('\n')
|
||||
|
||||
self.assertEqual(text.split('\n'),
|
||||
"The quick reddish-brown fox jumped over the comatose dog".split())
|
||||
|
||||
def test03_FixedLength(self):
|
||||
d = db.DB()
|
||||
d.set_re_len(40) # fixed length records, 40 bytes long
|
||||
d.set_re_pad('-') # sets the pad character...
|
||||
d.set_re_pad(45) # ...test both int and char
|
||||
d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
|
||||
|
||||
for x in string.ascii_letters:
|
||||
d.append(x * 35) # These will be padded
|
||||
|
||||
d.append('.' * 40) # this one will be exact
|
||||
|
||||
try: # this one will fail
|
||||
d.append('bad' * 20)
|
||||
except db.DBInvalidArgError, val:
|
||||
if sys.version_info < (2, 6) :
|
||||
self.assertEqual(val[0], db.EINVAL)
|
||||
else :
|
||||
self.assertEqual(val.args[0], db.EINVAL)
|
||||
if verbose: print val
|
||||
else:
|
||||
self.fail("expected exception")
|
||||
|
||||
c = d.cursor()
|
||||
rec = c.first()
|
||||
while rec:
|
||||
if verbose:
|
||||
print rec
|
||||
rec = c.next()
|
||||
|
||||
c.close()
|
||||
d.close()
|
||||
|
||||
def test04_get_size_empty(self) :
|
||||
d = db.DB()
|
||||
d.open(self.filename, dbtype=db.DB_RECNO, flags=db.DB_CREATE)
|
||||
|
||||
row_id = d.append(' ')
|
||||
self.assertEqual(1, d.get_size(key=row_id))
|
||||
row_id = d.append('')
|
||||
self.assertEqual(0, d.get_size(key=row_id))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(SimpleRecnoTestCase)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
541
Lib/bsddb/test/test_replication.py
Normal file
541
Lib/bsddb/test/test_replication.py
Normal file
@@ -0,0 +1,541 @@
|
||||
"""TestCases for distributed transactions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import time
|
||||
import unittest
|
||||
|
||||
from test_all import db, test_support, have_threads, verbose, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DBReplication(unittest.TestCase) :
|
||||
def setUp(self) :
|
||||
self.homeDirMaster = get_new_environment_path()
|
||||
self.homeDirClient = get_new_environment_path()
|
||||
|
||||
self.dbenvMaster = db.DBEnv()
|
||||
self.dbenvClient = db.DBEnv()
|
||||
|
||||
# Must use "DB_THREAD" because the Replication Manager will
|
||||
# be executed in other threads but will use the same environment.
|
||||
# http://forums.oracle.com/forums/thread.jspa?threadID=645788&tstart=0
|
||||
self.dbenvMaster.open(self.homeDirMaster, db.DB_CREATE | db.DB_INIT_TXN
|
||||
| db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK |
|
||||
db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0666)
|
||||
self.dbenvClient.open(self.homeDirClient, db.DB_CREATE | db.DB_INIT_TXN
|
||||
| db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK |
|
||||
db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0666)
|
||||
|
||||
self.confirmed_master=self.client_startupdone=False
|
||||
def confirmed_master(a,b,c) :
|
||||
if b==db.DB_EVENT_REP_MASTER :
|
||||
self.confirmed_master=True
|
||||
|
||||
def client_startupdone(a,b,c) :
|
||||
if b==db.DB_EVENT_REP_STARTUPDONE :
|
||||
self.client_startupdone=True
|
||||
|
||||
self.dbenvMaster.set_event_notify(confirmed_master)
|
||||
self.dbenvClient.set_event_notify(client_startupdone)
|
||||
|
||||
#self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True)
|
||||
#self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
|
||||
#self.dbenvClient.set_verbose(db.DB_VERB_REPLICATION, True)
|
||||
#self.dbenvClient.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
|
||||
|
||||
self.dbMaster = self.dbClient = None
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
if self.dbClient :
|
||||
self.dbClient.close()
|
||||
if self.dbMaster :
|
||||
self.dbMaster.close()
|
||||
|
||||
# Here we assign dummy event handlers to allow GC of the test object.
|
||||
# Since the dummy handler doesn't use any outer scope variable, it
|
||||
# doesn't keep any reference to the test object.
|
||||
def dummy(*args) :
|
||||
pass
|
||||
self.dbenvMaster.set_event_notify(dummy)
|
||||
self.dbenvClient.set_event_notify(dummy)
|
||||
|
||||
self.dbenvClient.close()
|
||||
self.dbenvMaster.close()
|
||||
test_support.rmtree(self.homeDirClient)
|
||||
test_support.rmtree(self.homeDirMaster)
|
||||
|
||||
class DBReplicationManager(DBReplication) :
|
||||
def test01_basic_replication(self) :
|
||||
master_port = test_support.find_unused_port()
|
||||
client_port = test_support.find_unused_port()
|
||||
if db.version() >= (5, 2) :
|
||||
self.site = self.dbenvMaster.repmgr_site("127.0.0.1", master_port)
|
||||
self.site.set_config(db.DB_GROUP_CREATOR, True)
|
||||
self.site.set_config(db.DB_LOCAL_SITE, True)
|
||||
self.site2 = self.dbenvMaster.repmgr_site("127.0.0.1", client_port)
|
||||
|
||||
self.site3 = self.dbenvClient.repmgr_site("127.0.0.1", master_port)
|
||||
self.site3.set_config(db.DB_BOOTSTRAP_HELPER, True)
|
||||
self.site4 = self.dbenvClient.repmgr_site("127.0.0.1", client_port)
|
||||
self.site4.set_config(db.DB_LOCAL_SITE, True)
|
||||
|
||||
d = {
|
||||
db.DB_BOOTSTRAP_HELPER: [False, False, True, False],
|
||||
db.DB_GROUP_CREATOR: [True, False, False, False],
|
||||
db.DB_LEGACY: [False, False, False, False],
|
||||
db.DB_LOCAL_SITE: [True, False, False, True],
|
||||
db.DB_REPMGR_PEER: [False, False, False, False ],
|
||||
}
|
||||
|
||||
for i, j in d.items() :
|
||||
for k, v in \
|
||||
zip([self.site, self.site2, self.site3, self.site4], j) :
|
||||
if v :
|
||||
self.assertTrue(k.get_config(i))
|
||||
else :
|
||||
self.assertFalse(k.get_config(i))
|
||||
|
||||
self.assertNotEqual(self.site.get_eid(), self.site2.get_eid())
|
||||
self.assertNotEqual(self.site3.get_eid(), self.site4.get_eid())
|
||||
|
||||
for i, j in zip([self.site, self.site2, self.site3, self.site4], \
|
||||
[master_port, client_port, master_port, client_port]) :
|
||||
addr = i.get_address()
|
||||
self.assertEqual(addr, ("127.0.0.1", j))
|
||||
|
||||
for i in [self.site, self.site2] :
|
||||
self.assertEqual(i.get_address(),
|
||||
self.dbenvMaster.repmgr_site_by_eid(i.get_eid()).get_address())
|
||||
for i in [self.site3, self.site4] :
|
||||
self.assertEqual(i.get_address(),
|
||||
self.dbenvClient.repmgr_site_by_eid(i.get_eid()).get_address())
|
||||
else :
|
||||
self.dbenvMaster.repmgr_set_local_site("127.0.0.1", master_port)
|
||||
self.dbenvClient.repmgr_set_local_site("127.0.0.1", client_port)
|
||||
self.dbenvMaster.repmgr_add_remote_site("127.0.0.1", client_port)
|
||||
self.dbenvClient.repmgr_add_remote_site("127.0.0.1", master_port)
|
||||
|
||||
self.dbenvMaster.rep_set_nsites(2)
|
||||
self.dbenvClient.rep_set_nsites(2)
|
||||
|
||||
self.dbenvMaster.rep_set_priority(10)
|
||||
self.dbenvClient.rep_set_priority(0)
|
||||
|
||||
self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123)
|
||||
self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321)
|
||||
self.assertEqual(self.dbenvMaster.rep_get_timeout(
|
||||
db.DB_REP_CONNECTION_RETRY), 100123)
|
||||
self.assertEqual(self.dbenvClient.rep_get_timeout(
|
||||
db.DB_REP_CONNECTION_RETRY), 100321)
|
||||
|
||||
self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234)
|
||||
self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432)
|
||||
self.assertEqual(self.dbenvMaster.rep_get_timeout(
|
||||
db.DB_REP_ELECTION_TIMEOUT), 100234)
|
||||
self.assertEqual(self.dbenvClient.rep_get_timeout(
|
||||
db.DB_REP_ELECTION_TIMEOUT), 100432)
|
||||
|
||||
self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345)
|
||||
self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543)
|
||||
self.assertEqual(self.dbenvMaster.rep_get_timeout(
|
||||
db.DB_REP_ELECTION_RETRY), 100345)
|
||||
self.assertEqual(self.dbenvClient.rep_get_timeout(
|
||||
db.DB_REP_ELECTION_RETRY), 100543)
|
||||
|
||||
self.dbenvMaster.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL)
|
||||
self.dbenvClient.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL)
|
||||
|
||||
self.dbenvMaster.repmgr_start(1, db.DB_REP_MASTER);
|
||||
self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT);
|
||||
|
||||
self.assertEqual(self.dbenvMaster.rep_get_nsites(),2)
|
||||
self.assertEqual(self.dbenvClient.rep_get_nsites(),2)
|
||||
self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
|
||||
self.assertEqual(self.dbenvClient.rep_get_priority(),0)
|
||||
self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(),
|
||||
db.DB_REPMGR_ACKS_ALL)
|
||||
self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(),
|
||||
db.DB_REPMGR_ACKS_ALL)
|
||||
|
||||
# The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE
|
||||
# is not generated if the master has no new transactions.
|
||||
# This is solved in BDB 4.6 (#15542).
|
||||
import time
|
||||
timeout = time.time()+60
|
||||
while (time.time()<timeout) and not (self.confirmed_master and self.client_startupdone) :
|
||||
time.sleep(0.02)
|
||||
# self.client_startupdone does not always get set to True within
|
||||
# the timeout. On windows this may be a deep issue, on other
|
||||
# platforms it is likely just a timing issue, especially on slow
|
||||
# virthost buildbots (see issue 3892 for more). Even though
|
||||
# the timeout triggers, the rest of this test method usually passes
|
||||
# (but not all of it always, see below). So we just note the
|
||||
# timeout on stderr and keep soldering on.
|
||||
if time.time()>timeout:
|
||||
import sys
|
||||
print >> sys.stderr, ("XXX: timeout happened before"
|
||||
"startup was confirmed - see issue 3892")
|
||||
startup_timeout = True
|
||||
|
||||
d = self.dbenvMaster.repmgr_site_list()
|
||||
self.assertEqual(len(d), 1)
|
||||
d = d.values()[0] # There is only one
|
||||
self.assertEqual(d[0], "127.0.0.1")
|
||||
self.assertEqual(d[1], client_port)
|
||||
self.assertIn(d[2], (db.DB_REPMGR_CONNECTED, db.DB_REPMGR_DISCONNECTED))
|
||||
|
||||
d = self.dbenvClient.repmgr_site_list()
|
||||
self.assertEqual(len(d), 1)
|
||||
d = d.values()[0] # There is only one
|
||||
self.assertEqual(d[0], "127.0.0.1")
|
||||
self.assertEqual(d[1], master_port)
|
||||
self.assertIn(d[2], (db.DB_REPMGR_CONNECTED, db.DB_REPMGR_DISCONNECTED))
|
||||
|
||||
if db.version() >= (4,6) :
|
||||
d = self.dbenvMaster.repmgr_stat(flags=db.DB_STAT_CLEAR);
|
||||
self.assertIn("msgs_queued", d)
|
||||
|
||||
self.dbMaster=db.DB(self.dbenvMaster)
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.open("test", db.DB_HASH, db.DB_CREATE, 0666, txn=txn)
|
||||
txn.commit()
|
||||
|
||||
import time,os.path
|
||||
timeout=time.time()+10
|
||||
while (time.time()<timeout) and \
|
||||
not (os.path.exists(os.path.join(self.homeDirClient,"test"))) :
|
||||
time.sleep(0.01)
|
||||
|
||||
self.dbClient=db.DB(self.dbenvClient)
|
||||
while True :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
try :
|
||||
self.dbClient.open("test", db.DB_HASH, flags=db.DB_RDONLY,
|
||||
mode=0666, txn=txn)
|
||||
except db.DBRepHandleDeadError :
|
||||
txn.abort()
|
||||
self.dbClient.close()
|
||||
self.dbClient=db.DB(self.dbenvClient)
|
||||
continue
|
||||
|
||||
txn.commit()
|
||||
break
|
||||
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.put("ABC", "123", txn=txn)
|
||||
txn.commit()
|
||||
import time
|
||||
timeout=time.time()+10
|
||||
v=None
|
||||
while (time.time()<timeout) and (v is None) :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
v=self.dbClient.get("ABC", txn=txn)
|
||||
txn.commit()
|
||||
if v is None :
|
||||
time.sleep(0.02)
|
||||
# If startup did not happen before the timeout above, then this test
|
||||
# sometimes fails. This happens randomly, which causes buildbot
|
||||
# instability, but all the other bsddb tests pass. Since bsddb3 in the
|
||||
# stdlib is currently not getting active maintenance, and is gone in
|
||||
# py3k, we just skip the end of the test in that case.
|
||||
if time.time()>=timeout and startup_timeout:
|
||||
self.skipTest("replication test skipped due to random failure, "
|
||||
"see issue 3892")
|
||||
self.assertLess(time.time(), timeout)
|
||||
self.assertEqual("123", v)
|
||||
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.delete("ABC", txn=txn)
|
||||
txn.commit()
|
||||
timeout=time.time()+10
|
||||
while (time.time()<timeout) and (v is not None) :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
v=self.dbClient.get("ABC", txn=txn)
|
||||
txn.commit()
|
||||
if v is None :
|
||||
time.sleep(0.02)
|
||||
self.assertLess(time.time(), timeout)
|
||||
self.assertEqual(None, v)
|
||||
|
||||
class DBBaseReplication(DBReplication) :
|
||||
def setUp(self) :
|
||||
DBReplication.setUp(self)
|
||||
def confirmed_master(a,b,c) :
|
||||
if (b == db.DB_EVENT_REP_MASTER) or (b == db.DB_EVENT_REP_ELECTED) :
|
||||
self.confirmed_master = True
|
||||
|
||||
def client_startupdone(a,b,c) :
|
||||
if b == db.DB_EVENT_REP_STARTUPDONE :
|
||||
self.client_startupdone = True
|
||||
|
||||
self.dbenvMaster.set_event_notify(confirmed_master)
|
||||
self.dbenvClient.set_event_notify(client_startupdone)
|
||||
|
||||
import Queue
|
||||
self.m2c = Queue.Queue()
|
||||
self.c2m = Queue.Queue()
|
||||
|
||||
# There are only two nodes, so we don't need to
|
||||
# do any routing decision
|
||||
def m2c(dbenv, control, rec, lsnp, envid, flags) :
|
||||
self.m2c.put((control, rec))
|
||||
|
||||
def c2m(dbenv, control, rec, lsnp, envid, flags) :
|
||||
self.c2m.put((control, rec))
|
||||
|
||||
self.dbenvMaster.rep_set_transport(13,m2c)
|
||||
self.dbenvMaster.rep_set_priority(10)
|
||||
self.dbenvClient.rep_set_transport(3,c2m)
|
||||
self.dbenvClient.rep_set_priority(0)
|
||||
|
||||
self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
|
||||
self.assertEqual(self.dbenvClient.rep_get_priority(),0)
|
||||
|
||||
#self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True)
|
||||
#self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
|
||||
#self.dbenvClient.set_verbose(db.DB_VERB_REPLICATION, True)
|
||||
#self.dbenvClient.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
|
||||
|
||||
def thread_master() :
|
||||
return self.thread_do(self.dbenvMaster, self.c2m, 3,
|
||||
self.master_doing_election, True)
|
||||
|
||||
def thread_client() :
|
||||
return self.thread_do(self.dbenvClient, self.m2c, 13,
|
||||
self.client_doing_election, False)
|
||||
|
||||
from threading import Thread
|
||||
t_m=Thread(target=thread_master)
|
||||
t_c=Thread(target=thread_client)
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
t_m.setDaemon(True)
|
||||
t_c.setDaemon(True)
|
||||
else :
|
||||
t_m.daemon = True
|
||||
t_c.daemon = True
|
||||
|
||||
self.t_m = t_m
|
||||
self.t_c = t_c
|
||||
|
||||
self.dbMaster = self.dbClient = None
|
||||
|
||||
self.master_doing_election=[False]
|
||||
self.client_doing_election=[False]
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
if self.dbClient :
|
||||
self.dbClient.close()
|
||||
if self.dbMaster :
|
||||
self.dbMaster.close()
|
||||
self.m2c.put(None)
|
||||
self.c2m.put(None)
|
||||
self.t_m.join()
|
||||
self.t_c.join()
|
||||
|
||||
# Here we assign dummy event handlers to allow GC of the test object.
|
||||
# Since the dummy handler doesn't use any outer scope variable, it
|
||||
# doesn't keep any reference to the test object.
|
||||
def dummy(*args) :
|
||||
pass
|
||||
self.dbenvMaster.set_event_notify(dummy)
|
||||
self.dbenvClient.set_event_notify(dummy)
|
||||
self.dbenvMaster.rep_set_transport(13,dummy)
|
||||
self.dbenvClient.rep_set_transport(3,dummy)
|
||||
|
||||
self.dbenvClient.close()
|
||||
self.dbenvMaster.close()
|
||||
test_support.rmtree(self.homeDirClient)
|
||||
test_support.rmtree(self.homeDirMaster)
|
||||
|
||||
def basic_rep_threading(self) :
|
||||
self.dbenvMaster.rep_start(flags=db.DB_REP_MASTER)
|
||||
self.dbenvClient.rep_start(flags=db.DB_REP_CLIENT)
|
||||
|
||||
def thread_do(env, q, envid, election_status, must_be_master) :
|
||||
while True :
|
||||
v=q.get()
|
||||
if v is None : return
|
||||
env.rep_process_message(v[0], v[1], envid)
|
||||
|
||||
self.thread_do = thread_do
|
||||
|
||||
self.t_m.start()
|
||||
self.t_c.start()
|
||||
|
||||
def test01_basic_replication(self) :
|
||||
self.basic_rep_threading()
|
||||
|
||||
# The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE
|
||||
# is not generated if the master has no new transactions.
|
||||
# This is solved in BDB 4.6 (#15542).
|
||||
import time
|
||||
timeout = time.time()+60
|
||||
while (time.time()<timeout) and not (self.confirmed_master and
|
||||
self.client_startupdone) :
|
||||
time.sleep(0.02)
|
||||
self.assertLess(time.time(), timeout)
|
||||
|
||||
self.dbMaster=db.DB(self.dbenvMaster)
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.open("test", db.DB_HASH, db.DB_CREATE, 0666, txn=txn)
|
||||
txn.commit()
|
||||
|
||||
import time,os.path
|
||||
timeout=time.time()+10
|
||||
while (time.time()<timeout) and \
|
||||
not (os.path.exists(os.path.join(self.homeDirClient,"test"))) :
|
||||
time.sleep(0.01)
|
||||
|
||||
self.dbClient=db.DB(self.dbenvClient)
|
||||
while True :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
try :
|
||||
self.dbClient.open("test", db.DB_HASH, flags=db.DB_RDONLY,
|
||||
mode=0666, txn=txn)
|
||||
except db.DBRepHandleDeadError :
|
||||
txn.abort()
|
||||
self.dbClient.close()
|
||||
self.dbClient=db.DB(self.dbenvClient)
|
||||
continue
|
||||
|
||||
txn.commit()
|
||||
break
|
||||
|
||||
d = self.dbenvMaster.rep_stat(flags=db.DB_STAT_CLEAR);
|
||||
self.assertIn("master_changes", d)
|
||||
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.put("ABC", "123", txn=txn)
|
||||
txn.commit()
|
||||
import time
|
||||
timeout=time.time()+10
|
||||
v=None
|
||||
while (time.time()<timeout) and (v is None) :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
v=self.dbClient.get("ABC", txn=txn)
|
||||
txn.commit()
|
||||
if v is None :
|
||||
time.sleep(0.02)
|
||||
self.assertLess(time.time(), timeout)
|
||||
self.assertEqual("123", v)
|
||||
|
||||
txn=self.dbenvMaster.txn_begin()
|
||||
self.dbMaster.delete("ABC", txn=txn)
|
||||
txn.commit()
|
||||
timeout=time.time()+10
|
||||
while (time.time()<timeout) and (v is not None) :
|
||||
txn=self.dbenvClient.txn_begin()
|
||||
v=self.dbClient.get("ABC", txn=txn)
|
||||
txn.commit()
|
||||
if v is None :
|
||||
time.sleep(0.02)
|
||||
self.assertLess(time.time(), timeout)
|
||||
self.assertEqual(None, v)
|
||||
|
||||
if db.version() >= (4,7) :
|
||||
def test02_test_request(self) :
|
||||
self.basic_rep_threading()
|
||||
(minimum, maximum) = self.dbenvClient.rep_get_request()
|
||||
self.dbenvClient.rep_set_request(minimum-1, maximum+1)
|
||||
self.assertEqual(self.dbenvClient.rep_get_request(),
|
||||
(minimum-1, maximum+1))
|
||||
|
||||
if db.version() >= (4,6) :
|
||||
def test03_master_election(self) :
|
||||
# Get ready to hold an election
|
||||
#self.dbenvMaster.rep_start(flags=db.DB_REP_MASTER)
|
||||
self.dbenvMaster.rep_start(flags=db.DB_REP_CLIENT)
|
||||
self.dbenvClient.rep_start(flags=db.DB_REP_CLIENT)
|
||||
|
||||
def thread_do(env, q, envid, election_status, must_be_master) :
|
||||
while True :
|
||||
v=q.get()
|
||||
if v is None : return
|
||||
r = env.rep_process_message(v[0],v[1],envid)
|
||||
if must_be_master and self.confirmed_master :
|
||||
self.dbenvMaster.rep_start(flags = db.DB_REP_MASTER)
|
||||
must_be_master = False
|
||||
|
||||
if r[0] == db.DB_REP_HOLDELECTION :
|
||||
def elect() :
|
||||
while True :
|
||||
try :
|
||||
env.rep_elect(2, 1)
|
||||
election_status[0] = False
|
||||
break
|
||||
except db.DBRepUnavailError :
|
||||
pass
|
||||
if not election_status[0] and not self.confirmed_master :
|
||||
from threading import Thread
|
||||
election_status[0] = True
|
||||
t=Thread(target=elect)
|
||||
import sys
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
|
||||
self.thread_do = thread_do
|
||||
|
||||
self.t_m.start()
|
||||
self.t_c.start()
|
||||
|
||||
self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 50000)
|
||||
self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 50000)
|
||||
self.client_doing_election[0] = True
|
||||
while True :
|
||||
try :
|
||||
self.dbenvClient.rep_elect(2, 1)
|
||||
self.client_doing_election[0] = False
|
||||
break
|
||||
except db.DBRepUnavailError :
|
||||
pass
|
||||
|
||||
self.assertTrue(self.confirmed_master)
|
||||
|
||||
# Race condition showed up after upgrading to Solaris 10 Update 10
|
||||
# https://forums.oracle.com/forums/thread.jspa?messageID=9902860
|
||||
# jcea@jcea.es: See private email from Paula Bingham (Oracle),
|
||||
# in 20110929.
|
||||
while not (self.dbenvClient.rep_stat()["startup_complete"]) :
|
||||
pass
|
||||
|
||||
if db.version() >= (4,7) :
|
||||
def test04_test_clockskew(self) :
|
||||
fast, slow = 1234, 1230
|
||||
self.dbenvMaster.rep_set_clockskew(fast, slow)
|
||||
self.assertEqual((fast, slow),
|
||||
self.dbenvMaster.rep_get_clockskew())
|
||||
self.basic_rep_threading()
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
if db.version() >= (4, 6) :
|
||||
dbenv = db.DBEnv()
|
||||
try :
|
||||
dbenv.repmgr_get_ack_policy()
|
||||
ReplicationManager_available=True
|
||||
except :
|
||||
ReplicationManager_available=False
|
||||
dbenv.close()
|
||||
del dbenv
|
||||
if ReplicationManager_available :
|
||||
suite.addTest(unittest.makeSuite(DBReplicationManager))
|
||||
|
||||
if have_threads :
|
||||
suite.addTest(unittest.makeSuite(DBBaseReplication))
|
||||
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
136
Lib/bsddb/test/test_sequence.py
Normal file
136
Lib/bsddb/test/test_sequence.py
Normal file
@@ -0,0 +1,136 @@
|
||||
import unittest
|
||||
import os
|
||||
|
||||
from test_all import db, test_support, get_new_environment_path, get_new_database_path
|
||||
|
||||
|
||||
class DBSequenceTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.int_32_max = 0x100000000
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.filename = "test"
|
||||
|
||||
self.dbenv = db.DBEnv()
|
||||
self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL, 0666)
|
||||
self.d = db.DB(self.dbenv)
|
||||
self.d.open(self.filename, db.DB_BTREE, db.DB_CREATE, 0666)
|
||||
|
||||
def tearDown(self):
|
||||
if hasattr(self, 'seq'):
|
||||
self.seq.close()
|
||||
del self.seq
|
||||
if hasattr(self, 'd'):
|
||||
self.d.close()
|
||||
del self.d
|
||||
if hasattr(self, 'dbenv'):
|
||||
self.dbenv.close()
|
||||
del self.dbenv
|
||||
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def test_get(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
start_value = 10 * self.int_32_max
|
||||
self.assertEqual(0xA00000000, start_value)
|
||||
self.assertEqual(None, self.seq.initial_value(start_value))
|
||||
self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(start_value, self.seq.get(5))
|
||||
self.assertEqual(start_value + 5, self.seq.get())
|
||||
|
||||
def test_remove(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(None, self.seq.remove(txn=None, flags=0))
|
||||
del self.seq
|
||||
|
||||
def test_get_key(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
key = 'foo'
|
||||
self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(key, self.seq.get_key())
|
||||
|
||||
def test_get_dbp(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(self.d, self.seq.get_dbp())
|
||||
|
||||
def test_cachesize(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
cashe_size = 10
|
||||
self.assertEqual(None, self.seq.set_cachesize(cashe_size))
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(cashe_size, self.seq.get_cachesize())
|
||||
|
||||
def test_flags(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
flag = db.DB_SEQ_WRAP;
|
||||
self.assertEqual(None, self.seq.set_flags(flag))
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(flag, self.seq.get_flags() & flag)
|
||||
|
||||
def test_range(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1)
|
||||
self.assertEqual(None, self.seq.set_range(seq_range))
|
||||
self.seq.initial_value(seq_range[0])
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
self.assertEqual(seq_range, self.seq.get_range())
|
||||
|
||||
def test_stat(self):
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
|
||||
stat = self.seq.stat()
|
||||
for param in ('nowait', 'min', 'max', 'value', 'current',
|
||||
'flags', 'cache_size', 'last_value', 'wait'):
|
||||
self.assertIn(param, stat, "parameter %s isn't in stat info" % param)
|
||||
|
||||
if db.version() >= (4,7) :
|
||||
# This code checks a crash solved in Berkeley DB 4.7
|
||||
def test_stat_crash(self) :
|
||||
d=db.DB()
|
||||
d.open(None,dbtype=db.DB_HASH,flags=db.DB_CREATE) # In RAM
|
||||
seq = db.DBSequence(d, flags=0)
|
||||
|
||||
self.assertRaises(db.DBNotFoundError, seq.open,
|
||||
key='id', txn=None, flags=0)
|
||||
|
||||
self.assertRaises(db.DBInvalidArgError, seq.stat)
|
||||
|
||||
d.close()
|
||||
|
||||
def test_64bits(self) :
|
||||
# We don't use both extremes because they are problematic
|
||||
value_plus=(1L<<63)-2
|
||||
self.assertEqual(9223372036854775806L,value_plus)
|
||||
value_minus=(-1L<<63)+1 # Two complement
|
||||
self.assertEqual(-9223372036854775807L,value_minus)
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
self.assertEqual(None, self.seq.initial_value(value_plus-1))
|
||||
self.assertEqual(None, self.seq.open(key='id', txn=None,
|
||||
flags=db.DB_CREATE))
|
||||
self.assertEqual(value_plus-1, self.seq.get(1))
|
||||
self.assertEqual(value_plus, self.seq.get(1))
|
||||
|
||||
self.seq.remove(txn=None, flags=0)
|
||||
|
||||
self.seq = db.DBSequence(self.d, flags=0)
|
||||
self.assertEqual(None, self.seq.initial_value(value_minus))
|
||||
self.assertEqual(None, self.seq.open(key='id', txn=None,
|
||||
flags=db.DB_CREATE))
|
||||
self.assertEqual(value_minus, self.seq.get(1))
|
||||
self.assertEqual(value_minus+1, self.seq.get(1))
|
||||
|
||||
def test_multiple_close(self):
|
||||
self.seq = db.DBSequence(self.d)
|
||||
self.seq.close() # You can close a Sequence multiple times
|
||||
self.seq.close()
|
||||
self.seq.close()
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(unittest.makeSuite(DBSequenceTest))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
517
Lib/bsddb/test/test_thread.py
Normal file
517
Lib/bsddb/test/test_thread.py
Normal file
@@ -0,0 +1,517 @@
|
||||
"""TestCases for multi-threaded access to a DB.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import errno
|
||||
from random import random
|
||||
|
||||
DASH = '-'
|
||||
|
||||
try:
|
||||
WindowsError
|
||||
except NameError:
|
||||
class WindowsError(Exception):
|
||||
pass
|
||||
|
||||
import unittest
|
||||
from test_all import db, dbutils, test_support, verbose, have_threads, \
|
||||
get_new_environment_path, get_new_database_path
|
||||
|
||||
if have_threads :
|
||||
from threading import Thread
|
||||
if sys.version_info[0] < 3 :
|
||||
from threading import currentThread
|
||||
else :
|
||||
from threading import current_thread as currentThread
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class BaseThreadedTestCase(unittest.TestCase):
|
||||
dbtype = db.DB_UNKNOWN # must be set in derived class
|
||||
dbopenflags = 0
|
||||
dbsetflags = 0
|
||||
envflags = 0
|
||||
|
||||
def setUp(self):
|
||||
if verbose:
|
||||
dbutils._deadlock_VerboseFile = sys.stdout
|
||||
|
||||
self.homeDir = get_new_environment_path()
|
||||
self.env = db.DBEnv()
|
||||
self.setEnvOpts()
|
||||
self.env.open(self.homeDir, self.envflags | db.DB_CREATE)
|
||||
|
||||
self.filename = self.__class__.__name__ + '.db'
|
||||
self.d = db.DB(self.env)
|
||||
if self.dbsetflags:
|
||||
self.d.set_flags(self.dbsetflags)
|
||||
self.d.open(self.filename, self.dbtype, self.dbopenflags|db.DB_CREATE)
|
||||
|
||||
def tearDown(self):
|
||||
self.d.close()
|
||||
self.env.close()
|
||||
test_support.rmtree(self.homeDir)
|
||||
|
||||
def setEnvOpts(self):
|
||||
pass
|
||||
|
||||
def makeData(self, key):
|
||||
return DASH.join([key] * 5)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
class ConcurrentDataStoreBase(BaseThreadedTestCase):
|
||||
dbopenflags = db.DB_THREAD
|
||||
envflags = db.DB_THREAD | db.DB_INIT_CDB | db.DB_INIT_MPOOL
|
||||
readers = 0 # derived class should set
|
||||
writers = 0
|
||||
records = 1000
|
||||
|
||||
def test01_1WriterMultiReaders(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test01_1WriterMultiReaders..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
keys=range(self.records)
|
||||
import random
|
||||
random.shuffle(keys)
|
||||
records_per_writer=self.records//self.writers
|
||||
readers_per_writer=self.readers//self.writers
|
||||
self.assertEqual(self.records,self.writers*records_per_writer)
|
||||
self.assertEqual(self.readers,self.writers*readers_per_writer)
|
||||
self.assertEqual(records_per_writer%readers_per_writer, 0)
|
||||
readers = []
|
||||
|
||||
for x in xrange(self.readers):
|
||||
rt = Thread(target = self.readerThread,
|
||||
args = (self.d, x),
|
||||
name = 'reader %d' % x,
|
||||
)#verbose = verbose)
|
||||
if sys.version_info[0] < 3 :
|
||||
rt.setDaemon(True)
|
||||
else :
|
||||
rt.daemon = True
|
||||
readers.append(rt)
|
||||
|
||||
writers=[]
|
||||
for x in xrange(self.writers):
|
||||
a=keys[records_per_writer*x:records_per_writer*(x+1)]
|
||||
a.sort() # Generate conflicts
|
||||
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
|
||||
wt = Thread(target = self.writerThread,
|
||||
args = (self.d, a, b),
|
||||
name = 'writer %d' % x,
|
||||
)#verbose = verbose)
|
||||
writers.append(wt)
|
||||
|
||||
for t in writers:
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
|
||||
for t in writers:
|
||||
t.join()
|
||||
for t in readers:
|
||||
t.join()
|
||||
|
||||
def writerThread(self, d, keys, readers):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
if verbose:
|
||||
print "%s: creating records %d - %d" % (name, start, stop)
|
||||
|
||||
count=len(keys)//len(readers)
|
||||
count2=count
|
||||
for x in keys :
|
||||
key = '%04d' % x
|
||||
dbutils.DeadlockWrap(d.put, key, self.makeData(key),
|
||||
max_retries=12)
|
||||
if verbose and x % 100 == 0:
|
||||
print "%s: records %d - %d finished" % (name, start, x)
|
||||
|
||||
count2-=1
|
||||
if not count2 :
|
||||
readers.pop().start()
|
||||
count2=count
|
||||
|
||||
if verbose:
|
||||
print "%s: finished creating records" % name
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
def readerThread(self, d, readerNum):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
for i in xrange(5) :
|
||||
c = d.cursor()
|
||||
count = 0
|
||||
rec = c.first()
|
||||
while rec:
|
||||
count += 1
|
||||
key, data = rec
|
||||
self.assertEqual(self.makeData(key), data)
|
||||
rec = c.next()
|
||||
if verbose:
|
||||
print "%s: found %d records" % (name, count)
|
||||
c.close()
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
|
||||
class BTreeConcurrentDataStore(ConcurrentDataStoreBase):
|
||||
dbtype = db.DB_BTREE
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
|
||||
|
||||
class HashConcurrentDataStore(ConcurrentDataStoreBase):
|
||||
dbtype = db.DB_HASH
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class SimpleThreadedBase(BaseThreadedTestCase):
|
||||
dbopenflags = db.DB_THREAD
|
||||
envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
|
||||
readers = 10
|
||||
writers = 2
|
||||
records = 1000
|
||||
|
||||
def setEnvOpts(self):
|
||||
self.env.set_lk_detect(db.DB_LOCK_DEFAULT)
|
||||
|
||||
def test02_SimpleLocks(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test02_SimpleLocks..." % self.__class__.__name__
|
||||
|
||||
|
||||
keys=range(self.records)
|
||||
import random
|
||||
random.shuffle(keys)
|
||||
records_per_writer=self.records//self.writers
|
||||
readers_per_writer=self.readers//self.writers
|
||||
self.assertEqual(self.records,self.writers*records_per_writer)
|
||||
self.assertEqual(self.readers,self.writers*readers_per_writer)
|
||||
self.assertEqual(records_per_writer%readers_per_writer, 0)
|
||||
|
||||
readers = []
|
||||
for x in xrange(self.readers):
|
||||
rt = Thread(target = self.readerThread,
|
||||
args = (self.d, x),
|
||||
name = 'reader %d' % x,
|
||||
)#verbose = verbose)
|
||||
if sys.version_info[0] < 3 :
|
||||
rt.setDaemon(True)
|
||||
else :
|
||||
rt.daemon = True
|
||||
readers.append(rt)
|
||||
|
||||
writers = []
|
||||
for x in xrange(self.writers):
|
||||
a=keys[records_per_writer*x:records_per_writer*(x+1)]
|
||||
a.sort() # Generate conflicts
|
||||
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
|
||||
wt = Thread(target = self.writerThread,
|
||||
args = (self.d, a, b),
|
||||
name = 'writer %d' % x,
|
||||
)#verbose = verbose)
|
||||
writers.append(wt)
|
||||
|
||||
for t in writers:
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
|
||||
for t in writers:
|
||||
t.join()
|
||||
for t in readers:
|
||||
t.join()
|
||||
|
||||
def writerThread(self, d, keys, readers):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
if verbose:
|
||||
print "%s: creating records %d - %d" % (name, start, stop)
|
||||
|
||||
count=len(keys)//len(readers)
|
||||
count2=count
|
||||
for x in keys :
|
||||
key = '%04d' % x
|
||||
dbutils.DeadlockWrap(d.put, key, self.makeData(key),
|
||||
max_retries=12)
|
||||
|
||||
if verbose and x % 100 == 0:
|
||||
print "%s: records %d - %d finished" % (name, start, x)
|
||||
|
||||
count2-=1
|
||||
if not count2 :
|
||||
readers.pop().start()
|
||||
count2=count
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
def readerThread(self, d, readerNum):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
c = d.cursor()
|
||||
count = 0
|
||||
rec = dbutils.DeadlockWrap(c.first, max_retries=10)
|
||||
while rec:
|
||||
count += 1
|
||||
key, data = rec
|
||||
self.assertEqual(self.makeData(key), data)
|
||||
rec = dbutils.DeadlockWrap(c.next, max_retries=10)
|
||||
if verbose:
|
||||
print "%s: found %d records" % (name, count)
|
||||
c.close()
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
|
||||
class BTreeSimpleThreaded(SimpleThreadedBase):
|
||||
dbtype = db.DB_BTREE
|
||||
|
||||
|
||||
class HashSimpleThreaded(SimpleThreadedBase):
|
||||
dbtype = db.DB_HASH
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
class ThreadedTransactionsBase(BaseThreadedTestCase):
|
||||
dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT
|
||||
envflags = (db.DB_THREAD |
|
||||
db.DB_INIT_MPOOL |
|
||||
db.DB_INIT_LOCK |
|
||||
db.DB_INIT_LOG |
|
||||
db.DB_INIT_TXN
|
||||
)
|
||||
readers = 0
|
||||
writers = 0
|
||||
records = 2000
|
||||
txnFlag = 0
|
||||
|
||||
def setEnvOpts(self):
|
||||
#self.env.set_lk_detect(db.DB_LOCK_DEFAULT)
|
||||
pass
|
||||
|
||||
def test03_ThreadedTransactions(self):
|
||||
if verbose:
|
||||
print '\n', '-=' * 30
|
||||
print "Running %s.test03_ThreadedTransactions..." % \
|
||||
self.__class__.__name__
|
||||
|
||||
keys=range(self.records)
|
||||
import random
|
||||
random.shuffle(keys)
|
||||
records_per_writer=self.records//self.writers
|
||||
readers_per_writer=self.readers//self.writers
|
||||
self.assertEqual(self.records,self.writers*records_per_writer)
|
||||
self.assertEqual(self.readers,self.writers*readers_per_writer)
|
||||
self.assertEqual(records_per_writer%readers_per_writer, 0)
|
||||
|
||||
readers=[]
|
||||
for x in xrange(self.readers):
|
||||
rt = Thread(target = self.readerThread,
|
||||
args = (self.d, x),
|
||||
name = 'reader %d' % x,
|
||||
)#verbose = verbose)
|
||||
if sys.version_info[0] < 3 :
|
||||
rt.setDaemon(True)
|
||||
else :
|
||||
rt.daemon = True
|
||||
readers.append(rt)
|
||||
|
||||
writers = []
|
||||
for x in xrange(self.writers):
|
||||
a=keys[records_per_writer*x:records_per_writer*(x+1)]
|
||||
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
|
||||
wt = Thread(target = self.writerThread,
|
||||
args = (self.d, a, b),
|
||||
name = 'writer %d' % x,
|
||||
)#verbose = verbose)
|
||||
writers.append(wt)
|
||||
|
||||
dt = Thread(target = self.deadlockThread)
|
||||
if sys.version_info[0] < 3 :
|
||||
dt.setDaemon(True)
|
||||
else :
|
||||
dt.daemon = True
|
||||
dt.start()
|
||||
|
||||
for t in writers:
|
||||
if sys.version_info[0] < 3 :
|
||||
t.setDaemon(True)
|
||||
else :
|
||||
t.daemon = True
|
||||
t.start()
|
||||
|
||||
for t in writers:
|
||||
t.join()
|
||||
for t in readers:
|
||||
t.join()
|
||||
|
||||
self.doLockDetect = False
|
||||
dt.join()
|
||||
|
||||
def writerThread(self, d, keys, readers):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
count=len(keys)//len(readers)
|
||||
while len(keys):
|
||||
try:
|
||||
txn = self.env.txn_begin(None, self.txnFlag)
|
||||
keys2=keys[:count]
|
||||
for x in keys2 :
|
||||
key = '%04d' % x
|
||||
d.put(key, self.makeData(key), txn)
|
||||
if verbose and x % 100 == 0:
|
||||
print "%s: records %d - %d finished" % (name, start, x)
|
||||
txn.commit()
|
||||
keys=keys[count:]
|
||||
readers.pop().start()
|
||||
except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
|
||||
if verbose:
|
||||
if sys.version_info < (2, 6) :
|
||||
print "%s: Aborting transaction (%s)" % (name, val[1])
|
||||
else :
|
||||
print "%s: Aborting transaction (%s)" % (name,
|
||||
val.args[1])
|
||||
txn.abort()
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
def readerThread(self, d, readerNum):
|
||||
if sys.version_info[0] < 3 :
|
||||
name = currentThread().getName()
|
||||
else :
|
||||
name = currentThread().name
|
||||
|
||||
finished = False
|
||||
while not finished:
|
||||
try:
|
||||
txn = self.env.txn_begin(None, self.txnFlag)
|
||||
c = d.cursor(txn)
|
||||
count = 0
|
||||
rec = c.first()
|
||||
while rec:
|
||||
count += 1
|
||||
key, data = rec
|
||||
self.assertEqual(self.makeData(key), data)
|
||||
rec = c.next()
|
||||
if verbose: print "%s: found %d records" % (name, count)
|
||||
c.close()
|
||||
txn.commit()
|
||||
finished = True
|
||||
except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
|
||||
if verbose:
|
||||
if sys.version_info < (2, 6) :
|
||||
print "%s: Aborting transaction (%s)" % (name, val[1])
|
||||
else :
|
||||
print "%s: Aborting transaction (%s)" % (name,
|
||||
val.args[1])
|
||||
c.close()
|
||||
txn.abort()
|
||||
|
||||
if verbose:
|
||||
print "%s: thread finished" % name
|
||||
|
||||
def deadlockThread(self):
|
||||
self.doLockDetect = True
|
||||
while self.doLockDetect:
|
||||
time.sleep(0.05)
|
||||
try:
|
||||
aborted = self.env.lock_detect(
|
||||
db.DB_LOCK_RANDOM, db.DB_LOCK_CONFLICT)
|
||||
if verbose and aborted:
|
||||
print "deadlock: Aborted %d deadlocked transaction(s)" \
|
||||
% aborted
|
||||
except db.DBError:
|
||||
pass
|
||||
|
||||
|
||||
class BTreeThreadedTransactions(ThreadedTransactionsBase):
|
||||
dbtype = db.DB_BTREE
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
|
||||
class HashThreadedTransactions(ThreadedTransactionsBase):
|
||||
dbtype = db.DB_HASH
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
|
||||
class BTreeThreadedNoWaitTransactions(ThreadedTransactionsBase):
|
||||
dbtype = db.DB_BTREE
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
txnFlag = db.DB_TXN_NOWAIT
|
||||
|
||||
class HashThreadedNoWaitTransactions(ThreadedTransactionsBase):
|
||||
dbtype = db.DB_HASH
|
||||
writers = 2
|
||||
readers = 10
|
||||
records = 1000
|
||||
txnFlag = db.DB_TXN_NOWAIT
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
if have_threads:
|
||||
suite.addTest(unittest.makeSuite(BTreeConcurrentDataStore))
|
||||
suite.addTest(unittest.makeSuite(HashConcurrentDataStore))
|
||||
suite.addTest(unittest.makeSuite(BTreeSimpleThreaded))
|
||||
suite.addTest(unittest.makeSuite(HashSimpleThreaded))
|
||||
suite.addTest(unittest.makeSuite(BTreeThreadedTransactions))
|
||||
suite.addTest(unittest.makeSuite(HashThreadedTransactions))
|
||||
suite.addTest(unittest.makeSuite(BTreeThreadedNoWaitTransactions))
|
||||
suite.addTest(unittest.makeSuite(HashThreadedNoWaitTransactions))
|
||||
|
||||
else:
|
||||
print "Threads not available, skipping thread tests."
|
||||
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(defaultTest='test_suite')
|
||||
Reference in New Issue
Block a user