1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
"""
Test implementation of the PEP 509: dictionary versionning.
"""
import unittest
from test.support import import_helper
# PEP 509 is implemented in CPython but other Python implementations
# don't require to implement it
_testcapi = import_helper.import_module('_testcapi')
class DictVersionTests(unittest.TestCase):
type2test = dict
def setUp(self):
self.seen_versions = set()
self.dict = None
def check_version_unique(self, mydict):
version = _testcapi.dict_get_version(mydict)
self.assertNotIn(version, self.seen_versions)
self.seen_versions.add(version)
def check_version_changed(self, mydict, method, *args, **kw):
result = method(*args, **kw)
self.check_version_unique(mydict)
return result
def check_version_dont_change(self, mydict, method, *args, **kw):
version1 = _testcapi.dict_get_version(mydict)
self.seen_versions.add(version1)
result = method(*args, **kw)
version2 = _testcapi.dict_get_version(mydict)
self.assertEqual(version2, version1, "version changed")
return result
def new_dict(self, *args, **kw):
d = self.type2test(*args, **kw)
self.check_version_unique(d)
return d
def test_constructor(self):
# new empty dictionaries must all have an unique version
empty1 = self.new_dict()
empty2 = self.new_dict()
empty3 = self.new_dict()
# non-empty dictionaries must also have an unique version
nonempty1 = self.new_dict(x='x')
nonempty2 = self.new_dict(x='x', y='y')
def test_copy(self):
d = self.new_dict(a=1, b=2)
d2 = self.check_version_dont_change(d, d.copy)
# dict.copy() must create a dictionary with a new unique version
self.check_version_unique(d2)
def test_setitem(self):
d = self.new_dict()
# creating new keys must change the version
self.check_version_changed(d, d.__setitem__, 'x', 'x')
self.check_version_changed(d, d.__setitem__, 'y', 'y')
# changing values must change the version
self.check_version_changed(d, d.__setitem__, 'x', 1)
self.check_version_changed(d, d.__setitem__, 'y', 2)
def test_setitem_same_value(self):
value = object()
d = self.new_dict()
# setting a key must change the version
self.check_version_changed(d, d.__setitem__, 'key', value)
# setting a key to the same value with dict.__setitem__
# must change the version
self.check_version_dont_change(d, d.__setitem__, 'key', value)
# setting a key to the same value with dict.update
# must change the version
self.check_version_dont_change(d, d.update, key=value)
d2 = self.new_dict(key=value)
self.check_version_dont_change(d, d.update, d2)
def test_setitem_equal(self):
class AlwaysEqual:
def __eq__(self, other):
return True
value1 = AlwaysEqual()
value2 = AlwaysEqual()
self.assertTrue(value1 == value2)
self.assertFalse(value1 != value2)
self.assertIsNot(value1, value2)
d = self.new_dict()
self.check_version_changed(d, d.__setitem__, 'key', value1)
self.assertIs(d['key'], value1)
# setting a key to a value equal to the current value
# with dict.__setitem__() must change the version
self.check_version_changed(d, d.__setitem__, 'key', value2)
self.assertIs(d['key'], value2)
# setting a key to a value equal to the current value
# with dict.update() must change the version
self.check_version_changed(d, d.update, key=value1)
self.assertIs(d['key'], value1)
d2 = self.new_dict(key=value2)
self.check_version_changed(d, d.update, d2)
self.assertIs(d['key'], value2)
def test_setdefault(self):
d = self.new_dict()
# setting a key with dict.setdefault() must change the version
self.check_version_changed(d, d.setdefault, 'key', 'value1')
# don't change the version if the key already exists
self.check_version_dont_change(d, d.setdefault, 'key', 'value2')
def test_delitem(self):
d = self.new_dict(key='value')
# deleting a key with dict.__delitem__() must change the version
self.check_version_changed(d, d.__delitem__, 'key')
# don't change the version if the key doesn't exist
self.check_version_dont_change(d, self.assertRaises, KeyError,
d.__delitem__, 'key')
def test_pop(self):
d = self.new_dict(key='value')
# pop() must change the version if the key exists
self.check_version_changed(d, d.pop, 'key')
# pop() must not change the version if the key does not exist
self.check_version_dont_change(d, self.assertRaises, KeyError,
d.pop, 'key')
def test_popitem(self):
d = self.new_dict(key='value')
# popitem() must change the version if the dict is not empty
self.check_version_changed(d, d.popitem)
# popitem() must not change the version if the dict is empty
self.check_version_dont_change(d, self.assertRaises, KeyError,
d.popitem)
def test_update(self):
d = self.new_dict(key='value')
# update() calling with no argument must not change the version
self.check_version_dont_change(d, d.update)
# update() must change the version
self.check_version_changed(d, d.update, key='new value')
d2 = self.new_dict(key='value 3')
self.check_version_changed(d, d.update, d2)
def test_clear(self):
d = self.new_dict(key='value')
# clear() must change the version if the dict is not empty
self.check_version_changed(d, d.clear)
# clear() must not change the version if the dict is empty
self.check_version_dont_change(d, d.clear)
class Dict(dict):
pass
class DictSubtypeVersionTests(DictVersionTests):
type2test = Dict
if __name__ == "__main__":
unittest.main()
|
