from test import support import collections.abc import copy import pickle import sys import unittest class DictSetTest(unittest.TestCase): @support.cpython_only def test_constructors_not_callable(self): kt = type({}.keys()) self.assertRaises(TypeError, kt, {}) self.assertRaises(TypeError, kt) it = type({}.items()) self.assertRaises(TypeError, it, {}) self.assertRaises(TypeError, it) vt = type({}.values()) self.assertRaises(TypeError, vt, {}) self.assertRaises(TypeError, vt) def test_dict_keys(self): d = {1: 10, "a": "ABC"} keys = d.keys() self.assertEqual(len(keys), 2) self.assertEqual(set(keys), {1, "a"}) self.assertEqual(keys, {1, "a"}) self.assertNotEqual(keys, {1, "a", "b"}) self.assertNotEqual(keys, {1, "b"}) self.assertNotEqual(keys, {1}) self.assertNotEqual(keys, 42) self.assertIn(1, keys) self.assertIn("a", keys) self.assertNotIn(10, keys) self.assertNotIn("Z", keys) self.assertEqual(d.keys(), d.keys()) e = {1: 11, "a": "def"} self.assertEqual(d.keys(), e.keys()) del e["a"] self.assertNotEqual(d.keys(), e.keys()) def test_dict_items(self): d = {1: 10, "a": "ABC"} items = d.items() self.assertEqual(len(items), 2) self.assertEqual(set(items), {(1, 10), ("a", "ABC")}) self.assertEqual(items, {(1, 10), ("a", "ABC")}) self.assertNotEqual(items, {(1, 10), ("a", "ABC"), "junk"}) self.assertNotEqual(items, {(1, 10), ("a", "def")}) self.assertNotEqual(items, {(1, 10)}) self.assertNotEqual(items, 42) self.assertIn((1, 10), items) self.assertIn(("a", "ABC"), items) self.assertNotIn((1, 11), items) self.assertNotIn(1, items) self.assertNotIn((), items) self.assertNotIn((1,), items) self.assertNotIn((1, 2, 3), items) self.assertEqual(d.items(), d.items()) e = d.copy() self.assertEqual(d.items(), e.items()) e["a"] = "def" self.assertNotEqual(d.items(), e.items()) def test_dict_mixed_keys_items(self): d = {(1, 1): 11, (2, 2): 22} e = {1: 1, 2: 2} self.assertEqual(d.keys(), e.items()) self.assertNotEqual(d.items(), e.keys()) def test_dict_values(self): d = {1: 10, "a": "ABC"} values = d.values() self.assertEqual(set(values), {10, "ABC"}) self.assertEqual(len(values), 2) def test_dict_repr(self): d = {1: 10, "a": "ABC"} self.assertIsInstance(repr(d), str) r = repr(d.items()) self.assertIsInstance(r, str) self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or r == "dict_items([(1, 10), ('a', 'ABC')])") r = repr(d.keys()) self.assertIsInstance(r, str) self.assertTrue(r == "dict_keys(['a', 1])" or r == "dict_keys([1, 'a'])") r = repr(d.values()) self.assertIsInstance(r, str) self.assertTrue(r == "dict_values(['ABC', 10])" or r == "dict_values([10, 'ABC'])") def test_keys_set_operations(self): d1 = {'a': 1, 'b': 2} d2 = {'b': 3, 'c': 2} d3 = {'d': 4, 'e': 5} self.assertEqual(d1.keys() & d1.keys(), {'a', 'b'}) self.assertEqual(d1.keys() & d2.keys(), {'b'}) self.assertEqual(d1.keys() & d3.keys(), set()) self.assertEqual(d1.keys() & set(d1.keys()), {'a', 'b'}) self.assertEqual(d1.keys() & set(d2.keys()), {'b'}) self.assertEqual(d1.keys() & set(d3.keys()), set()) self.assertEqual(d1.keys() & tuple(d1.keys()), {'a', 'b'}) self.assertEqual(d1.keys() | d1.keys(), {'a', 'b'}) self.assertEqual(d1.keys() | d2.keys(), {'a', 'b', 'c'}) self.assertEqual(d1.keys() | d3.keys(), {'a', 'b', 'd', 'e'}) self.assertEqual(d1.keys() | set(d1.keys()), {'a', 'b'}) self.assertEqual(d1.keys() | set(d2.keys()), {'a', 'b', 'c'}) self.assertEqual(d1.keys() | set(d3.keys()), {'a', 'b', 'd', 'e'}) self.assertEqual(d1.keys() | (1, 2), {'a', 'b', 1, 2}) self.assertEqual(d1.keys() ^ d1.keys(), set()) self.assertEqual(d1.keys() ^ d2.keys(), {'a', 'c'}) self.assertEqual(d1.keys() ^ d3.keys(), {'a', 'b', 'd', 'e'}) self.assertEqual(d1.keys() ^ set(d1.keys()), set()) self.assertEqual(d1.keys() ^ set(d2.keys()), {'a', 'c'}) self.assertEqual(d1.keys() ^ set(d3.keys()), {'a', 'b', 'd', 'e'}) self.assertEqual(d1.keys() ^ tuple(d2.keys()), {'a', 'c'}) self.assertEqual(d1.keys() - d1.keys(), set()) self.assertEqual(d1.keys() - d2.keys(), {'a'}) self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'}) self.assertEqual(d1.keys() - set(d1.keys()), set()) self.assertEqual(d1.keys() - set(d2.keys()), {'a'}) self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'}) self.assertEqual(d1.keys() - (0, 1), {'a', 'b'}) self.assertFalse(d1.keys().isdisjoint(d1.keys())) self.assertFalse(d1.keys().isdisjoint(d2.keys())) self.assertFalse(d1.keys().isdisjoint(list(d2.keys()))) self.assertFalse(d1.keys().isdisjoint(set(d2.keys()))) self.assertTrue(d1.keys().isdisjoint({'x', 'y', 'z'})) self.assertTrue(d1.keys().isdisjoint(['x', 'y', 'z'])) self.assertTrue(d1.keys().isdisjoint(set(['x', 'y', 'z']))) self.assertTrue(d1.keys().isdisjoint(set(['x', 'y']))) self.assertTrue(d1.keys().isdisjoint(['x', 'y'])) self.assertTrue(d1.keys().isdisjoint({})) self.assertTrue(d1.keys().isdisjoint(d3.keys())) de = {} self.assertTrue(de.keys().isdisjoint(set())) self.assertTrue(de.keys().isdisjoint([])) self.assertTrue(de.keys().isdisjoint(de.keys())) self.assertTrue(de.keys().isdisjoint([1])) def test_items_set_operations(self): d1 = {'a': 1, 'b': 2} d2 = {'a': 2, 'b': 2} d3 = {'d': 4, 'e': 5} self.assertEqual( d1.items() & d1.items(), {('a', 1), ('b', 2)}) self.assertEqual(d1.items() & d2.items(), {('b', 2)}) self.assertEqual(d1.items() & d3.items(), set()) self.assertEqual(d1.items() & set(d1.items()), {('a', 1), ('b', 2)}) self.assertEqual(d1.items() & set(d2.items()), {('b', 2)}) self.assertEqual(d1.items() & set(d3.items()), set()) self.assertEqual(d1.items() | d1.items(), {('a', 1), ('b', 2)}) self.assertEqual(d1.items() | d2.items(), {('a', 1), ('a', 2), ('b', 2)}) self.assertEqual(d1.items() | d3.items(), {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) self.assertEqual(d1.items() | set(d1.items()), {('a', 1), ('b', 2)}) self.assertEqual(d1.items() | set(d2.items()), {('a', 1), ('a', 2), ('b', 2)}) self.assertEqual(d1.items() | set(d3.items()), {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) self.assertEqual(d1.items() ^ d1.items(), set()) self.assertEqual(d1.items() ^ d2.items(), {('a', 1), ('a', 2)}) self.assertEqual(d1.items() ^ d3.items(), {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) self.assertEqual(d1.items() - d1.items(), set()) self.assertEqual(d1.items() - d2.items(), {('a', 1)}) self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)}) self.assertEqual(d1.items() - set(d1.items()), set()) self.assertEqual(d1.items() - set(d2.items()), {('a', 1)}) self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)}) self.assertFalse(d1.items().isdisjoint(d1.items())) self.assertFalse(d1.items().isdisjoint(d2.items())) self.assertFalse(d1.items().isdisjoint(list(d2.items()))) self.assertFalse(d1.items().isdisjoint(set(d2.items()))) self.assertTrue(d1.items().isdisjoint({'x', 'y', 'z'})) self.assertTrue(d1.items().isdisjoint(['x', 'y', 'z'])) self.assertTrue(d1.items().isdisjoint(set(['x', 'y', 'z']))) self.assertTrue(d1.items().isdisjoint(set(['x', 'y']))) self.assertTrue(d1.items().isdisjoint({})) self.assertTrue(d1.items().isdisjoint(d3.items())) de = {} self.assertTrue(de.items().isdisjoint(set())) self.assertTrue(de.items().isdisjoint([])) self.assertTrue(de.items().isdisjoint(de.items())) self.assertTrue(de.items().isdisjoint([1])) def test_recursive_repr(self): d = {} d[42] = d.values() r = repr(d) # Cannot perform a stronger test, as the contents of the repr # are implementation-dependent. All we can say is that we # want a str result, not an exception of any sort. self.assertIsInstance(r, str) d[42] = d.items() r = repr(d) # Again. self.assertIsInstance(r, str) def test_deeply_nested_repr(self): d = {} for i in range(sys.getrecursionlimit() + 100): d = {42: d.values()} self.assertRaises(RecursionError, repr, d) def test_copy(self): d = {1: 10, "a": "ABC"} self.assertRaises(TypeError, copy.copy, d.keys()) self.assertRaises(TypeError, copy.copy, d.values()) self.assertRaises(TypeError, copy.copy, d.items()) def test_compare_error(self): class Exc(Exception): pass class BadEq: def __hash__(self): return 7 def __eq__(self, other): raise Exc k1, k2 = BadEq(), BadEq() v1, v2 = BadEq(), BadEq() d = {k1: v1} self.assertIn(k1, d) self.assertIn(k1, d.keys()) self.assertIn(v1, d.values()) self.assertIn((k1, v1), d.items()) self.assertRaises(Exc, d.__contains__, k2) self.assertRaises(Exc, d.keys().__contains__, k2) self.assertRaises(Exc, d.items().__contains__, (k2, v1)) self.assertRaises(Exc, d.items().__contains__, (k1, v2)) with self.assertRaises(Exc): v2 in d.values() def test_pickle(self): d = {1: 10, "a": "ABC"} for proto in range(pickle.HIGHEST_PROTOCOL + 1): self.assertRaises((TypeError, pickle.PicklingError), pickle.dumps, d.keys(), proto) self.assertRaises((TypeError, pickle.PicklingError), pickle.dumps, d.values(), proto) self.assertRaises((TypeError, pickle.PicklingError), pickle.dumps, d.items(), proto) def test_abc_registry(self): d = dict(a=1) self.assertIsInstance(d.keys(), collections.abc.KeysView) self.assertIsInstance(d.keys(), collections.abc.MappingView) self.assertIsInstance(d.keys(), collections.abc.Set) self.assertIsInstance(d.keys(), collections.abc.Sized) self.assertIsInstance(d.keys(), collections.abc.Iterable) self.assertIsInstance(d.keys(), collections.abc.Container) self.assertIsInstance(d.values(), collections.abc.ValuesView) self.assertIsInstance(d.values(), collections.abc.MappingView) self.assertIsInstance(d.values(), collections.abc.Sized) self.assertIsInstance(d.items(), collections.abc.ItemsView) self.assertIsInstance(d.items(), collections.abc.MappingView) self.assertIsInstance(d.items(), collections.abc.Set) self.assertIsInstance(d.items(), collections.abc.Sized) self.assertIsInstance(d.items(), collections.abc.Iterable) self.assertIsInstance(d.items(), collections.abc.Container) if __name__ == "__main__": unittest.main()