From 0a7ac7d70d370544c6a9d118bbbd6886ad4f5ce5 Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Mon, 26 May 2008 10:29:35 +0000 Subject: Create the dbm package from PEP 3108. #2881. --- Lib/test/test___all__.py | 2 +- Lib/test/test_anydbm.py | 90 +++++++++++++--------- Lib/test/test_bsddb.py | 2 +- Lib/test/test_dbm.py | 40 ---------- Lib/test/test_dbm_dumb.py | 185 ++++++++++++++++++++++++++++++++++++++++++++++ Lib/test/test_dbm_gnu.py | 81 ++++++++++++++++++++ Lib/test/test_dbm_ndbm.py | 40 ++++++++++ Lib/test/test_dumbdbm.py | 185 ---------------------------------------------- Lib/test/test_gdbm.py | 81 -------------------- Lib/test/test_whichdb.py | 58 --------------- 10 files changed, 362 insertions(+), 402 deletions(-) delete mode 100755 Lib/test/test_dbm.py create mode 100644 Lib/test/test_dbm_dumb.py create mode 100755 Lib/test/test_dbm_gnu.py create mode 100755 Lib/test/test_dbm_ndbm.py delete mode 100644 Lib/test/test_dumbdbm.py delete mode 100755 Lib/test/test_gdbm.py delete mode 100644 Lib/test/test_whichdb.py (limited to 'Lib/test') diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index 615f6c5a1e..ed8d8d9c80 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -57,7 +57,7 @@ class AllTest(unittest.TestCase): self.check_all("copy") self.check_all("copyreg") self.check_all("csv") - self.check_all("dbhash") + self.check_all("dbm.bsd") self.check_all("decimal") self.check_all("difflib") self.check_all("dircache") diff --git a/Lib/test/test_anydbm.py b/Lib/test/test_anydbm.py index ace9dd207c..aab1388d79 100644 --- a/Lib/test/test_anydbm.py +++ b/Lib/test/test_anydbm.py @@ -1,50 +1,34 @@ #! /usr/bin/env python -"""Test script for the anydbm module - based on testdumbdbm.py -""" +"""Test script for the dbm.open function based on testdumbdbm.py""" import os import unittest -import anydbm +import dbm import glob -from test import support - -_fname = support.TESTFN - -_all_modules = [] - -for _name in anydbm._names: - try: - _module = __import__(_name) - except ImportError: - continue - _all_modules.append(_module) +import test.support +_fname = test.support.TESTFN # -# Iterates over every database module supported by anydbm -# currently available, setting anydbm to use each in turn, -# and yielding that module +# Iterates over every database module supported by dbm currently available, +# setting dbm to use each in turn, and yielding that module # def dbm_iterator(): - old_default = anydbm._defaultmod - for module in _all_modules: - anydbm._defaultmod = module + old_default = dbm._defaultmod + for module in dbm._modules.values(): + dbm._defaultmod = module yield module - anydbm._defaultmod = old_default + dbm._defaultmod = old_default # -# Clean up all scratch databases we might have created -# during testing +# Clean up all scratch databases we might have created during testing # def delete_files(): # we don't know the precise name the underlying database uses # so we use glob to locate all names for f in glob.glob(_fname + "*"): - try: - os.unlink(f) - except OSError: - pass + test.support.unlink(f) + class AnyDBMTestCase(unittest.TestCase): _dict = {'0': b'', @@ -60,7 +44,7 @@ class AnyDBMTestCase(unittest.TestCase): unittest.TestCase.__init__(self, *args) def test_anydbm_creation(self): - f = anydbm.open(_fname, 'c') + f = dbm.open(_fname, 'c') self.assertEqual(list(f.keys()), []) for key in self._dict: f[key.encode("ascii")] = self._dict[key] @@ -69,26 +53,26 @@ class AnyDBMTestCase(unittest.TestCase): def test_anydbm_modification(self): self.init_db() - f = anydbm.open(_fname, 'c') + f = dbm.open(_fname, 'c') self._dict['g'] = f[b'g'] = b"indented" self.read_helper(f) f.close() def test_anydbm_read(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') self.read_helper(f) f.close() def test_anydbm_keys(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') keys = self.keys_helper(f) f.close() def test_anydbm_access(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') key = "a".encode("ascii") assert(key in f) assert(f[key] == b"Python:") @@ -100,7 +84,7 @@ class AnyDBMTestCase(unittest.TestCase): self.assertEqual(self._dict[key], f[key.encode("ascii")]) def init_db(self): - f = anydbm.open(_fname, 'n') + f = dbm.open(_fname, 'n') for k in self._dict: f[k.encode("ascii")] = self._dict[k] f.close() @@ -118,10 +102,44 @@ class AnyDBMTestCase(unittest.TestCase): delete_files() +class WhichDBTestCase(unittest.TestCase): + # Actual test methods are added to namespace after class definition. + def __init__(self, *args): + unittest.TestCase.__init__(self, *args) + + def test_whichdb(self): + for module in dbm_iterator(): + # Check whether whichdb correctly guesses module name + # for databases opened with "module" module. + # Try with empty files first + name = module.__name__ + if name == 'dbm.dumb': + continue # whichdb can't support dbm.dumb + test.support.unlink(_fname) + f = module.open(_fname, 'c') + f.close() + self.assertEqual(name, dbm.whichdb(_fname)) + # Now add a key + f = module.open(_fname, 'w') + f[b"1"] = b"1" + # and test that we can find it + self.assertTrue(b"1" in f) + # and read it + self.assertTrue(f[b"1"] == b"1") + f.close() + self.assertEqual(name, dbm.whichdb(_fname)) + + def tearDown(self): + delete_files() + + def setUp(self): + delete_files() + + def test_main(): try: for module in dbm_iterator(): - support.run_unittest(AnyDBMTestCase) + test.support.run_unittest(AnyDBMTestCase, WhichDBTestCase) finally: delete_files() diff --git a/Lib/test/test_bsddb.py b/Lib/test/test_bsddb.py index 3eb291f3a9..a722d8ca9d 100755 --- a/Lib/test/test_bsddb.py +++ b/Lib/test/test_bsddb.py @@ -5,7 +5,7 @@ import os, sys import copy import bsddb -import dbhash # Just so we know it's imported +import dbm.bsd # Just so we know it's imported import unittest from test import support diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py deleted file mode 100755 index 2c6ce9902a..0000000000 --- a/Lib/test/test_dbm.py +++ /dev/null @@ -1,40 +0,0 @@ -from test import support -import unittest -import os -import random -import dbm -from dbm import error - -class DbmTestCase(unittest.TestCase): - - def setUp(self): - self.filename = support.TESTFN - self.d = dbm.open(self.filename, 'c') - self.d.close() - - def tearDown(self): - for suffix in ['', '.pag', '.dir', '.db']: - support.unlink(self.filename + suffix) - - def test_keys(self): - self.d = dbm.open(self.filename, 'c') - self.assert_(self.d.keys() == []) - self.d['a'] = 'b' - self.d['12345678910'] = '019237410982340912840198242' - self.d.keys() - self.assert_(b'a' in self.d) - self.d.close() - - def test_modes(self): - for mode in ['r', 'rw', 'w', 'n']: - try: - self.d = dbm.open(self.filename, mode) - self.d.close() - except dbm.error: - self.fail() - -def test_main(): - support.run_unittest(DbmTestCase) - -if __name__ == '__main__': - test_main() diff --git a/Lib/test/test_dbm_dumb.py b/Lib/test/test_dbm_dumb.py new file mode 100644 index 0000000000..9bdc240637 --- /dev/null +++ b/Lib/test/test_dbm_dumb.py @@ -0,0 +1,185 @@ +#! /usr/bin/env python +"""Test script for the dumbdbm module + Original by Roger E. Masse +""" + +import io +import os +import unittest +import dbm.dumb as dumbdbm +from test import support + +_fname = support.TESTFN + +def _delete_files(): + for ext in [".dir", ".dat", ".bak"]: + try: + os.unlink(_fname + ext) + except OSError: + pass + +class DumbDBMTestCase(unittest.TestCase): + _dict = {'0': b'', + 'a': b'Python:', + 'b': b'Programming', + 'c': b'the', + 'd': b'way', + 'f': b'Guido', + 'g': b'intended', + } + + def __init__(self, *args): + unittest.TestCase.__init__(self, *args) + + def test_dumbdbm_creation(self): + f = dumbdbm.open(_fname, 'c') + self.assertEqual(list(f.keys()), []) + for key in self._dict: + f[key.encode("ascii")] = self._dict[key] + self.read_helper(f) + f.close() + + def test_dumbdbm_creation_mode(self): + # On platforms without chmod, don't do anything. + if not (hasattr(os, 'chmod') and hasattr(os, 'umask')): + return + + try: + old_umask = os.umask(0o002) + f = dumbdbm.open(_fname, 'c', 0o637) + f.close() + finally: + os.umask(old_umask) + + expected_mode = 0o635 + if os.name != 'posix': + # Windows only supports setting the read-only attribute. + # This shouldn't fail, but doesn't work like Unix either. + expected_mode = 0o666 + + import stat + st = os.stat(_fname + '.dat') + self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) + st = os.stat(_fname + '.dir') + self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) + + def test_close_twice(self): + f = dumbdbm.open(_fname) + f[b'a'] = b'b' + self.assertEqual(f[b'a'], b'b') + f.close() + f.close() + + def test_dumbdbm_modification(self): + self.init_db() + f = dumbdbm.open(_fname, 'w') + self._dict['g'] = f[b'g'] = b"indented" + self.read_helper(f) + f.close() + + def test_dumbdbm_read(self): + self.init_db() + f = dumbdbm.open(_fname, 'r') + self.read_helper(f) + f.close() + + def test_dumbdbm_keys(self): + self.init_db() + f = dumbdbm.open(_fname) + keys = self.keys_helper(f) + f.close() + + def test_write_contains(self): + f = dumbdbm.open(_fname) + f[b'1'] = b'hello' + self.assertTrue(b'1' in f) + f.close() + + def test_write_write_read(self): + # test for bug #482460 + f = dumbdbm.open(_fname) + f[b'1'] = b'hello' + f[b'1'] = b'hello2' + f.close() + f = dumbdbm.open(_fname) + self.assertEqual(f[b'1'], b'hello2') + f.close() + + def test_line_endings(self): + # test for bug #1172763: dumbdbm would die if the line endings + # weren't what was expected. + f = dumbdbm.open(_fname) + f[b'1'] = b'hello' + f[b'2'] = b'hello2' + f.close() + + # Mangle the file by changing the line separator to Windows or Unix + data = io.open(_fname + '.dir', 'rb').read() + if os.linesep == '\n': + data = data.replace(b'\n', b'\r\n') + else: + data = data.replace(b'\r\n', b'\n') + io.open(_fname + '.dir', 'wb').write(data) + + f = dumbdbm.open(_fname) + self.assertEqual(f[b'1'], b'hello') + self.assertEqual(f[b'2'], b'hello2') + + + def read_helper(self, f): + keys = self.keys_helper(f) + for key in self._dict: + self.assertEqual(self._dict[key], f[key.encode("ascii")]) + + def init_db(self): + f = dumbdbm.open(_fname, 'w') + for k in self._dict: + f[k.encode("ascii")] = self._dict[k] + f.close() + + def keys_helper(self, f): + keys = sorted(k.decode("ascii") for k in f.keys()) + dkeys = sorted(self._dict.keys()) + self.assertEqual(keys, dkeys) + return keys + + # Perform randomized operations. This doesn't make assumptions about + # what *might* fail. + def test_random(self): + import random + d = {} # mirror the database + for dummy in range(5): + f = dumbdbm.open(_fname) + for dummy in range(100): + k = random.choice('abcdefghijklm') + if random.random() < 0.2: + if k in d: + del d[k] + del f[k.encode("ascii")] + else: + v = random.choice((b'a', b'b', b'c')) * random.randrange(10000) + d[k] = v + f[k.encode("ascii")] = v + self.assertEqual(f[k.encode("ascii")], v) + f.close() + + f = dumbdbm.open(_fname) + expected = sorted((k.encode("latin-1"), v) for k, v in d.items()) + got = sorted(f.items()) + self.assertEqual(expected, got) + f.close() + + def tearDown(self): + _delete_files() + + def setUp(self): + _delete_files() + +def test_main(): + try: + support.run_unittest(DumbDBMTestCase) + finally: + _delete_files() + +if __name__ == "__main__": + test_main() diff --git a/Lib/test/test_dbm_gnu.py b/Lib/test/test_dbm_gnu.py new file mode 100755 index 0000000000..eddb970831 --- /dev/null +++ b/Lib/test/test_dbm_gnu.py @@ -0,0 +1,81 @@ +import dbm.gnu as gdbm +import unittest +import os +from test.support import verbose, TESTFN, run_unittest, unlink + + +filename = TESTFN + +class TestGdbm(unittest.TestCase): + def setUp(self): + self.g = None + + def tearDown(self): + if self.g is not None: + self.g.close() + unlink(filename) + + def test_key_methods(self): + self.g = gdbm.open(filename, 'c') + self.assertEqual(self.g.keys(), []) + self.g['a'] = 'b' + self.g['12345678910'] = '019237410982340912840198242' + key_set = set(self.g.keys()) + self.assertEqual(key_set, set([b'a', b'12345678910'])) + self.assert_(b'a' in self.g) + key = self.g.firstkey() + while key: + self.assert_(key in key_set) + key_set.remove(key) + key = self.g.nextkey(key) + self.assertRaises(KeyError, lambda: self.g['xxx']) + + def test_error_conditions(self): + # Try to open a non-existent database. + unlink(filename) + self.assertRaises(gdbm.error, gdbm.open, filename, 'r') + # Try to access a closed database. + self.g = gdbm.open(filename, 'c') + self.g.close() + self.assertRaises(gdbm.error, lambda: self.g['a']) + # try pass an invalid open flag + self.assertRaises(gdbm.error, lambda: gdbm.open(filename, 'rx').close()) + + def test_flags(self): + # Test the flag parameter open() by trying all supported flag modes. + all = set(gdbm.open_flags) + # Test standard flags (presumably "crwn"). + modes = all - set('fsu') + for mode in modes: + self.g = gdbm.open(filename, mode) + self.g.close() + + # Test additional flags (presumably "fsu"). + flags = all - set('crwn') + for mode in modes: + for flag in flags: + self.g = gdbm.open(filename, mode + flag) + self.g.close() + + def test_reorganize(self): + self.g = gdbm.open(filename, 'c') + size0 = os.path.getsize(filename) + + self.g['x'] = 'x' * 10000 + size1 = os.path.getsize(filename) + self.assert_(size0 < size1) + + del self.g['x'] + # 'size' is supposed to be the same even after deleting an entry. + self.assertEqual(os.path.getsize(filename), size1) + + self.g.reorganize() + size2 = os.path.getsize(filename) + self.assert_(size1 > size2 >= size0) + + +def test_main(): + run_unittest(TestGdbm) + +if __name__ == '__main__': + test_main() diff --git a/Lib/test/test_dbm_ndbm.py b/Lib/test/test_dbm_ndbm.py new file mode 100755 index 0000000000..74d32386ae --- /dev/null +++ b/Lib/test/test_dbm_ndbm.py @@ -0,0 +1,40 @@ +from test import support +import unittest +import os +import random +import dbm.ndbm +from dbm.ndbm import error + +class DbmTestCase(unittest.TestCase): + + def setUp(self): + self.filename = support.TESTFN + self.d = dbm.ndbm.open(self.filename, 'c') + self.d.close() + + def tearDown(self): + for suffix in ['', '.pag', '.dir', '.db']: + support.unlink(self.filename + suffix) + + def test_keys(self): + self.d = dbm.ndbm.open(self.filename, 'c') + self.assert_(self.d.keys() == []) + self.d['a'] = 'b' + self.d['12345678910'] = '019237410982340912840198242' + self.d.keys() + self.assert_(b'a' in self.d) + self.d.close() + + def test_modes(self): + for mode in ['r', 'rw', 'w', 'n']: + try: + self.d = dbm.ndbm.open(self.filename, mode) + self.d.close() + except error: + self.fail() + +def test_main(): + support.run_unittest(DbmTestCase) + +if __name__ == '__main__': + test_main() diff --git a/Lib/test/test_dumbdbm.py b/Lib/test/test_dumbdbm.py deleted file mode 100644 index 24c178ffd9..0000000000 --- a/Lib/test/test_dumbdbm.py +++ /dev/null @@ -1,185 +0,0 @@ -#! /usr/bin/env python -"""Test script for the dumbdbm module - Original by Roger E. Masse -""" - -import io -import os -import unittest -import dumbdbm -from test import support - -_fname = support.TESTFN - -def _delete_files(): - for ext in [".dir", ".dat", ".bak"]: - try: - os.unlink(_fname + ext) - except OSError: - pass - -class DumbDBMTestCase(unittest.TestCase): - _dict = {'0': b'', - 'a': b'Python:', - 'b': b'Programming', - 'c': b'the', - 'd': b'way', - 'f': b'Guido', - 'g': b'intended', - } - - def __init__(self, *args): - unittest.TestCase.__init__(self, *args) - - def test_dumbdbm_creation(self): - f = dumbdbm.open(_fname, 'c') - self.assertEqual(list(f.keys()), []) - for key in self._dict: - f[key.encode("ascii")] = self._dict[key] - self.read_helper(f) - f.close() - - def test_dumbdbm_creation_mode(self): - # On platforms without chmod, don't do anything. - if not (hasattr(os, 'chmod') and hasattr(os, 'umask')): - return - - try: - old_umask = os.umask(0o002) - f = dumbdbm.open(_fname, 'c', 0o637) - f.close() - finally: - os.umask(old_umask) - - expected_mode = 0o635 - if os.name != 'posix': - # Windows only supports setting the read-only attribute. - # This shouldn't fail, but doesn't work like Unix either. - expected_mode = 0o666 - - import stat - st = os.stat(_fname + '.dat') - self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) - st = os.stat(_fname + '.dir') - self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) - - def test_close_twice(self): - f = dumbdbm.open(_fname) - f[b'a'] = b'b' - self.assertEqual(f[b'a'], b'b') - f.close() - f.close() - - def test_dumbdbm_modification(self): - self.init_db() - f = dumbdbm.open(_fname, 'w') - self._dict['g'] = f[b'g'] = b"indented" - self.read_helper(f) - f.close() - - def test_dumbdbm_read(self): - self.init_db() - f = dumbdbm.open(_fname, 'r') - self.read_helper(f) - f.close() - - def test_dumbdbm_keys(self): - self.init_db() - f = dumbdbm.open(_fname) - keys = self.keys_helper(f) - f.close() - - def test_write_contains(self): - f = dumbdbm.open(_fname) - f[b'1'] = b'hello' - self.assertTrue(b'1' in f) - f.close() - - def test_write_write_read(self): - # test for bug #482460 - f = dumbdbm.open(_fname) - f[b'1'] = b'hello' - f[b'1'] = b'hello2' - f.close() - f = dumbdbm.open(_fname) - self.assertEqual(f[b'1'], b'hello2') - f.close() - - def test_line_endings(self): - # test for bug #1172763: dumbdbm would die if the line endings - # weren't what was expected. - f = dumbdbm.open(_fname) - f[b'1'] = b'hello' - f[b'2'] = b'hello2' - f.close() - - # Mangle the file by changing the line separator to Windows or Unix - data = io.open(_fname + '.dir', 'rb').read() - if os.linesep == '\n': - data = data.replace(b'\n', b'\r\n') - else: - data = data.replace(b'\r\n', b'\n') - io.open(_fname + '.dir', 'wb').write(data) - - f = dumbdbm.open(_fname) - self.assertEqual(f[b'1'], b'hello') - self.assertEqual(f[b'2'], b'hello2') - - - def read_helper(self, f): - keys = self.keys_helper(f) - for key in self._dict: - self.assertEqual(self._dict[key], f[key.encode("ascii")]) - - def init_db(self): - f = dumbdbm.open(_fname, 'w') - for k in self._dict: - f[k.encode("ascii")] = self._dict[k] - f.close() - - def keys_helper(self, f): - keys = sorted(k.decode("ascii") for k in f.keys()) - dkeys = sorted(self._dict.keys()) - self.assertEqual(keys, dkeys) - return keys - - # Perform randomized operations. This doesn't make assumptions about - # what *might* fail. - def test_random(self): - import random - d = {} # mirror the database - for dummy in range(5): - f = dumbdbm.open(_fname) - for dummy in range(100): - k = random.choice('abcdefghijklm') - if random.random() < 0.2: - if k in d: - del d[k] - del f[k.encode("ascii")] - else: - v = random.choice((b'a', b'b', b'c')) * random.randrange(10000) - d[k] = v - f[k.encode("ascii")] = v - self.assertEqual(f[k.encode("ascii")], v) - f.close() - - f = dumbdbm.open(_fname) - expected = sorted((k.encode("latin-1"), v) for k, v in d.items()) - got = sorted(f.items()) - self.assertEqual(expected, got) - f.close() - - def tearDown(self): - _delete_files() - - def setUp(self): - _delete_files() - -def test_main(): - try: - support.run_unittest(DumbDBMTestCase) - finally: - _delete_files() - -if __name__ == "__main__": - test_main() diff --git a/Lib/test/test_gdbm.py b/Lib/test/test_gdbm.py deleted file mode 100755 index 42cb136ac5..0000000000 --- a/Lib/test/test_gdbm.py +++ /dev/null @@ -1,81 +0,0 @@ -import gdbm -import unittest -import os -from test.support import verbose, TESTFN, run_unittest, unlink - - -filename = TESTFN - -class TestGdbm(unittest.TestCase): - def setUp(self): - self.g = None - - def tearDown(self): - if self.g is not None: - self.g.close() - unlink(filename) - - def test_key_methods(self): - self.g = gdbm.open(filename, 'c') - self.assertEqual(self.g.keys(), []) - self.g['a'] = 'b' - self.g['12345678910'] = '019237410982340912840198242' - key_set = set(self.g.keys()) - self.assertEqual(key_set, set([b'a', b'12345678910'])) - self.assert_(b'a' in self.g) - key = self.g.firstkey() - while key: - self.assert_(key in key_set) - key_set.remove(key) - key = self.g.nextkey(key) - self.assertRaises(KeyError, lambda: self.g['xxx']) - - def test_error_conditions(self): - # Try to open a non-existent database. - unlink(filename) - self.assertRaises(gdbm.error, gdbm.open, filename, 'r') - # Try to access a closed database. - self.g = gdbm.open(filename, 'c') - self.g.close() - self.assertRaises(gdbm.error, lambda: self.g['a']) - # try pass an invalid open flag - self.assertRaises(gdbm.error, lambda: gdbm.open(filename, 'rx').close()) - - def test_flags(self): - # Test the flag parameter open() by trying all supported flag modes. - all = set(gdbm.open_flags) - # Test standard flags (presumably "crwn"). - modes = all - set('fsu') - for mode in modes: - self.g = gdbm.open(filename, mode) - self.g.close() - - # Test additional flags (presumably "fsu"). - flags = all - set('crwn') - for mode in modes: - for flag in flags: - self.g = gdbm.open(filename, mode + flag) - self.g.close() - - def test_reorganize(self): - self.g = gdbm.open(filename, 'c') - size0 = os.path.getsize(filename) - - self.g['x'] = 'x' * 10000 - size1 = os.path.getsize(filename) - self.assert_(size0 < size1) - - del self.g['x'] - # 'size' is supposed to be the same even after deleting an entry. - self.assertEqual(os.path.getsize(filename), size1) - - self.g.reorganize() - size2 = os.path.getsize(filename) - self.assert_(size1 > size2 >= size0) - - -def test_main(): - run_unittest(TestGdbm) - -if __name__ == '__main__': - test_main() diff --git a/Lib/test/test_whichdb.py b/Lib/test/test_whichdb.py deleted file mode 100644 index d908ac5b3b..0000000000 --- a/Lib/test/test_whichdb.py +++ /dev/null @@ -1,58 +0,0 @@ -#! /usr/bin/env python -"""Test script for the whichdb module - based on test_anydbm.py -""" - -import os -import test.support -import unittest -import whichdb -import anydbm -import glob -from test.test_anydbm import delete_files, dbm_iterator - -_fname = test.support.TESTFN - -class WhichDBTestCase(unittest.TestCase): - # Actual test methods are added to namespace - # after class definition. - def __init__(self, *args): - unittest.TestCase.__init__(self, *args) - - def test_whichdb(self): - for module in dbm_iterator(): - # Check whether whichdb correctly guesses module name - # for databases opened with "module" module. - # Try with empty files first - name = module.__name__ - if name == 'dumbdbm': - continue # whichdb can't support dumbdbm - test.support.unlink(_fname) - f = module.open(_fname, 'c') - f.close() - self.assertEqual(name, whichdb.whichdb(_fname)) - # Now add a key - f = module.open(_fname, 'w') - f[b"1"] = b"1" - # and test that we can find it - self.assertTrue(b"1" in f) - # and read it - self.assertTrue(f[b"1"] == b"1") - f.close() - self.assertEqual(name, whichdb.whichdb(_fname)) - - def tearDown(self): - delete_files() - - def setUp(self): - delete_files() - - -def test_main(): - try: - test.support.run_unittest(WhichDBTestCase) - finally: - delete_files() - -if __name__ == "__main__": - test_main() -- cgit v1.2.1