cpython/Lib/test/test_copy_reg.py

122 lines
4.2 KiB
Python
Raw Normal View History

2008-05-20 04:49:57 -03:00
import copy_reg
2001-05-22 17:38:44 -03:00
import unittest
from test import test_support
from test.pickletester import ExtensionSaver
class C:
pass
class WithoutSlots(object):
pass
class WithWeakref(object):
__slots__ = ('__weakref__',)
class WithPrivate(object):
__slots__ = ('__spam',)
class WithSingleString(object):
__slots__ = 'spam'
class WithInherited(WithSingleString):
__slots__ = ('eggs',)
2001-05-22 17:38:44 -03:00
class CopyRegTestCase(unittest.TestCase):
def test_class(self):
2008-05-20 04:49:57 -03:00
self.assertRaises(TypeError, copy_reg.pickle,
2001-05-22 17:38:44 -03:00
C, None, None)
def test_noncallable_reduce(self):
2008-05-20 04:49:57 -03:00
self.assertRaises(TypeError, copy_reg.pickle,
2001-05-22 17:38:44 -03:00
type(1), "not a callable")
def test_noncallable_constructor(self):
2008-05-20 04:49:57 -03:00
self.assertRaises(TypeError, copy_reg.pickle,
2001-05-22 17:38:44 -03:00
type(1), int, "not a callable")
2003-01-26 07:32:44 -04:00
def test_bool(self):
import copy
self.assertEqual(True, copy.copy(True))
2003-01-26 07:32:44 -04:00
def test_extension_registry(self):
mod, func, code = 'junk1 ', ' junk2', 0xabcd
e = ExtensionSaver(code)
try:
# Shouldn't be in registry now.
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func, code)
2008-05-20 04:49:57 -03:00
copy_reg.add_extension(mod, func, code)
# Should be in the registry.
2009-06-30 19:57:08 -03:00
self.assertTrue(copy_reg._extension_registry[mod, func] == code)
self.assertTrue(copy_reg._inverted_registry[code] == (mod, func))
# Shouldn't be in the cache.
2010-01-23 19:04:36 -04:00
self.assertNotIn(code, copy_reg._extension_cache)
# Redundant registration should be OK.
2008-05-20 04:49:57 -03:00
copy_reg.add_extension(mod, func, code) # shouldn't blow up
# Conflicting code.
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func, code + 1)
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func, code + 1)
# Conflicting module name.
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.add_extension,
mod[1:], func, code )
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.remove_extension,
mod[1:], func, code )
# Conflicting function name.
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func[1:], code)
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func[1:], code)
# Can't remove one that isn't registered at all.
2008-05-20 04:49:57 -03:00
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.
2010-01-23 19:04:36 -04:00
self.assertNotIn((mod, func), copy_reg._extension_registry)
2008-05-20 04:49:57 -03:00
# 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.
# Check valid codes at the limits.
for code in 1, 0x7fffffff:
e = ExtensionSaver(code)
try:
2008-05-20 04:49:57 -03:00
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:
2008-05-20 04:49:57 -03:00
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func, code)
2001-05-22 17:38:44 -03:00
def test_slotnames(self):
self.assertEqual(copy_reg._slotnames(WithoutSlots), [])
self.assertEqual(copy_reg._slotnames(WithWeakref), [])
expected = ['_WithPrivate__spam']
self.assertEqual(copy_reg._slotnames(WithPrivate), expected)
self.assertEqual(copy_reg._slotnames(WithSingleString), ['spam'])
expected = ['eggs', 'spam']
expected.sort()
2008-05-20 04:49:57 -03:00
result = copy_reg._slotnames(WithInherited)
result.sort()
self.assertEqual(result, expected)
def test_main():
test_support.run_unittest(CopyRegTestCase)
if __name__ == "__main__":
test_main()