← Back to branch summary

~pythonregexp2.7/python/issue2636

« back to all changes in this revision

Viewing changes to Lib/test/test_copy_reg.py

  • Committer: Jeffrey C. "The TimeHorse" Jacobs
  • Date: 2008-05-24 16:05:21 UTC
  • mfrom: (39021.1.401 Regexp-2.6)
  • Revision ID: darklord@timehorse.com-20080524160521-1xenj7p6u3wb89et
Merged in changes from the latest python source snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_copy_reg.py
 
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()