|
1 import copy_reg |
|
2 import unittest |
|
3 |
|
4 from test import test_support |
|
5 from test.pickletester import ExtensionSaver |
|
6 |
|
7 class C: |
|
8 pass |
|
9 |
|
10 |
|
11 class WithoutSlots(object): |
|
12 pass |
|
13 |
|
14 class WithWeakref(object): |
|
15 __slots__ = ('__weakref__',) |
|
16 |
|
17 class WithPrivate(object): |
|
18 __slots__ = ('__spam',) |
|
19 |
|
20 class WithSingleString(object): |
|
21 __slots__ = 'spam' |
|
22 |
|
23 class WithInherited(WithSingleString): |
|
24 __slots__ = ('eggs',) |
|
25 |
|
26 |
|
27 class CopyRegTestCase(unittest.TestCase): |
|
28 |
|
29 def test_class(self): |
|
30 self.assertRaises(TypeError, copy_reg.pickle, |
|
31 C, None, None) |
|
32 |
|
33 def test_noncallable_reduce(self): |
|
34 self.assertRaises(TypeError, copy_reg.pickle, |
|
35 type(1), "not a callable") |
|
36 |
|
37 def test_noncallable_constructor(self): |
|
38 self.assertRaises(TypeError, copy_reg.pickle, |
|
39 type(1), int, "not a callable") |
|
40 |
|
41 def test_bool(self): |
|
42 import copy |
|
43 self.assertEquals(True, copy.copy(True)) |
|
44 |
|
45 def test_extension_registry(self): |
|
46 mod, func, code = 'junk1 ', ' junk2', 0xabcd |
|
47 e = ExtensionSaver(code) |
|
48 try: |
|
49 # Shouldn't be in registry now. |
|
50 self.assertRaises(ValueError, copy_reg.remove_extension, |
|
51 mod, func, code) |
|
52 copy_reg.add_extension(mod, func, code) |
|
53 # Should be in the registry. |
|
54 self.assert_(copy_reg._extension_registry[mod, func] == code) |
|
55 self.assert_(copy_reg._inverted_registry[code] == (mod, func)) |
|
56 # Shouldn't be in the cache. |
|
57 self.assert_(code not in copy_reg._extension_cache) |
|
58 # Redundant registration should be OK. |
|
59 copy_reg.add_extension(mod, func, code) # shouldn't blow up |
|
60 # Conflicting code. |
|
61 self.assertRaises(ValueError, copy_reg.add_extension, |
|
62 mod, func, code + 1) |
|
63 self.assertRaises(ValueError, copy_reg.remove_extension, |
|
64 mod, func, code + 1) |
|
65 # Conflicting module name. |
|
66 self.assertRaises(ValueError, copy_reg.add_extension, |
|
67 mod[1:], func, code ) |
|
68 self.assertRaises(ValueError, copy_reg.remove_extension, |
|
69 mod[1:], func, code ) |
|
70 # Conflicting function name. |
|
71 self.assertRaises(ValueError, copy_reg.add_extension, |
|
72 mod, func[1:], code) |
|
73 self.assertRaises(ValueError, copy_reg.remove_extension, |
|
74 mod, func[1:], code) |
|
75 # Can't remove one that isn't registered at all. |
|
76 if code + 1 not in copy_reg._inverted_registry: |
|
77 self.assertRaises(ValueError, copy_reg.remove_extension, |
|
78 mod[1:], func[1:], code + 1) |
|
79 |
|
80 finally: |
|
81 e.restore() |
|
82 |
|
83 # Shouldn't be there anymore. |
|
84 self.assert_((mod, func) not in copy_reg._extension_registry) |
|
85 # The code *may* be in copy_reg._extension_registry, though, if |
|
86 # we happened to pick on a registered code. So don't check for |
|
87 # that. |
|
88 |
|
89 # Check valid codes at the limits. |
|
90 for code in 1, 0x7fffffff: |
|
91 e = ExtensionSaver(code) |
|
92 try: |
|
93 copy_reg.add_extension(mod, func, code) |
|
94 copy_reg.remove_extension(mod, func, code) |
|
95 finally: |
|
96 e.restore() |
|
97 |
|
98 # Ensure invalid codes blow up. |
|
99 for code in -1, 0, 0x80000000L: |
|
100 self.assertRaises(ValueError, copy_reg.add_extension, |
|
101 mod, func, code) |
|
102 |
|
103 def test_slotnames(self): |
|
104 self.assertEquals(copy_reg._slotnames(WithoutSlots), []) |
|
105 self.assertEquals(copy_reg._slotnames(WithWeakref), []) |
|
106 expected = ['_WithPrivate__spam'] |
|
107 self.assertEquals(copy_reg._slotnames(WithPrivate), expected) |
|
108 self.assertEquals(copy_reg._slotnames(WithSingleString), ['spam']) |
|
109 expected = ['eggs', 'spam'] |
|
110 expected.sort() |
|
111 result = copy_reg._slotnames(WithInherited) |
|
112 result.sort() |
|
113 self.assertEquals(result, expected) |
|
114 |
|
115 |
|
116 def test_main(): |
|
117 test_support.run_unittest(CopyRegTestCase) |
|
118 |
|
119 |
|
120 if __name__ == "__main__": |
|
121 test_main() |