diff options
Diffstat (limited to 'Lib/test')
| -rw-r--r-- | Lib/test/pickletester.py | 18 | ||||
| -rwxr-xr-x | Lib/test/regrtest.py | 10 | ||||
| -rw-r--r-- | Lib/test/test___all__.py | 2 | ||||
| -rw-r--r-- | Lib/test/test_copy.py | 6 | ||||
| -rw-r--r-- | Lib/test/test_copy_reg.py (renamed from Lib/test/test_copyreg.py) | 56 | ||||
| -rw-r--r-- | Lib/test/test_py3kwarn.py | 2 |
6 files changed, 47 insertions, 47 deletions
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index ed3b626..e1bc078 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -2,7 +2,7 @@ import unittest import pickle import cPickle import pickletools -import copyreg +import copy_reg from test.test_support import TestFailed, have_unicode, TESTFN, \ run_with_locale @@ -44,21 +44,21 @@ class ExtensionSaver: # there is one). def __init__(self, code): self.code = code - if code in copyreg._inverted_registry: - self.pair = copyreg._inverted_registry[code] - copyreg.remove_extension(self.pair[0], self.pair[1], code) + if code in copy_reg._inverted_registry: + self.pair = copy_reg._inverted_registry[code] + copy_reg.remove_extension(self.pair[0], self.pair[1], code) else: self.pair = None # Restore previous registration for code. def restore(self): code = self.code - curpair = copyreg._inverted_registry.get(code) + curpair = copy_reg._inverted_registry.get(code) if curpair is not None: - copyreg.remove_extension(curpair[0], curpair[1], code) + copy_reg.remove_extension(curpair[0], curpair[1], code) pair = self.pair if pair is not None: - copyreg.add_extension(pair[0], pair[1], code) + copy_reg.add_extension(pair[0], pair[1], code) class C: def __cmp__(self, other): @@ -690,14 +690,14 @@ class AbstractPickleTests(unittest.TestCase): self.assertEqual(B(x), B(y), detail) self.assertEqual(x.__dict__, y.__dict__, detail) - # Register a type with copyreg, with extension code extcode. Pickle + # Register a type with copy_reg, with extension code extcode. Pickle # an object of that type. Check that the resulting pickle uses opcode # (EXT[124]) under proto 2, and not in proto 1. def produce_global_ext(self, extcode, opcode): e = ExtensionSaver(extcode) try: - copyreg.add_extension(__name__, "MyList", extcode) + copy_reg.add_extension(__name__, "MyList", extcode) x = MyList([1, 2, 3]) x.foo = 42 x.bar = "hello" diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py index 85df78e..7aa22ed 100755 --- a/Lib/test/regrtest.py +++ b/Lib/test/regrtest.py @@ -629,7 +629,7 @@ def cleanup_test_droppings(testname, verbose): def dash_R(the_module, test, indirect_test, huntrleaks): # This code is hackish and inelegant, but it seems to do the job. - import copyreg, _abcoll, io + import copy_reg, _abcoll, io if not hasattr(sys, 'gettotalrefcount'): raise Exception("Tracking reference leaks requires a debug build " @@ -637,7 +637,7 @@ def dash_R(the_module, test, indirect_test, huntrleaks): # Save current values for dash_R_cleanup() to restore. fs = warnings.filters[:] - ps = copyreg.dispatch_table.copy() + ps = copy_reg.dispatch_table.copy() pic = sys.path_importer_cache.copy() abcs = {} modules = _abcoll, io @@ -677,7 +677,7 @@ def dash_R(the_module, test, indirect_test, huntrleaks): refrep.close() def dash_R_cleanup(fs, ps, pic, abcs): - import gc, copyreg + import gc, copy_reg import _strptime, linecache dircache = test_support.import_module('dircache', deprecated=True) import urlparse, urllib, urllib2, mimetypes, doctest @@ -691,8 +691,8 @@ def dash_R_cleanup(fs, ps, pic, abcs): # Restore some original values. warnings.filters[:] = fs - copyreg.dispatch_table.clear() - copyreg.dispatch_table.update(ps) + copy_reg.dispatch_table.clear() + copy_reg.dispatch_table.update(ps) sys.path_importer_cache.clear() sys.path_importer_cache.update(pic) diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index 3b6d966..466d921 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -61,7 +61,7 @@ class AllTest(unittest.TestCase): self.check_all("commands") self.check_all("compileall") self.check_all("copy") - self.check_all("copyreg") + self.check_all("copy_reg") self.check_all("csv") self.check_all("dbhash") self.check_all("decimal") diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py index 8645ba1..d2899bd 100644 --- a/Lib/test/test_copy.py +++ b/Lib/test/test_copy.py @@ -1,7 +1,7 @@ """Unit tests for the copy module.""" import copy -import copyreg +import copy_reg import unittest from test import test_support @@ -42,7 +42,7 @@ class TestCopy(unittest.TestCase): return (C, (obj.foo,)) x = C(42) self.assertRaises(TypeError, copy.copy, x) - copyreg.pickle(C, pickle_C, C) + copy_reg.pickle(C, pickle_C, C) y = copy.copy(x) def test_copy_reduce_ex(self): @@ -215,7 +215,7 @@ class TestCopy(unittest.TestCase): return (C, (obj.foo,)) x = C(42) self.assertRaises(TypeError, copy.deepcopy, x) - copyreg.pickle(C, pickle_C, C) + copy_reg.pickle(C, pickle_C, C) y = copy.deepcopy(x) def test_deepcopy_reduce_ex(self): diff --git a/Lib/test/test_copyreg.py b/Lib/test/test_copy_reg.py index 0b42128..c3d3964 100644 --- a/Lib/test/test_copyreg.py +++ b/Lib/test/test_copy_reg.py @@ -1,4 +1,4 @@ -import copyreg +import copy_reg import unittest from test import test_support @@ -27,15 +27,15 @@ class WithInherited(WithSingleString): class CopyRegTestCase(unittest.TestCase): def test_class(self): - self.assertRaises(TypeError, copyreg.pickle, + self.assertRaises(TypeError, copy_reg.pickle, C, None, None) def test_noncallable_reduce(self): - self.assertRaises(TypeError, copyreg.pickle, + self.assertRaises(TypeError, copy_reg.pickle, type(1), "not a callable") def test_noncallable_constructor(self): - self.assertRaises(TypeError, copyreg.pickle, + self.assertRaises(TypeError, copy_reg.pickle, type(1), int, "not a callable") def test_bool(self): @@ -47,42 +47,42 @@ class CopyRegTestCase(unittest.TestCase): e = ExtensionSaver(code) try: # Shouldn't be in registry now. - self.assertRaises(ValueError, copyreg.remove_extension, + self.assertRaises(ValueError, copy_reg.remove_extension, mod, func, code) - copyreg.add_extension(mod, func, code) + copy_reg.add_extension(mod, func, code) # Should be in the registry. - self.assert_(copyreg._extension_registry[mod, func] == code) - self.assert_(copyreg._inverted_registry[code] == (mod, func)) + self.assert_(copy_reg._extension_registry[mod, func] == code) + self.assert_(copy_reg._inverted_registry[code] == (mod, func)) # Shouldn't be in the cache. - self.assert_(code not in copyreg._extension_cache) + self.assert_(code not in copy_reg._extension_cache) # Redundant registration should be OK. - copyreg.add_extension(mod, func, code) # shouldn't blow up + copy_reg.add_extension(mod, func, code) # shouldn't blow up # Conflicting code. - self.assertRaises(ValueError, copyreg.add_extension, + self.assertRaises(ValueError, copy_reg.add_extension, mod, func, code + 1) - self.assertRaises(ValueError, copyreg.remove_extension, + self.assertRaises(ValueError, copy_reg.remove_extension, mod, func, code + 1) # Conflicting module name. - self.assertRaises(ValueError, copyreg.add_extension, + self.assertRaises(ValueError, copy_reg.add_extension, mod[1:], func, code ) - self.assertRaises(ValueError, copyreg.remove_extension, + self.assertRaises(ValueError, copy_reg.remove_extension, mod[1:], func, code ) # Conflicting function name. - self.assertRaises(ValueError, copyreg.add_extension, + self.assertRaises(ValueError, copy_reg.add_extension, mod, func[1:], code) - self.assertRaises(ValueError, copyreg.remove_extension, + self.assertRaises(ValueError, copy_reg.remove_extension, mod, func[1:], code) # Can't remove one that isn't registered at all. - if code + 1 not in copyreg._inverted_registry: - self.assertRaises(ValueError, copyreg.remove_extension, + if code + 1 not in copy_reg._inverted_registry: + self.assertRaises(ValueError, copy_reg.remove_extension, mod[1:], func[1:], code + 1) finally: e.restore() # Shouldn't be there anymore. - self.assert_((mod, func) not in copyreg._extension_registry) - # The code *may* be in copyreg._extension_registry, though, if + self.assert_((mod, func) not in copy_reg._extension_registry) + # The code *may* be in copy_reg._extension_registry, though, if # we happened to pick on a registered code. So don't check for # that. @@ -90,25 +90,25 @@ class CopyRegTestCase(unittest.TestCase): for code in 1, 0x7fffffff: e = ExtensionSaver(code) try: - copyreg.add_extension(mod, func, code) - copyreg.remove_extension(mod, func, code) + copy_reg.add_extension(mod, func, code) + copy_reg.remove_extension(mod, func, code) finally: e.restore() # Ensure invalid codes blow up. for code in -1, 0, 0x80000000L: - self.assertRaises(ValueError, copyreg.add_extension, + self.assertRaises(ValueError, copy_reg.add_extension, mod, func, code) def test_slotnames(self): - self.assertEquals(copyreg._slotnames(WithoutSlots), []) - self.assertEquals(copyreg._slotnames(WithWeakref), []) + self.assertEquals(copy_reg._slotnames(WithoutSlots), []) + self.assertEquals(copy_reg._slotnames(WithWeakref), []) expected = ['_WithPrivate__spam'] - self.assertEquals(copyreg._slotnames(WithPrivate), expected) - self.assertEquals(copyreg._slotnames(WithSingleString), ['spam']) + self.assertEquals(copy_reg._slotnames(WithPrivate), expected) + self.assertEquals(copy_reg._slotnames(WithSingleString), ['spam']) expected = ['eggs', 'spam'] expected.sort() - result = copyreg._slotnames(WithInherited) + result = copy_reg._slotnames(WithInherited) result.sort() self.assertEquals(result, expected) diff --git a/Lib/test/test_py3kwarn.py b/Lib/test/test_py3kwarn.py index 0641f7d..ece38ec 100644 --- a/Lib/test/test_py3kwarn.py +++ b/Lib/test/test_py3kwarn.py @@ -215,7 +215,7 @@ class TestStdlibRemovals(unittest.TestCase): class TestStdlibRenames(unittest.TestCase): - renames = {'copy_reg': 'copyreg', 'Queue': 'queue', + renames = {'Queue': 'queue', 'SocketServer': 'socketserver', 'ConfigParser': 'configparser', 'repr': 'reprlib'} |