| 1 |
import collections.abc |
| 2 |
import copy |
| 3 |
import pickle |
| 4 |
import unittest |
| 5 |
from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow, exceeds_recursion_limit |
| 6 |
|
| 7 |
class DictSetTest(unittest.TestCase): |
| 8 |
|
| 9 |
def test_constructors_not_callable(self): |
| 10 |
kt = type({}.keys()) |
| 11 |
self.assertRaises(TypeError, kt, {}) |
| 12 |
self.assertRaises(TypeError, kt) |
| 13 |
it = type({}.items()) |
| 14 |
self.assertRaises(TypeError, it, {}) |
| 15 |
self.assertRaises(TypeError, it) |
| 16 |
vt = type({}.values()) |
| 17 |
self.assertRaises(TypeError, vt, {}) |
| 18 |
self.assertRaises(TypeError, vt) |
| 19 |
|
| 20 |
def test_dict_keys(self): |
| 21 |
d = {1: 10, "a": "ABC"} |
| 22 |
keys = d.keys() |
| 23 |
self.assertEqual(len(keys), 2) |
| 24 |
self.assertEqual(set(keys), {1, "a"}) |
| 25 |
self.assertEqual(keys, {1, "a"}) |
| 26 |
self.assertNotEqual(keys, {1, "a", "b"}) |
| 27 |
self.assertNotEqual(keys, {1, "b"}) |
| 28 |
self.assertNotEqual(keys, {1}) |
| 29 |
self.assertNotEqual(keys, 42) |
| 30 |
self.assertIn(1, keys) |
| 31 |
self.assertIn("a", keys) |
| 32 |
self.assertNotIn(10, keys) |
| 33 |
self.assertNotIn("Z", keys) |
| 34 |
self.assertEqual(d.keys(), d.keys()) |
| 35 |
e = {1: 11, "a": "def"} |
| 36 |
self.assertEqual(d.keys(), e.keys()) |
| 37 |
del e["a"] |
| 38 |
self.assertNotEqual(d.keys(), e.keys()) |
| 39 |
|
| 40 |
def test_dict_items(self): |
| 41 |
d = {1: 10, "a": "ABC"} |
| 42 |
items = d.items() |
| 43 |
self.assertEqual(len(items), 2) |
| 44 |
self.assertEqual(set(items), {(1, 10), ("a", "ABC")}) |
| 45 |
self.assertEqual(items, {(1, 10), ("a", "ABC")}) |
| 46 |
self.assertNotEqual(items, {(1, 10), ("a", "ABC"), "junk"}) |
| 47 |
self.assertNotEqual(items, {(1, 10), ("a", "def")}) |
| 48 |
self.assertNotEqual(items, {(1, 10)}) |
| 49 |
self.assertNotEqual(items, 42) |
| 50 |
self.assertIn((1, 10), items) |
| 51 |
self.assertIn(("a", "ABC"), items) |
| 52 |
self.assertNotIn((1, 11), items) |
| 53 |
self.assertNotIn(1, items) |
| 54 |
self.assertNotIn((), items) |
| 55 |
self.assertNotIn((1,), items) |
| 56 |
self.assertNotIn((1, 2, 3), items) |
| 57 |
self.assertEqual(d.items(), d.items()) |
| 58 |
e = d.copy() |
| 59 |
self.assertEqual(d.items(), e.items()) |
| 60 |
e["a"] = "def" |
| 61 |
self.assertNotEqual(d.items(), e.items()) |
| 62 |
|
| 63 |
def test_dict_mixed_keys_items(self): |
| 64 |
d = {(1, 1): 11, (2, 2): 22} |
| 65 |
e = {1: 1, 2: 2} |
| 66 |
self.assertEqual(d.keys(), e.items()) |
| 67 |
self.assertNotEqual(d.items(), e.keys()) |
| 68 |
|
| 69 |
def test_dict_values(self): |
| 70 |
d = {1: 10, "a": "ABC"} |
| 71 |
values = d.values() |
| 72 |
self.assertEqual(set(values), {10, "ABC"}) |
| 73 |
self.assertEqual(len(values), 2) |
| 74 |
|
| 75 |
def test_dict_repr(self): |
| 76 |
d = {1: 10, "a": "ABC"} |
| 77 |
self.assertIsInstance(repr(d), str) |
| 78 |
r = repr(d.items()) |
| 79 |
self.assertIsInstance(r, str) |
| 80 |
self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or |
| 81 |
r == "dict_items([(1, 10), ('a', 'ABC')])") |
| 82 |
r = repr(d.keys()) |
| 83 |
self.assertIsInstance(r, str) |
| 84 |
self.assertTrue(r == "dict_keys(['a', 1])" or |
| 85 |
r == "dict_keys([1, 'a'])") |
| 86 |
r = repr(d.values()) |
| 87 |
self.assertIsInstance(r, str) |
| 88 |
self.assertTrue(r == "dict_values(['ABC', 10])" or |
| 89 |
r == "dict_values([10, 'ABC'])") |
| 90 |
|
| 91 |
def test_keys_set_operations(self): |
| 92 |
d1 = {'a': 1, 'b': 2} |
| 93 |
d2 = {'b': 3, 'c': 2} |
| 94 |
d3 = {'d': 4, 'e': 5} |
| 95 |
d4 = {'d': 4} |
| 96 |
|
| 97 |
class CustomSet(set): |
| 98 |
def intersection(self, other): |
| 99 |
return CustomSet(super().intersection(other)) |
| 100 |
|
| 101 |
self.assertEqual(d1.keys() & d1.keys(), {'a', 'b'}) |
| 102 |
self.assertEqual(d1.keys() & d2.keys(), {'b'}) |
| 103 |
self.assertEqual(d1.keys() & d3.keys(), set()) |
| 104 |
self.assertEqual(d1.keys() & set(d1.keys()), {'a', 'b'}) |
| 105 |
self.assertEqual(d1.keys() & set(d2.keys()), {'b'}) |
| 106 |
self.assertEqual(d1.keys() & set(d3.keys()), set()) |
| 107 |
self.assertEqual(d1.keys() & tuple(d1.keys()), {'a', 'b'}) |
| 108 |
self.assertEqual(d3.keys() & d4.keys(), {'d'}) |
| 109 |
self.assertEqual(d4.keys() & d3.keys(), {'d'}) |
| 110 |
self.assertEqual(d4.keys() & set(d3.keys()), {'d'}) |
| 111 |
self.assertIsInstance(d4.keys() & frozenset(d3.keys()), set) |
| 112 |
self.assertIsInstance(frozenset(d3.keys()) & d4.keys(), set) |
| 113 |
self.assertIs(type(d4.keys() & CustomSet(d3.keys())), set) |
| 114 |
self.assertIs(type(d1.keys() & []), set) |
| 115 |
self.assertIs(type([] & d1.keys()), set) |
| 116 |
|
| 117 |
self.assertEqual(d1.keys() | d1.keys(), {'a', 'b'}) |
| 118 |
self.assertEqual(d1.keys() | d2.keys(), {'a', 'b', 'c'}) |
| 119 |
self.assertEqual(d1.keys() | d3.keys(), {'a', 'b', 'd', 'e'}) |
| 120 |
self.assertEqual(d1.keys() | set(d1.keys()), {'a', 'b'}) |
| 121 |
self.assertEqual(d1.keys() | set(d2.keys()), {'a', 'b', 'c'}) |
| 122 |
self.assertEqual(d1.keys() | set(d3.keys()), |
| 123 |
{'a', 'b', 'd', 'e'}) |
| 124 |
self.assertEqual(d1.keys() | (1, 2), {'a', 'b', 1, 2}) |
| 125 |
|
| 126 |
self.assertEqual(d1.keys() ^ d1.keys(), set()) |
| 127 |
self.assertEqual(d1.keys() ^ d2.keys(), {'a', 'c'}) |
| 128 |
self.assertEqual(d1.keys() ^ d3.keys(), {'a', 'b', 'd', 'e'}) |
| 129 |
self.assertEqual(d1.keys() ^ set(d1.keys()), set()) |
| 130 |
self.assertEqual(d1.keys() ^ set(d2.keys()), {'a', 'c'}) |
| 131 |
self.assertEqual(d1.keys() ^ set(d3.keys()), |
| 132 |
{'a', 'b', 'd', 'e'}) |
| 133 |
self.assertEqual(d1.keys() ^ tuple(d2.keys()), {'a', 'c'}) |
| 134 |
|
| 135 |
self.assertEqual(d1.keys() - d1.keys(), set()) |
| 136 |
self.assertEqual(d1.keys() - d2.keys(), {'a'}) |
| 137 |
self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'}) |
| 138 |
self.assertEqual(d1.keys() - set(d1.keys()), set()) |
| 139 |
self.assertEqual(d1.keys() - set(d2.keys()), {'a'}) |
| 140 |
self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'}) |
| 141 |
self.assertEqual(d1.keys() - (0, 1), {'a', 'b'}) |
| 142 |
|
| 143 |
self.assertFalse(d1.keys().isdisjoint(d1.keys())) |
| 144 |
self.assertFalse(d1.keys().isdisjoint(d2.keys())) |
| 145 |
self.assertFalse(d1.keys().isdisjoint(list(d2.keys()))) |
| 146 |
self.assertFalse(d1.keys().isdisjoint(set(d2.keys()))) |
| 147 |
self.assertTrue(d1.keys().isdisjoint({'x', 'y', 'z'})) |
| 148 |
self.assertTrue(d1.keys().isdisjoint(['x', 'y', 'z'])) |
| 149 |
self.assertTrue(d1.keys().isdisjoint(set(['x', 'y', 'z']))) |
| 150 |
self.assertTrue(d1.keys().isdisjoint(set(['x', 'y']))) |
| 151 |
self.assertTrue(d1.keys().isdisjoint(['x', 'y'])) |
| 152 |
self.assertTrue(d1.keys().isdisjoint({})) |
| 153 |
self.assertTrue(d1.keys().isdisjoint(d3.keys())) |
| 154 |
|
| 155 |
de = {} |
| 156 |
self.assertTrue(de.keys().isdisjoint(set())) |
| 157 |
self.assertTrue(de.keys().isdisjoint([])) |
| 158 |
self.assertTrue(de.keys().isdisjoint(de.keys())) |
| 159 |
self.assertTrue(de.keys().isdisjoint([1])) |
| 160 |
|
| 161 |
def test_items_set_operations(self): |
| 162 |
d1 = {'a': 1, 'b': 2} |
| 163 |
d2 = {'a': 2, 'b': 2} |
| 164 |
d3 = {'d': 4, 'e': 5} |
| 165 |
self.assertEqual( |
| 166 |
d1.items() & d1.items(), {('a', 1), ('b', 2)}) |
| 167 |
self.assertEqual(d1.items() & d2.items(), {('b', 2)}) |
| 168 |
self.assertEqual(d1.items() & d3.items(), set()) |
| 169 |
self.assertEqual(d1.items() & set(d1.items()), |
| 170 |
{('a', 1), ('b', 2)}) |
| 171 |
self.assertEqual(d1.items() & set(d2.items()), {('b', 2)}) |
| 172 |
self.assertEqual(d1.items() & set(d3.items()), set()) |
| 173 |
self.assertEqual(d1.items() & (("a", 1), ("b", 2)), |
| 174 |
{('a', 1), ('b', 2)}) |
| 175 |
self.assertEqual(d1.items() & (("a", 2), ("b", 2)), {('b', 2)}) |
| 176 |
self.assertEqual(d1.items() & (("d", 4), ("e", 5)), set()) |
| 177 |
|
| 178 |
self.assertEqual(d1.items() | d1.items(), |
| 179 |
{('a', 1), ('b', 2)}) |
| 180 |
self.assertEqual(d1.items() | d2.items(), |
| 181 |
{('a', 1), ('a', 2), ('b', 2)}) |
| 182 |
self.assertEqual(d1.items() | d3.items(), |
| 183 |
{('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 184 |
self.assertEqual(d1.items() | set(d1.items()), |
| 185 |
{('a', 1), ('b', 2)}) |
| 186 |
self.assertEqual(d1.items() | set(d2.items()), |
| 187 |
{('a', 1), ('a', 2), ('b', 2)}) |
| 188 |
self.assertEqual(d1.items() | set(d3.items()), |
| 189 |
{('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 190 |
self.assertEqual(d1.items() | (('a', 1), ('b', 2)), |
| 191 |
{('a', 1), ('b', 2)}) |
| 192 |
self.assertEqual(d1.items() | (('a', 2), ('b', 2)), |
| 193 |
{('a', 1), ('a', 2), ('b', 2)}) |
| 194 |
self.assertEqual(d1.items() | (('d', 4), ('e', 5)), |
| 195 |
{('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 196 |
|
| 197 |
self.assertEqual(d1.items() ^ d1.items(), set()) |
| 198 |
self.assertEqual(d1.items() ^ d2.items(), |
| 199 |
{('a', 1), ('a', 2)}) |
| 200 |
self.assertEqual(d1.items() ^ d3.items(), |
| 201 |
{('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 202 |
self.assertEqual(d1.items() ^ (('a', 1), ('b', 2)), set()) |
| 203 |
self.assertEqual(d1.items() ^ (("a", 2), ("b", 2)), |
| 204 |
{('a', 1), ('a', 2)}) |
| 205 |
self.assertEqual(d1.items() ^ (("d", 4), ("e", 5)), |
| 206 |
{('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 207 |
|
| 208 |
self.assertEqual(d1.items() - d1.items(), set()) |
| 209 |
self.assertEqual(d1.items() - d2.items(), {('a', 1)}) |
| 210 |
self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)}) |
| 211 |
self.assertEqual(d1.items() - set(d1.items()), set()) |
| 212 |
self.assertEqual(d1.items() - set(d2.items()), {('a', 1)}) |
| 213 |
self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)}) |
| 214 |
self.assertEqual(d1.items() - (('a', 1), ('b', 2)), set()) |
| 215 |
self.assertEqual(d1.items() - (("a", 2), ("b", 2)), {('a', 1)}) |
| 216 |
self.assertEqual(d1.items() - (("d", 4), ("e", 5)), {('a', 1), ('b', 2)}) |
| 217 |
|
| 218 |
self.assertFalse(d1.items().isdisjoint(d1.items())) |
| 219 |
self.assertFalse(d1.items().isdisjoint(d2.items())) |
| 220 |
self.assertFalse(d1.items().isdisjoint(list(d2.items()))) |
| 221 |
self.assertFalse(d1.items().isdisjoint(set(d2.items()))) |
| 222 |
self.assertTrue(d1.items().isdisjoint({'x', 'y', 'z'})) |
| 223 |
self.assertTrue(d1.items().isdisjoint(['x', 'y', 'z'])) |
| 224 |
self.assertTrue(d1.items().isdisjoint(set(['x', 'y', 'z']))) |
| 225 |
self.assertTrue(d1.items().isdisjoint(set(['x', 'y']))) |
| 226 |
self.assertTrue(d1.items().isdisjoint({})) |
| 227 |
self.assertTrue(d1.items().isdisjoint(d3.items())) |
| 228 |
|
| 229 |
de = {} |
| 230 |
self.assertTrue(de.items().isdisjoint(set())) |
| 231 |
self.assertTrue(de.items().isdisjoint([])) |
| 232 |
self.assertTrue(de.items().isdisjoint(de.items())) |
| 233 |
self.assertTrue(de.items().isdisjoint([1])) |
| 234 |
|
| 235 |
def test_set_operations_with_iterator(self): |
| 236 |
origin = {1: 2, 3: 4} |
| 237 |
self.assertEqual(origin.keys() & iter([1, 2]), {1}) |
| 238 |
self.assertEqual(origin.keys() | iter([1, 2]), {1, 2, 3}) |
| 239 |
self.assertEqual(origin.keys() ^ iter([1, 2]), {2, 3}) |
| 240 |
self.assertEqual(origin.keys() - iter([1, 2]), {3}) |
| 241 |
|
| 242 |
items = origin.items() |
| 243 |
self.assertEqual(items & iter([(1, 2)]), {(1, 2)}) |
| 244 |
self.assertEqual(items ^ iter([(1, 2)]), {(3, 4)}) |
| 245 |
self.assertEqual(items | iter([(1, 2)]), {(1, 2), (3, 4)}) |
| 246 |
self.assertEqual(items - iter([(1, 2)]), {(3, 4)}) |
| 247 |
|
| 248 |
def test_set_operations_with_noniterable(self): |
| 249 |
with self.assertRaises(TypeError): |
| 250 |
{}.keys() & 1 |
| 251 |
with self.assertRaises(TypeError): |
| 252 |
{}.keys() | 1 |
| 253 |
with self.assertRaises(TypeError): |
| 254 |
{}.keys() ^ 1 |
| 255 |
with self.assertRaises(TypeError): |
| 256 |
{}.keys() - 1 |
| 257 |
|
| 258 |
with self.assertRaises(TypeError): |
| 259 |
{}.items() & 1 |
| 260 |
with self.assertRaises(TypeError): |
| 261 |
{}.items() | 1 |
| 262 |
with self.assertRaises(TypeError): |
| 263 |
{}.items() ^ 1 |
| 264 |
with self.assertRaises(TypeError): |
| 265 |
{}.items() - 1 |
| 266 |
|
| 267 |
def test_recursive_repr(self): |
| 268 |
d = {} |
| 269 |
d[42] = d.values() |
| 270 |
r = repr(d) |
| 271 |
# Cannot perform a stronger test, as the contents of the repr |
| 272 |
# are implementation-dependent. All we can say is that we |
| 273 |
# want a str result, not an exception of any sort. |
| 274 |
self.assertIsInstance(r, str) |
| 275 |
d[42] = d.items() |
| 276 |
r = repr(d) |
| 277 |
# Again. |
| 278 |
self.assertIsInstance(r, str) |
| 279 |
|
| 280 |
@skip_wasi_stack_overflow() |
| 281 |
@skip_emscripten_stack_overflow() |
| 282 |
def test_deeply_nested_repr(self): |
| 283 |
d = {} |
| 284 |
for i in range(exceeds_recursion_limit()): |
| 285 |
d = {42: d.values()} |
| 286 |
self.assertRaises(RecursionError, repr, d) |
| 287 |
|
| 288 |
def test_copy(self): |
| 289 |
d = {1: 10, "a": "ABC"} |
| 290 |
self.assertRaises(TypeError, copy.copy, d.keys()) |
| 291 |
self.assertRaises(TypeError, copy.copy, d.values()) |
| 292 |
self.assertRaises(TypeError, copy.copy, d.items()) |
| 293 |
|
| 294 |
def test_compare_error(self): |
| 295 |
class Exc(Exception): |
| 296 |
pass |
| 297 |
|
| 298 |
class BadEq: |
| 299 |
def __hash__(self): |
| 300 |
return 7 |
| 301 |
def __eq__(self, other): |
| 302 |
raise Exc |
| 303 |
|
| 304 |
k1, k2 = BadEq(), BadEq() |
| 305 |
v1, v2 = BadEq(), BadEq() |
| 306 |
d = {k1: v1} |
| 307 |
|
| 308 |
self.assertIn(k1, d) |
| 309 |
self.assertIn(k1, d.keys()) |
| 310 |
self.assertIn(v1, d.values()) |
| 311 |
self.assertIn((k1, v1), d.items()) |
| 312 |
|
| 313 |
self.assertRaises(Exc, d.__contains__, k2) |
| 314 |
self.assertRaises(Exc, d.keys().__contains__, k2) |
| 315 |
self.assertRaises(Exc, d.items().__contains__, (k2, v1)) |
| 316 |
self.assertRaises(Exc, d.items().__contains__, (k1, v2)) |
| 317 |
with self.assertRaises(Exc): |
| 318 |
v2 in d.values() |
| 319 |
|
| 320 |
def test_pickle(self): |
| 321 |
d = {1: 10, "a": "ABC"} |
| 322 |
for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| 323 |
self.assertRaises((TypeError, pickle.PicklingError), |
| 324 |
pickle.dumps, d.keys(), proto) |
| 325 |
self.assertRaises((TypeError, pickle.PicklingError), |
| 326 |
pickle.dumps, d.values(), proto) |
| 327 |
self.assertRaises((TypeError, pickle.PicklingError), |
| 328 |
pickle.dumps, d.items(), proto) |
| 329 |
|
| 330 |
def test_abc_registry(self): |
| 331 |
d = dict(a=1) |
| 332 |
|
| 333 |
self.assertIsInstance(d.keys(), collections.abc.KeysView) |
| 334 |
self.assertIsInstance(d.keys(), collections.abc.MappingView) |
| 335 |
self.assertIsInstance(d.keys(), collections.abc.Set) |
| 336 |
self.assertIsInstance(d.keys(), collections.abc.Sized) |
| 337 |
self.assertIsInstance(d.keys(), collections.abc.Iterable) |
| 338 |
self.assertIsInstance(d.keys(), collections.abc.Container) |
| 339 |
|
| 340 |
self.assertIsInstance(d.values(), collections.abc.ValuesView) |
| 341 |
self.assertIsInstance(d.values(), collections.abc.MappingView) |
| 342 |
self.assertIsInstance(d.values(), collections.abc.Sized) |
| 343 |
self.assertIsInstance(d.values(), collections.abc.Collection) |
| 344 |
self.assertIsInstance(d.values(), collections.abc.Iterable) |
| 345 |
self.assertIsInstance(d.values(), collections.abc.Container) |
| 346 |
|
| 347 |
self.assertIsInstance(d.items(), collections.abc.ItemsView) |
| 348 |
self.assertIsInstance(d.items(), collections.abc.MappingView) |
| 349 |
self.assertIsInstance(d.items(), collections.abc.Set) |
| 350 |
self.assertIsInstance(d.items(), collections.abc.Sized) |
| 351 |
self.assertIsInstance(d.items(), collections.abc.Iterable) |
| 352 |
self.assertIsInstance(d.items(), collections.abc.Container) |
| 353 |
|
| 354 |
|
| 355 |
if __name__ == "__main__": |
| 356 |
unittest.main() |