Serhiy Storchaka | d7a4415 | 2015-11-12 11:23:04 +0200 | [diff] [blame] | 1 | import copy |
| 2 | import pickle |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 3 | import unittest |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 4 | |
| 5 | class DictSetTest(unittest.TestCase): |
| 6 | |
Guido van Rossum | 3ac6741 | 2007-02-10 18:55:06 +0000 | [diff] [blame] | 7 | def test_constructors_not_callable(self): |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 8 | kt = type({}.keys()) |
Guido van Rossum | 3ac6741 | 2007-02-10 18:55:06 +0000 | [diff] [blame] | 9 | self.assertRaises(TypeError, kt, {}) |
| 10 | self.assertRaises(TypeError, kt) |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 11 | it = type({}.items()) |
Guido van Rossum | 3ac6741 | 2007-02-10 18:55:06 +0000 | [diff] [blame] | 12 | self.assertRaises(TypeError, it, {}) |
| 13 | self.assertRaises(TypeError, it) |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 14 | vt = type({}.values()) |
Guido van Rossum | 3ac6741 | 2007-02-10 18:55:06 +0000 | [diff] [blame] | 15 | self.assertRaises(TypeError, vt, {}) |
| 16 | self.assertRaises(TypeError, vt) |
| 17 | |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 18 | def test_dict_keys(self): |
| 19 | d = {1: 10, "a": "ABC"} |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 20 | keys = d.keys() |
Guido van Rossum | 83825ac | 2007-02-10 04:54:19 +0000 | [diff] [blame] | 21 | self.assertEqual(len(keys), 2) |
Guido van Rossum | d9214d1 | 2007-02-12 02:23:40 +0000 | [diff] [blame] | 22 | self.assertEqual(set(keys), {1, "a"}) |
| 23 | self.assertEqual(keys, {1, "a"}) |
| 24 | self.assertNotEqual(keys, {1, "a", "b"}) |
| 25 | self.assertNotEqual(keys, {1, "b"}) |
| 26 | self.assertNotEqual(keys, {1}) |
| 27 | self.assertNotEqual(keys, 42) |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 28 | self.assertIn(1, keys) |
| 29 | self.assertIn("a", keys) |
| 30 | self.assertNotIn(10, keys) |
| 31 | self.assertNotIn("Z", keys) |
Guido van Rossum | d9214d1 | 2007-02-12 02:23:40 +0000 | [diff] [blame] | 32 | self.assertEqual(d.keys(), d.keys()) |
| 33 | e = {1: 11, "a": "def"} |
| 34 | self.assertEqual(d.keys(), e.keys()) |
| 35 | del e["a"] |
| 36 | self.assertNotEqual(d.keys(), e.keys()) |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 37 | |
| 38 | def test_dict_items(self): |
| 39 | d = {1: 10, "a": "ABC"} |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 40 | items = d.items() |
Guido van Rossum | 83825ac | 2007-02-10 04:54:19 +0000 | [diff] [blame] | 41 | self.assertEqual(len(items), 2) |
Guido van Rossum | d9214d1 | 2007-02-12 02:23:40 +0000 | [diff] [blame] | 42 | self.assertEqual(set(items), {(1, 10), ("a", "ABC")}) |
| 43 | self.assertEqual(items, {(1, 10), ("a", "ABC")}) |
| 44 | self.assertNotEqual(items, {(1, 10), ("a", "ABC"), "junk"}) |
| 45 | self.assertNotEqual(items, {(1, 10), ("a", "def")}) |
| 46 | self.assertNotEqual(items, {(1, 10)}) |
| 47 | self.assertNotEqual(items, 42) |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 48 | self.assertIn((1, 10), items) |
| 49 | self.assertIn(("a", "ABC"), items) |
| 50 | self.assertNotIn((1, 11), items) |
| 51 | self.assertNotIn(1, items) |
| 52 | self.assertNotIn((), items) |
| 53 | self.assertNotIn((1,), items) |
| 54 | self.assertNotIn((1, 2, 3), items) |
Guido van Rossum | d9214d1 | 2007-02-12 02:23:40 +0000 | [diff] [blame] | 55 | self.assertEqual(d.items(), d.items()) |
| 56 | e = d.copy() |
| 57 | self.assertEqual(d.items(), e.items()) |
| 58 | e["a"] = "def" |
| 59 | self.assertNotEqual(d.items(), e.items()) |
| 60 | |
| 61 | def test_dict_mixed_keys_items(self): |
| 62 | d = {(1, 1): 11, (2, 2): 22} |
| 63 | e = {1: 1, 2: 2} |
| 64 | self.assertEqual(d.keys(), e.items()) |
| 65 | self.assertNotEqual(d.items(), e.keys()) |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 66 | |
| 67 | def test_dict_values(self): |
| 68 | d = {1: 10, "a": "ABC"} |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 69 | values = d.values() |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 70 | self.assertEqual(set(values), {10, "ABC"}) |
Guido van Rossum | 83825ac | 2007-02-10 04:54:19 +0000 | [diff] [blame] | 71 | self.assertEqual(len(values), 2) |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 72 | |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 73 | def test_dict_repr(self): |
| 74 | d = {1: 10, "a": "ABC"} |
| 75 | self.assertIsInstance(repr(d), str) |
| 76 | r = repr(d.items()) |
| 77 | self.assertIsInstance(r, str) |
| 78 | self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or |
| 79 | r == "dict_items([(1, 10), ('a', 'ABC')])") |
| 80 | r = repr(d.keys()) |
| 81 | self.assertIsInstance(r, str) |
| 82 | self.assertTrue(r == "dict_keys(['a', 1])" or |
| 83 | r == "dict_keys([1, 'a'])") |
| 84 | r = repr(d.values()) |
| 85 | self.assertIsInstance(r, str) |
| 86 | self.assertTrue(r == "dict_values(['ABC', 10])" or |
| 87 | r == "dict_values([10, 'ABC'])") |
| 88 | |
| 89 | def test_keys_set_operations(self): |
| 90 | d1 = {'a': 1, 'b': 2} |
| 91 | d2 = {'b': 3, 'c': 2} |
| 92 | d3 = {'d': 4, 'e': 5} |
| 93 | self.assertEqual(d1.keys() & d1.keys(), {'a', 'b'}) |
| 94 | self.assertEqual(d1.keys() & d2.keys(), {'b'}) |
| 95 | self.assertEqual(d1.keys() & d3.keys(), set()) |
| 96 | self.assertEqual(d1.keys() & set(d1.keys()), {'a', 'b'}) |
| 97 | self.assertEqual(d1.keys() & set(d2.keys()), {'b'}) |
| 98 | self.assertEqual(d1.keys() & set(d3.keys()), set()) |
Benjamin Peterson | f11b25b | 2016-03-03 22:05:36 -0800 | [diff] [blame] | 99 | self.assertEqual(d1.keys() & tuple(d1.keys()), {'a', 'b'}) |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 100 | |
| 101 | self.assertEqual(d1.keys() | d1.keys(), {'a', 'b'}) |
| 102 | self.assertEqual(d1.keys() | d2.keys(), {'a', 'b', 'c'}) |
| 103 | self.assertEqual(d1.keys() | d3.keys(), {'a', 'b', 'd', 'e'}) |
| 104 | self.assertEqual(d1.keys() | set(d1.keys()), {'a', 'b'}) |
| 105 | self.assertEqual(d1.keys() | set(d2.keys()), {'a', 'b', 'c'}) |
| 106 | self.assertEqual(d1.keys() | set(d3.keys()), |
| 107 | {'a', 'b', 'd', 'e'}) |
Benjamin Peterson | f11b25b | 2016-03-03 22:05:36 -0800 | [diff] [blame] | 108 | self.assertEqual(d1.keys() | (1, 2), {'a', 'b', 1, 2}) |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 109 | |
| 110 | self.assertEqual(d1.keys() ^ d1.keys(), set()) |
| 111 | self.assertEqual(d1.keys() ^ d2.keys(), {'a', 'c'}) |
| 112 | self.assertEqual(d1.keys() ^ d3.keys(), {'a', 'b', 'd', 'e'}) |
| 113 | self.assertEqual(d1.keys() ^ set(d1.keys()), set()) |
| 114 | self.assertEqual(d1.keys() ^ set(d2.keys()), {'a', 'c'}) |
| 115 | self.assertEqual(d1.keys() ^ set(d3.keys()), |
| 116 | {'a', 'b', 'd', 'e'}) |
Benjamin Peterson | f11b25b | 2016-03-03 22:05:36 -0800 | [diff] [blame] | 117 | self.assertEqual(d1.keys() ^ tuple(d2.keys()), {'a', 'c'}) |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 118 | |
Ezio Melotti | 2532635 | 2013-08-08 20:12:28 +0300 | [diff] [blame] | 119 | self.assertEqual(d1.keys() - d1.keys(), set()) |
| 120 | self.assertEqual(d1.keys() - d2.keys(), {'a'}) |
| 121 | self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'}) |
| 122 | self.assertEqual(d1.keys() - set(d1.keys()), set()) |
| 123 | self.assertEqual(d1.keys() - set(d2.keys()), {'a'}) |
| 124 | self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'}) |
Benjamin Peterson | f11b25b | 2016-03-03 22:05:36 -0800 | [diff] [blame] | 125 | self.assertEqual(d1.keys() - (0, 1), {'a', 'b'}) |
Ezio Melotti | 2532635 | 2013-08-08 20:12:28 +0300 | [diff] [blame] | 126 | |
Daniel Stutzbach | 045b3ba | 2010-09-02 15:06:06 +0000 | [diff] [blame] | 127 | self.assertFalse(d1.keys().isdisjoint(d1.keys())) |
| 128 | self.assertFalse(d1.keys().isdisjoint(d2.keys())) |
| 129 | self.assertFalse(d1.keys().isdisjoint(list(d2.keys()))) |
| 130 | self.assertFalse(d1.keys().isdisjoint(set(d2.keys()))) |
| 131 | self.assertTrue(d1.keys().isdisjoint({'x', 'y', 'z'})) |
| 132 | self.assertTrue(d1.keys().isdisjoint(['x', 'y', 'z'])) |
| 133 | self.assertTrue(d1.keys().isdisjoint(set(['x', 'y', 'z']))) |
| 134 | self.assertTrue(d1.keys().isdisjoint(set(['x', 'y']))) |
| 135 | self.assertTrue(d1.keys().isdisjoint(['x', 'y'])) |
| 136 | self.assertTrue(d1.keys().isdisjoint({})) |
| 137 | self.assertTrue(d1.keys().isdisjoint(d3.keys())) |
| 138 | |
| 139 | de = {} |
| 140 | self.assertTrue(de.keys().isdisjoint(set())) |
| 141 | self.assertTrue(de.keys().isdisjoint([])) |
| 142 | self.assertTrue(de.keys().isdisjoint(de.keys())) |
| 143 | self.assertTrue(de.keys().isdisjoint([1])) |
| 144 | |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 145 | def test_items_set_operations(self): |
| 146 | d1 = {'a': 1, 'b': 2} |
| 147 | d2 = {'a': 2, 'b': 2} |
| 148 | d3 = {'d': 4, 'e': 5} |
| 149 | self.assertEqual( |
| 150 | d1.items() & d1.items(), {('a', 1), ('b', 2)}) |
| 151 | self.assertEqual(d1.items() & d2.items(), {('b', 2)}) |
| 152 | self.assertEqual(d1.items() & d3.items(), set()) |
| 153 | self.assertEqual(d1.items() & set(d1.items()), |
| 154 | {('a', 1), ('b', 2)}) |
| 155 | self.assertEqual(d1.items() & set(d2.items()), {('b', 2)}) |
| 156 | self.assertEqual(d1.items() & set(d3.items()), set()) |
| 157 | |
| 158 | self.assertEqual(d1.items() | d1.items(), |
| 159 | {('a', 1), ('b', 2)}) |
| 160 | self.assertEqual(d1.items() | d2.items(), |
| 161 | {('a', 1), ('a', 2), ('b', 2)}) |
| 162 | self.assertEqual(d1.items() | d3.items(), |
| 163 | {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 164 | self.assertEqual(d1.items() | set(d1.items()), |
| 165 | {('a', 1), ('b', 2)}) |
| 166 | self.assertEqual(d1.items() | set(d2.items()), |
| 167 | {('a', 1), ('a', 2), ('b', 2)}) |
| 168 | self.assertEqual(d1.items() | set(d3.items()), |
| 169 | {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 170 | |
| 171 | self.assertEqual(d1.items() ^ d1.items(), set()) |
| 172 | self.assertEqual(d1.items() ^ d2.items(), |
| 173 | {('a', 1), ('a', 2)}) |
| 174 | self.assertEqual(d1.items() ^ d3.items(), |
| 175 | {('a', 1), ('b', 2), ('d', 4), ('e', 5)}) |
| 176 | |
Ezio Melotti | 2532635 | 2013-08-08 20:12:28 +0300 | [diff] [blame] | 177 | self.assertEqual(d1.items() - d1.items(), set()) |
| 178 | self.assertEqual(d1.items() - d2.items(), {('a', 1)}) |
| 179 | self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)}) |
| 180 | self.assertEqual(d1.items() - set(d1.items()), set()) |
| 181 | self.assertEqual(d1.items() - set(d2.items()), {('a', 1)}) |
| 182 | self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)}) |
| 183 | |
Daniel Stutzbach | 045b3ba | 2010-09-02 15:06:06 +0000 | [diff] [blame] | 184 | self.assertFalse(d1.items().isdisjoint(d1.items())) |
| 185 | self.assertFalse(d1.items().isdisjoint(d2.items())) |
| 186 | self.assertFalse(d1.items().isdisjoint(list(d2.items()))) |
| 187 | self.assertFalse(d1.items().isdisjoint(set(d2.items()))) |
| 188 | self.assertTrue(d1.items().isdisjoint({'x', 'y', 'z'})) |
| 189 | self.assertTrue(d1.items().isdisjoint(['x', 'y', 'z'])) |
| 190 | self.assertTrue(d1.items().isdisjoint(set(['x', 'y', 'z']))) |
| 191 | self.assertTrue(d1.items().isdisjoint(set(['x', 'y']))) |
| 192 | self.assertTrue(d1.items().isdisjoint({})) |
| 193 | self.assertTrue(d1.items().isdisjoint(d3.items())) |
| 194 | |
| 195 | de = {} |
| 196 | self.assertTrue(de.items().isdisjoint(set())) |
| 197 | self.assertTrue(de.items().isdisjoint([])) |
| 198 | self.assertTrue(de.items().isdisjoint(de.items())) |
| 199 | self.assertTrue(de.items().isdisjoint([1])) |
| 200 | |
Benjamin Peterson | 611d901 | 2013-05-19 19:39:38 -0700 | [diff] [blame] | 201 | def test_recursive_repr(self): |
| 202 | d = {} |
| 203 | d[42] = d.values() |
Yury Selivanov | f488fb4 | 2015-07-03 01:04:23 -0400 | [diff] [blame] | 204 | self.assertRaises(RecursionError, repr, d) |
Benjamin Peterson | 611d901 | 2013-05-19 19:39:38 -0700 | [diff] [blame] | 205 | |
Serhiy Storchaka | d7a4415 | 2015-11-12 11:23:04 +0200 | [diff] [blame] | 206 | def test_copy(self): |
| 207 | d = {1: 10, "a": "ABC"} |
| 208 | self.assertRaises(TypeError, copy.copy, d.keys()) |
| 209 | self.assertRaises(TypeError, copy.copy, d.values()) |
| 210 | self.assertRaises(TypeError, copy.copy, d.items()) |
| 211 | |
| 212 | def test_pickle(self): |
| 213 | d = {1: 10, "a": "ABC"} |
| 214 | for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| 215 | self.assertRaises((TypeError, pickle.PicklingError), |
| 216 | pickle.dumps, d.keys(), proto) |
| 217 | self.assertRaises((TypeError, pickle.PicklingError), |
| 218 | pickle.dumps, d.values(), proto) |
| 219 | self.assertRaises((TypeError, pickle.PicklingError), |
| 220 | pickle.dumps, d.items(), proto) |
| 221 | |
Alexandre Vassalotti | a714257 | 2010-05-04 03:41:49 +0000 | [diff] [blame] | 222 | |
Guido van Rossum | b90c848 | 2007-02-10 01:11:45 +0000 | [diff] [blame] | 223 | if __name__ == "__main__": |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 224 | unittest.main() |