Python code coverage for Lib/test/test_set.py

#	count	content
1	n/a	import unittest
2	n/a	from test import support
3	n/a	import gc
4	n/a	import weakref
5	n/a	import operator
6	n/a	import copy
7	n/a	import pickle
8	n/a	from random import randrange, shuffle
9	n/a	import warnings
10	n/a	import collections
11	n/a	import collections.abc
12	n/a	import itertools
13	n/a
14	n/a	class PassThru(Exception):
15	n/a	pass
16	n/a
17	n/a	def check_pass_thru():
18	n/a	raise PassThru
19	n/a	yield 1
20	n/a
21	n/a	class BadCmp:
22	n/a	def __hash__(self):
23	n/a	return 1
24	n/a	def __eq__(self, other):
25	n/a	raise RuntimeError
26	n/a
27	n/a	class ReprWrapper:
28	n/a	'Used to test self-referential repr() calls'
29	n/a	def __repr__(self):
30	n/a	return repr(self.value)
31	n/a
32	n/a	class HashCountingInt(int):
33	n/a	'int-like object that counts the number of times __hash__ is called'
34	n/a	def __init__(self, *args):
35	n/a	self.hash_count = 0
36	n/a	def __hash__(self):
37	n/a	self.hash_count += 1
38	n/a	return int.__hash__(self)
39	n/a
40	n/a	class TestJointOps:
41	n/a	# Tests common to both set and frozenset
42	n/a
43	n/a	def setUp(self):
44	n/a	self.word = word = 'simsalabim'
45	n/a	self.otherword = 'madagascar'
46	n/a	self.letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
47	n/a	self.s = self.thetype(word)
48	n/a	self.d = dict.fromkeys(word)
49	n/a
50	n/a	def test_new_or_init(self):
51	n/a	self.assertRaises(TypeError, self.thetype, [], 2)
52	n/a	self.assertRaises(TypeError, set().__init__, a=1)
53	n/a
54	n/a	def test_uniquification(self):
55	n/a	actual = sorted(self.s)
56	n/a	expected = sorted(self.d)
57	n/a	self.assertEqual(actual, expected)
58	n/a	self.assertRaises(PassThru, self.thetype, check_pass_thru())
59	n/a	self.assertRaises(TypeError, self.thetype, [[]])
60	n/a
61	n/a	def test_len(self):
62	n/a	self.assertEqual(len(self.s), len(self.d))
63	n/a
64	n/a	def test_contains(self):
65	n/a	for c in self.letters:
66	n/a	self.assertEqual(c in self.s, c in self.d)
67	n/a	self.assertRaises(TypeError, self.s.__contains__, [[]])
68	n/a	s = self.thetype([frozenset(self.letters)])
69	n/a	self.assertIn(self.thetype(self.letters), s)
70	n/a
71	n/a	def test_union(self):
72	n/a	u = self.s.union(self.otherword)
73	n/a	for c in self.letters:
74	n/a	self.assertEqual(c in u, c in self.d or c in self.otherword)
75	n/a	self.assertEqual(self.s, self.thetype(self.word))
76	n/a	self.assertEqual(type(u), self.basetype)
77	n/a	self.assertRaises(PassThru, self.s.union, check_pass_thru())
78	n/a	self.assertRaises(TypeError, self.s.union, [[]])
79	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
80	n/a	self.assertEqual(self.thetype('abcba').union(C('cdc')), set('abcd'))
81	n/a	self.assertEqual(self.thetype('abcba').union(C('efgfe')), set('abcefg'))
82	n/a	self.assertEqual(self.thetype('abcba').union(C('ccb')), set('abc'))
83	n/a	self.assertEqual(self.thetype('abcba').union(C('ef')), set('abcef'))
84	n/a	self.assertEqual(self.thetype('abcba').union(C('ef'), C('fg')), set('abcefg'))
85	n/a
86	n/a	# Issue #6573
87	n/a	x = self.thetype()
88	n/a	self.assertEqual(x.union(set([1]), x, set([2])), self.thetype([1, 2]))
89	n/a
90	n/a	def test_or(self):
91	n/a	i = self.s.union(self.otherword)
92	n/a	self.assertEqual(self.s \| set(self.otherword), i)
93	n/a	self.assertEqual(self.s \| frozenset(self.otherword), i)
94	n/a	try:
95	n/a	self.s \| self.otherword
96	n/a	except TypeError:
97	n/a	pass
98	n/a	else:
99	n/a	self.fail("s\|t did not screen-out general iterables")
100	n/a
101	n/a	def test_intersection(self):
102	n/a	i = self.s.intersection(self.otherword)
103	n/a	for c in self.letters:
104	n/a	self.assertEqual(c in i, c in self.d and c in self.otherword)
105	n/a	self.assertEqual(self.s, self.thetype(self.word))
106	n/a	self.assertEqual(type(i), self.basetype)
107	n/a	self.assertRaises(PassThru, self.s.intersection, check_pass_thru())
108	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
109	n/a	self.assertEqual(self.thetype('abcba').intersection(C('cdc')), set('cc'))
110	n/a	self.assertEqual(self.thetype('abcba').intersection(C('efgfe')), set(''))
111	n/a	self.assertEqual(self.thetype('abcba').intersection(C('ccb')), set('bc'))
112	n/a	self.assertEqual(self.thetype('abcba').intersection(C('ef')), set(''))
113	n/a	self.assertEqual(self.thetype('abcba').intersection(C('cbcf'), C('bag')), set('b'))
114	n/a	s = self.thetype('abcba')
115	n/a	z = s.intersection()
116	n/a	if self.thetype == frozenset():
117	n/a	self.assertEqual(id(s), id(z))
118	n/a	else:
119	n/a	self.assertNotEqual(id(s), id(z))
120	n/a
121	n/a	def test_isdisjoint(self):
122	n/a	def f(s1, s2):
123	n/a	'Pure python equivalent of isdisjoint()'
124	n/a	return not set(s1).intersection(s2)
125	n/a	for larg in '', 'a', 'ab', 'abc', 'ababac', 'cdc', 'cc', 'efgfe', 'ccb', 'ef':
126	n/a	s1 = self.thetype(larg)
127	n/a	for rarg in '', 'a', 'ab', 'abc', 'ababac', 'cdc', 'cc', 'efgfe', 'ccb', 'ef':
128	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
129	n/a	s2 = C(rarg)
130	n/a	actual = s1.isdisjoint(s2)
131	n/a	expected = f(s1, s2)
132	n/a	self.assertEqual(actual, expected)
133	n/a	self.assertTrue(actual is True or actual is False)
134	n/a
135	n/a	def test_and(self):
136	n/a	i = self.s.intersection(self.otherword)
137	n/a	self.assertEqual(self.s & set(self.otherword), i)
138	n/a	self.assertEqual(self.s & frozenset(self.otherword), i)
139	n/a	try:
140	n/a	self.s & self.otherword
141	n/a	except TypeError:
142	n/a	pass
143	n/a	else:
144	n/a	self.fail("s&t did not screen-out general iterables")
145	n/a
146	n/a	def test_difference(self):
147	n/a	i = self.s.difference(self.otherword)
148	n/a	for c in self.letters:
149	n/a	self.assertEqual(c in i, c in self.d and c not in self.otherword)
150	n/a	self.assertEqual(self.s, self.thetype(self.word))
151	n/a	self.assertEqual(type(i), self.basetype)
152	n/a	self.assertRaises(PassThru, self.s.difference, check_pass_thru())
153	n/a	self.assertRaises(TypeError, self.s.difference, [[]])
154	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
155	n/a	self.assertEqual(self.thetype('abcba').difference(C('cdc')), set('ab'))
156	n/a	self.assertEqual(self.thetype('abcba').difference(C('efgfe')), set('abc'))
157	n/a	self.assertEqual(self.thetype('abcba').difference(C('ccb')), set('a'))
158	n/a	self.assertEqual(self.thetype('abcba').difference(C('ef')), set('abc'))
159	n/a	self.assertEqual(self.thetype('abcba').difference(), set('abc'))
160	n/a	self.assertEqual(self.thetype('abcba').difference(C('a'), C('b')), set('c'))
161	n/a
162	n/a	def test_sub(self):
163	n/a	i = self.s.difference(self.otherword)
164	n/a	self.assertEqual(self.s - set(self.otherword), i)
165	n/a	self.assertEqual(self.s - frozenset(self.otherword), i)
166	n/a	try:
167	n/a	self.s - self.otherword
168	n/a	except TypeError:
169	n/a	pass
170	n/a	else:
171	n/a	self.fail("s-t did not screen-out general iterables")
172	n/a
173	n/a	def test_symmetric_difference(self):
174	n/a	i = self.s.symmetric_difference(self.otherword)
175	n/a	for c in self.letters:
176	n/a	self.assertEqual(c in i, (c in self.d) ^ (c in self.otherword))
177	n/a	self.assertEqual(self.s, self.thetype(self.word))
178	n/a	self.assertEqual(type(i), self.basetype)
179	n/a	self.assertRaises(PassThru, self.s.symmetric_difference, check_pass_thru())
180	n/a	self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
181	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
182	n/a	self.assertEqual(self.thetype('abcba').symmetric_difference(C('cdc')), set('abd'))
183	n/a	self.assertEqual(self.thetype('abcba').symmetric_difference(C('efgfe')), set('abcefg'))
184	n/a	self.assertEqual(self.thetype('abcba').symmetric_difference(C('ccb')), set('a'))
185	n/a	self.assertEqual(self.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))
186	n/a
187	n/a	def test_xor(self):
188	n/a	i = self.s.symmetric_difference(self.otherword)
189	n/a	self.assertEqual(self.s ^ set(self.otherword), i)
190	n/a	self.assertEqual(self.s ^ frozenset(self.otherword), i)
191	n/a	try:
192	n/a	self.s ^ self.otherword
193	n/a	except TypeError:
194	n/a	pass
195	n/a	else:
196	n/a	self.fail("s^t did not screen-out general iterables")
197	n/a
198	n/a	def test_equality(self):
199	n/a	self.assertEqual(self.s, set(self.word))
200	n/a	self.assertEqual(self.s, frozenset(self.word))
201	n/a	self.assertEqual(self.s == self.word, False)
202	n/a	self.assertNotEqual(self.s, set(self.otherword))
203	n/a	self.assertNotEqual(self.s, frozenset(self.otherword))
204	n/a	self.assertEqual(self.s != self.word, True)
205	n/a
206	n/a	def test_setOfFrozensets(self):
207	n/a	t = map(frozenset, ['abcdef', 'bcd', 'bdcb', 'fed', 'fedccba'])
208	n/a	s = self.thetype(t)
209	n/a	self.assertEqual(len(s), 3)
210	n/a
211	n/a	def test_sub_and_super(self):
212	n/a	p, q, r = map(self.thetype, ['ab', 'abcde', 'def'])
213	n/a	self.assertTrue(p < q)
214	n/a	self.assertTrue(p <= q)
215	n/a	self.assertTrue(q <= q)
216	n/a	self.assertTrue(q > p)
217	n/a	self.assertTrue(q >= p)
218	n/a	self.assertFalse(q < r)
219	n/a	self.assertFalse(q <= r)
220	n/a	self.assertFalse(q > r)
221	n/a	self.assertFalse(q >= r)
222	n/a	self.assertTrue(set('a').issubset('abc'))
223	n/a	self.assertTrue(set('abc').issuperset('a'))
224	n/a	self.assertFalse(set('a').issubset('cbs'))
225	n/a	self.assertFalse(set('cbs').issuperset('a'))
226	n/a
227	n/a	def test_pickling(self):
228	n/a	for i in range(pickle.HIGHEST_PROTOCOL + 1):
229	n/a	p = pickle.dumps(self.s, i)
230	n/a	dup = pickle.loads(p)
231	n/a	self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup))
232	n/a	if type(self.s) not in (set, frozenset):
233	n/a	self.s.x = 10
234	n/a	p = pickle.dumps(self.s, i)
235	n/a	dup = pickle.loads(p)
236	n/a	self.assertEqual(self.s.x, dup.x)
237	n/a
238	n/a	def test_iterator_pickling(self):
239	n/a	for proto in range(pickle.HIGHEST_PROTOCOL + 1):
240	n/a	itorg = iter(self.s)
241	n/a	data = self.thetype(self.s)
242	n/a	d = pickle.dumps(itorg, proto)
243	n/a	it = pickle.loads(d)
244	n/a	# Set iterators unpickle as list iterators due to the
245	n/a	# undefined order of set items.
246	n/a	# self.assertEqual(type(itorg), type(it))
247	n/a	self.assertIsInstance(it, collections.abc.Iterator)
248	n/a	self.assertEqual(self.thetype(it), data)
249	n/a
250	n/a	it = pickle.loads(d)
251	n/a	try:
252	n/a	drop = next(it)
253	n/a	except StopIteration:
254	n/a	continue
255	n/a	d = pickle.dumps(it, proto)
256	n/a	it = pickle.loads(d)
257	n/a	self.assertEqual(self.thetype(it), data - self.thetype((drop,)))
258	n/a
259	n/a	def test_deepcopy(self):
260	n/a	class Tracer:
261	n/a	def __init__(self, value):
262	n/a	self.value = value
263	n/a	def __hash__(self):
264	n/a	return self.value
265	n/a	def __deepcopy__(self, memo=None):
266	n/a	return Tracer(self.value + 1)
267	n/a	t = Tracer(10)
268	n/a	s = self.thetype([t])
269	n/a	dup = copy.deepcopy(s)
270	n/a	self.assertNotEqual(id(s), id(dup))
271	n/a	for elem in dup:
272	n/a	newt = elem
273	n/a	self.assertNotEqual(id(t), id(newt))
274	n/a	self.assertEqual(t.value + 1, newt.value)
275	n/a
276	n/a	def test_gc(self):
277	n/a	# Create a nest of cycles to exercise overall ref count check
278	n/a	class A:
279	n/a	pass
280	n/a	s = set(A() for i in range(1000))
281	n/a	for elem in s:
282	n/a	elem.cycle = s
283	n/a	elem.sub = elem
284	n/a	elem.set = set([elem])
285	n/a
286	n/a	def test_subclass_with_custom_hash(self):
287	n/a	# Bug #1257731
288	n/a	class H(self.thetype):
289	n/a	def __hash__(self):
290	n/a	return int(id(self) & 0x7fffffff)
291	n/a	s=H()
292	n/a	f=set()
293	n/a	f.add(s)
294	n/a	self.assertIn(s, f)
295	n/a	f.remove(s)
296	n/a	f.add(s)
297	n/a	f.discard(s)
298	n/a
299	n/a	def test_badcmp(self):
300	n/a	s = self.thetype([BadCmp()])
301	n/a	# Detect comparison errors during insertion and lookup
302	n/a	self.assertRaises(RuntimeError, self.thetype, [BadCmp(), BadCmp()])
303	n/a	self.assertRaises(RuntimeError, s.__contains__, BadCmp())
304	n/a	# Detect errors during mutating operations
305	n/a	if hasattr(s, 'add'):
306	n/a	self.assertRaises(RuntimeError, s.add, BadCmp())
307	n/a	self.assertRaises(RuntimeError, s.discard, BadCmp())
308	n/a	self.assertRaises(RuntimeError, s.remove, BadCmp())
309	n/a
310	n/a	def test_cyclical_repr(self):
311	n/a	w = ReprWrapper()
312	n/a	s = self.thetype([w])
313	n/a	w.value = s
314	n/a	if self.thetype == set:
315	n/a	self.assertEqual(repr(s), '{set(...)}')
316	n/a	else:
317	n/a	name = repr(s).partition('(')[0] # strip class name
318	n/a	self.assertEqual(repr(s), '%s({%s(...)})' % (name, name))
319	n/a
320	n/a	def test_cyclical_print(self):
321	n/a	w = ReprWrapper()
322	n/a	s = self.thetype([w])
323	n/a	w.value = s
324	n/a	fo = open(support.TESTFN, "w")
325	n/a	try:
326	n/a	fo.write(str(s))
327	n/a	fo.close()
328	n/a	fo = open(support.TESTFN, "r")
329	n/a	self.assertEqual(fo.read(), repr(s))
330	n/a	finally:
331	n/a	fo.close()
332	n/a	support.unlink(support.TESTFN)
333	n/a
334	n/a	def test_do_not_rehash_dict_keys(self):
335	n/a	n = 10
336	n/a	d = dict.fromkeys(map(HashCountingInt, range(n)))
337	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
338	n/a	s = self.thetype(d)
339	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
340	n/a	s.difference(d)
341	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
342	n/a	if hasattr(s, 'symmetric_difference_update'):
343	n/a	s.symmetric_difference_update(d)
344	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
345	n/a	d2 = dict.fromkeys(set(d))
346	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
347	n/a	d3 = dict.fromkeys(frozenset(d))
348	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
349	n/a	d3 = dict.fromkeys(frozenset(d), 123)
350	n/a	self.assertEqual(sum(elem.hash_count for elem in d), n)
351	n/a	self.assertEqual(d3, dict.fromkeys(d, 123))
352	n/a
353	n/a	def test_container_iterator(self):
354	n/a	# Bug #3680: tp_traverse was not implemented for set iterator object
355	n/a	class C(object):
356	n/a	pass
357	n/a	obj = C()
358	n/a	ref = weakref.ref(obj)
359	n/a	container = set([obj, 1])
360	n/a	obj.x = iter(container)
361	n/a	del obj, container
362	n/a	gc.collect()
363	n/a	self.assertTrue(ref() is None, "Cycle was not collected")
364	n/a
365	n/a	def test_free_after_iterating(self):
366	n/a	support.check_free_after_iterating(self, iter, self.thetype)
367	n/a
368	n/a	class TestSet(TestJointOps, unittest.TestCase):
369	n/a	thetype = set
370	n/a	basetype = set
371	n/a
372	n/a	def test_init(self):
373	n/a	s = self.thetype()
374	n/a	s.__init__(self.word)
375	n/a	self.assertEqual(s, set(self.word))
376	n/a	s.__init__(self.otherword)
377	n/a	self.assertEqual(s, set(self.otherword))
378	n/a	self.assertRaises(TypeError, s.__init__, s, 2);
379	n/a	self.assertRaises(TypeError, s.__init__, 1);
380	n/a
381	n/a	def test_constructor_identity(self):
382	n/a	s = self.thetype(range(3))
383	n/a	t = self.thetype(s)
384	n/a	self.assertNotEqual(id(s), id(t))
385	n/a
386	n/a	def test_set_literal(self):
387	n/a	s = set([1,2,3])
388	n/a	t = {1,2,3}
389	n/a	self.assertEqual(s, t)
390	n/a
391	n/a	def test_set_literal_insertion_order(self):
392	n/a	# SF Issue #26020 -- Expect left to right insertion
393	n/a	s = {1, 1.0, True}
394	n/a	self.assertEqual(len(s), 1)
395	n/a	stored_value = s.pop()
396	n/a	self.assertEqual(type(stored_value), int)
397	n/a
398	n/a	def test_set_literal_evaluation_order(self):
399	n/a	# Expect left to right expression evaluation
400	n/a	events = []
401	n/a	def record(obj):
402	n/a	events.append(obj)
403	n/a	s = {record(1), record(2), record(3)}
404	n/a	self.assertEqual(events, [1, 2, 3])
405	n/a
406	n/a	def test_hash(self):
407	n/a	self.assertRaises(TypeError, hash, self.s)
408	n/a
409	n/a	def test_clear(self):
410	n/a	self.s.clear()
411	n/a	self.assertEqual(self.s, set())
412	n/a	self.assertEqual(len(self.s), 0)
413	n/a
414	n/a	def test_copy(self):
415	n/a	dup = self.s.copy()
416	n/a	self.assertEqual(self.s, dup)
417	n/a	self.assertNotEqual(id(self.s), id(dup))
418	n/a	self.assertEqual(type(dup), self.basetype)
419	n/a
420	n/a	def test_add(self):
421	n/a	self.s.add('Q')
422	n/a	self.assertIn('Q', self.s)
423	n/a	dup = self.s.copy()
424	n/a	self.s.add('Q')
425	n/a	self.assertEqual(self.s, dup)
426	n/a	self.assertRaises(TypeError, self.s.add, [])
427	n/a
428	n/a	def test_remove(self):
429	n/a	self.s.remove('a')
430	n/a	self.assertNotIn('a', self.s)
431	n/a	self.assertRaises(KeyError, self.s.remove, 'Q')
432	n/a	self.assertRaises(TypeError, self.s.remove, [])
433	n/a	s = self.thetype([frozenset(self.word)])
434	n/a	self.assertIn(self.thetype(self.word), s)
435	n/a	s.remove(self.thetype(self.word))
436	n/a	self.assertNotIn(self.thetype(self.word), s)
437	n/a	self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
438	n/a
439	n/a	def test_remove_keyerror_unpacking(self):
440	n/a	# bug: www.python.org/sf/1576657
441	n/a	for v1 in ['Q', (1,)]:
442	n/a	try:
443	n/a	self.s.remove(v1)
444	n/a	except KeyError as e:
445	n/a	v2 = e.args[0]
446	n/a	self.assertEqual(v1, v2)
447	n/a	else:
448	n/a	self.fail()
449	n/a
450	n/a	def test_remove_keyerror_set(self):
451	n/a	key = self.thetype([3, 4])
452	n/a	try:
453	n/a	self.s.remove(key)
454	n/a	except KeyError as e:
455	n/a	self.assertTrue(e.args[0] is key,
456	n/a	"KeyError should be {0}, not {1}".format(key,
457	n/a	e.args[0]))
458	n/a	else:
459	n/a	self.fail()
460	n/a
461	n/a	def test_discard(self):
462	n/a	self.s.discard('a')
463	n/a	self.assertNotIn('a', self.s)
464	n/a	self.s.discard('Q')
465	n/a	self.assertRaises(TypeError, self.s.discard, [])
466	n/a	s = self.thetype([frozenset(self.word)])
467	n/a	self.assertIn(self.thetype(self.word), s)
468	n/a	s.discard(self.thetype(self.word))
469	n/a	self.assertNotIn(self.thetype(self.word), s)
470	n/a	s.discard(self.thetype(self.word))
471	n/a
472	n/a	def test_pop(self):
473	n/a	for i in range(len(self.s)):
474	n/a	elem = self.s.pop()
475	n/a	self.assertNotIn(elem, self.s)
476	n/a	self.assertRaises(KeyError, self.s.pop)
477	n/a
478	n/a	def test_update(self):
479	n/a	retval = self.s.update(self.otherword)
480	n/a	self.assertEqual(retval, None)
481	n/a	for c in (self.word + self.otherword):
482	n/a	self.assertIn(c, self.s)
483	n/a	self.assertRaises(PassThru, self.s.update, check_pass_thru())
484	n/a	self.assertRaises(TypeError, self.s.update, [[]])
485	n/a	for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):
486	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
487	n/a	s = self.thetype('abcba')
488	n/a	self.assertEqual(s.update(C(p)), None)
489	n/a	self.assertEqual(s, set(q))
490	n/a	for p in ('cdc', 'efgfe', 'ccb', 'ef', 'abcda'):
491	n/a	q = 'ahi'
492	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
493	n/a	s = self.thetype('abcba')
494	n/a	self.assertEqual(s.update(C(p), C(q)), None)
495	n/a	self.assertEqual(s, set(s) \| set(p) \| set(q))
496	n/a
497	n/a	def test_ior(self):
498	n/a	self.s \|= set(self.otherword)
499	n/a	for c in (self.word + self.otherword):
500	n/a	self.assertIn(c, self.s)
501	n/a
502	n/a	def test_intersection_update(self):
503	n/a	retval = self.s.intersection_update(self.otherword)
504	n/a	self.assertEqual(retval, None)
505	n/a	for c in (self.word + self.otherword):
506	n/a	if c in self.otherword and c in self.word:
507	n/a	self.assertIn(c, self.s)
508	n/a	else:
509	n/a	self.assertNotIn(c, self.s)
510	n/a	self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
511	n/a	self.assertRaises(TypeError, self.s.intersection_update, [[]])
512	n/a	for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):
513	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
514	n/a	s = self.thetype('abcba')
515	n/a	self.assertEqual(s.intersection_update(C(p)), None)
516	n/a	self.assertEqual(s, set(q))
517	n/a	ss = 'abcba'
518	n/a	s = self.thetype(ss)
519	n/a	t = 'cbc'
520	n/a	self.assertEqual(s.intersection_update(C(p), C(t)), None)
521	n/a	self.assertEqual(s, set('abcba')&set(p)&set(t))
522	n/a
523	n/a	def test_iand(self):
524	n/a	self.s &= set(self.otherword)
525	n/a	for c in (self.word + self.otherword):
526	n/a	if c in self.otherword and c in self.word:
527	n/a	self.assertIn(c, self.s)
528	n/a	else:
529	n/a	self.assertNotIn(c, self.s)
530	n/a
531	n/a	def test_difference_update(self):
532	n/a	retval = self.s.difference_update(self.otherword)
533	n/a	self.assertEqual(retval, None)
534	n/a	for c in (self.word + self.otherword):
535	n/a	if c in self.word and c not in self.otherword:
536	n/a	self.assertIn(c, self.s)
537	n/a	else:
538	n/a	self.assertNotIn(c, self.s)
539	n/a	self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
540	n/a	self.assertRaises(TypeError, self.s.difference_update, [[]])
541	n/a	self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
542	n/a	for p, q in (('cdc', 'ab'), ('efgfe', 'abc'), ('ccb', 'a'), ('ef', 'abc')):
543	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
544	n/a	s = self.thetype('abcba')
545	n/a	self.assertEqual(s.difference_update(C(p)), None)
546	n/a	self.assertEqual(s, set(q))
547	n/a
548	n/a	s = self.thetype('abcdefghih')
549	n/a	s.difference_update()
550	n/a	self.assertEqual(s, self.thetype('abcdefghih'))
551	n/a
552	n/a	s = self.thetype('abcdefghih')
553	n/a	s.difference_update(C('aba'))
554	n/a	self.assertEqual(s, self.thetype('cdefghih'))
555	n/a
556	n/a	s = self.thetype('abcdefghih')
557	n/a	s.difference_update(C('cdc'), C('aba'))
558	n/a	self.assertEqual(s, self.thetype('efghih'))
559	n/a
560	n/a	def test_isub(self):
561	n/a	self.s -= set(self.otherword)
562	n/a	for c in (self.word + self.otherword):
563	n/a	if c in self.word and c not in self.otherword:
564	n/a	self.assertIn(c, self.s)
565	n/a	else:
566	n/a	self.assertNotIn(c, self.s)
567	n/a
568	n/a	def test_symmetric_difference_update(self):
569	n/a	retval = self.s.symmetric_difference_update(self.otherword)
570	n/a	self.assertEqual(retval, None)
571	n/a	for c in (self.word + self.otherword):
572	n/a	if (c in self.word) ^ (c in self.otherword):
573	n/a	self.assertIn(c, self.s)
574	n/a	else:
575	n/a	self.assertNotIn(c, self.s)
576	n/a	self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
577	n/a	self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
578	n/a	for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):
579	n/a	for C in set, frozenset, dict.fromkeys, str, list, tuple:
580	n/a	s = self.thetype('abcba')
581	n/a	self.assertEqual(s.symmetric_difference_update(C(p)), None)
582	n/a	self.assertEqual(s, set(q))
583	n/a
584	n/a	def test_ixor(self):
585	n/a	self.s ^= set(self.otherword)
586	n/a	for c in (self.word + self.otherword):
587	n/a	if (c in self.word) ^ (c in self.otherword):
588	n/a	self.assertIn(c, self.s)
589	n/a	else:
590	n/a	self.assertNotIn(c, self.s)
591	n/a
592	n/a	def test_inplace_on_self(self):
593	n/a	t = self.s.copy()
594	n/a	t \|= t
595	n/a	self.assertEqual(t, self.s)
596	n/a	t &= t
597	n/a	self.assertEqual(t, self.s)
598	n/a	t -= t
599	n/a	self.assertEqual(t, self.thetype())
600	n/a	t = self.s.copy()
601	n/a	t ^= t
602	n/a	self.assertEqual(t, self.thetype())
603	n/a
604	n/a	def test_weakref(self):
605	n/a	s = self.thetype('gallahad')
606	n/a	p = weakref.proxy(s)
607	n/a	self.assertEqual(str(p), str(s))
608	n/a	s = None
609	n/a	self.assertRaises(ReferenceError, str, p)
610	n/a
611	n/a	def test_rich_compare(self):
612	n/a	class TestRichSetCompare:
613	n/a	def __gt__(self, some_set):
614	n/a	self.gt_called = True
615	n/a	return False
616	n/a	def __lt__(self, some_set):
617	n/a	self.lt_called = True
618	n/a	return False
619	n/a	def __ge__(self, some_set):
620	n/a	self.ge_called = True
621	n/a	return False
622	n/a	def __le__(self, some_set):
623	n/a	self.le_called = True
624	n/a	return False
625	n/a
626	n/a	# This first tries the builtin rich set comparison, which doesn't know
627	n/a	# how to handle the custom object. Upon returning NotImplemented, the
628	n/a	# corresponding comparison on the right object is invoked.
629	n/a	myset = {1, 2, 3}
630	n/a
631	n/a	myobj = TestRichSetCompare()
632	n/a	myset < myobj
633	n/a	self.assertTrue(myobj.gt_called)
634	n/a
635	n/a	myobj = TestRichSetCompare()
636	n/a	myset > myobj
637	n/a	self.assertTrue(myobj.lt_called)
638	n/a
639	n/a	myobj = TestRichSetCompare()
640	n/a	myset <= myobj
641	n/a	self.assertTrue(myobj.ge_called)
642	n/a
643	n/a	myobj = TestRichSetCompare()
644	n/a	myset >= myobj
645	n/a	self.assertTrue(myobj.le_called)
646	n/a
647	n/a	@unittest.skipUnless(hasattr(set, "test_c_api"),
648	n/a	'C API test only available in a debug build')
649	n/a	def test_c_api(self):
650	n/a	self.assertEqual(set().test_c_api(), True)
651	n/a
652	n/a	class SetSubclass(set):
653	n/a	pass
654	n/a
655	n/a	class TestSetSubclass(TestSet):
656	n/a	thetype = SetSubclass
657	n/a	basetype = set
658	n/a
659	n/a	class SetSubclassWithKeywordArgs(set):
660	n/a	def __init__(self, iterable=[], newarg=None):
661	n/a	set.__init__(self, iterable)
662	n/a
663	n/a	class TestSetSubclassWithKeywordArgs(TestSet):
664	n/a
665	n/a	def test_keywords_in_subclass(self):
666	n/a	'SF bug #1486663 -- this used to erroneously raise a TypeError'
667	n/a	SetSubclassWithKeywordArgs(newarg=1)
668	n/a
669	n/a	class TestFrozenSet(TestJointOps, unittest.TestCase):
670	n/a	thetype = frozenset
671	n/a	basetype = frozenset
672	n/a
673	n/a	def test_init(self):
674	n/a	s = self.thetype(self.word)
675	n/a	s.__init__(self.otherword)
676	n/a	self.assertEqual(s, set(self.word))
677	n/a
678	n/a	def test_singleton_empty_frozenset(self):
679	n/a	f = frozenset()
680	n/a	efs = [frozenset(), frozenset([]), frozenset(()), frozenset(''),
681	n/a	frozenset(), frozenset([]), frozenset(()), frozenset(''),
682	n/a	frozenset(range(0)), frozenset(frozenset()),
683	n/a	frozenset(f), f]
684	n/a	# All of the empty frozensets should have just one id()
685	n/a	self.assertEqual(len(set(map(id, efs))), 1)
686	n/a
687	n/a	def test_constructor_identity(self):
688	n/a	s = self.thetype(range(3))
689	n/a	t = self.thetype(s)
690	n/a	self.assertEqual(id(s), id(t))
691	n/a
692	n/a	def test_hash(self):
693	n/a	self.assertEqual(hash(self.thetype('abcdeb')),
694	n/a	hash(self.thetype('ebecda')))
695	n/a
696	n/a	# make sure that all permutations give the same hash value
697	n/a	n = 100
698	n/a	seq = [randrange(n) for i in range(n)]
699	n/a	results = set()
700	n/a	for i in range(200):
701	n/a	shuffle(seq)
702	n/a	results.add(hash(self.thetype(seq)))
703	n/a	self.assertEqual(len(results), 1)
704	n/a
705	n/a	def test_copy(self):
706	n/a	dup = self.s.copy()
707	n/a	self.assertEqual(id(self.s), id(dup))
708	n/a
709	n/a	def test_frozen_as_dictkey(self):
710	n/a	seq = list(range(10)) + list('abcdefg') + ['apple']
711	n/a	key1 = self.thetype(seq)
712	n/a	key2 = self.thetype(reversed(seq))
713	n/a	self.assertEqual(key1, key2)
714	n/a	self.assertNotEqual(id(key1), id(key2))
715	n/a	d = {}
716	n/a	d[key1] = 42
717	n/a	self.assertEqual(d[key2], 42)
718	n/a
719	n/a	def test_hash_caching(self):
720	n/a	f = self.thetype('abcdcda')
721	n/a	self.assertEqual(hash(f), hash(f))
722	n/a
723	n/a	def test_hash_effectiveness(self):
724	n/a	n = 13
725	n/a	hashvalues = set()
726	n/a	addhashvalue = hashvalues.add
727	n/a	elemmasks = [(i+1, 1<<i) for i in range(n)]
728	n/a	for i in range(2**n):
729	n/a	addhashvalue(hash(frozenset([e for e, m in elemmasks if m&i])))
730	n/a	self.assertEqual(len(hashvalues), 2**n)
731	n/a
732	n/a	def zf_range(n):
733	n/a	# https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers
734	n/a	nums = [frozenset()]
735	n/a	for i in range(n-1):
736	n/a	num = frozenset(nums)
737	n/a	nums.append(num)
738	n/a	return nums[:n]
739	n/a
740	n/a	def powerset(s):
741	n/a	for i in range(len(s)+1):
742	n/a	yield from map(frozenset, itertools.combinations(s, i))
743	n/a
744	n/a	for n in range(18):
745	n/a	t = 2 ** n
746	n/a	mask = t - 1
747	n/a	for nums in (range, zf_range):
748	n/a	u = len({h & mask for h in map(hash, powerset(nums(n)))})
749	n/a	self.assertGreater(4*u, t)
750	n/a
751	n/a	class FrozenSetSubclass(frozenset):
752	n/a	pass
753	n/a
754	n/a	class TestFrozenSetSubclass(TestFrozenSet):
755	n/a	thetype = FrozenSetSubclass
756	n/a	basetype = frozenset
757	n/a
758	n/a	def test_constructor_identity(self):
759	n/a	s = self.thetype(range(3))
760	n/a	t = self.thetype(s)
761	n/a	self.assertNotEqual(id(s), id(t))
762	n/a
763	n/a	def test_copy(self):
764	n/a	dup = self.s.copy()
765	n/a	self.assertNotEqual(id(self.s), id(dup))
766	n/a
767	n/a	def test_nested_empty_constructor(self):
768	n/a	s = self.thetype()
769	n/a	t = self.thetype(s)
770	n/a	self.assertEqual(s, t)
771	n/a
772	n/a	def test_singleton_empty_frozenset(self):
773	n/a	Frozenset = self.thetype
774	n/a	f = frozenset()
775	n/a	F = Frozenset()
776	n/a	efs = [Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),
777	n/a	Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),
778	n/a	Frozenset(range(0)), Frozenset(Frozenset()),
779	n/a	Frozenset(frozenset()), f, F, Frozenset(f), Frozenset(F)]
780	n/a	# All empty frozenset subclass instances should have different ids
781	n/a	self.assertEqual(len(set(map(id, efs))), len(efs))
782	n/a
783	n/a	# Tests taken from test_sets.py =============================================
784	n/a
785	n/a	empty_set = set()
786	n/a
787	n/a	#==============================================================================
788	n/a
789	n/a	class TestBasicOps:
790	n/a
791	n/a	def test_repr(self):
792	n/a	if self.repr is not None:
793	n/a	self.assertEqual(repr(self.set), self.repr)
794	n/a
795	n/a	def check_repr_against_values(self):
796	n/a	text = repr(self.set)
797	n/a	self.assertTrue(text.startswith('{'))
798	n/a	self.assertTrue(text.endswith('}'))
799	n/a
800	n/a	result = text[1:-1].split(', ')
801	n/a	result.sort()
802	n/a	sorted_repr_values = [repr(value) for value in self.values]
803	n/a	sorted_repr_values.sort()
804	n/a	self.assertEqual(result, sorted_repr_values)
805	n/a
806	n/a	def test_print(self):
807	n/a	try:
808	n/a	fo = open(support.TESTFN, "w")
809	n/a	fo.write(str(self.set))
810	n/a	fo.close()
811	n/a	fo = open(support.TESTFN, "r")
812	n/a	self.assertEqual(fo.read(), repr(self.set))
813	n/a	finally:
814	n/a	fo.close()
815	n/a	support.unlink(support.TESTFN)
816	n/a
817	n/a	def test_length(self):
818	n/a	self.assertEqual(len(self.set), self.length)
819	n/a
820	n/a	def test_self_equality(self):
821	n/a	self.assertEqual(self.set, self.set)
822	n/a
823	n/a	def test_equivalent_equality(self):
824	n/a	self.assertEqual(self.set, self.dup)
825	n/a
826	n/a	def test_copy(self):
827	n/a	self.assertEqual(self.set.copy(), self.dup)
828	n/a
829	n/a	def test_self_union(self):
830	n/a	result = self.set \| self.set
831	n/a	self.assertEqual(result, self.dup)
832	n/a
833	n/a	def test_empty_union(self):
834	n/a	result = self.set \| empty_set
835	n/a	self.assertEqual(result, self.dup)
836	n/a
837	n/a	def test_union_empty(self):
838	n/a	result = empty_set \| self.set
839	n/a	self.assertEqual(result, self.dup)
840	n/a
841	n/a	def test_self_intersection(self):
842	n/a	result = self.set & self.set
843	n/a	self.assertEqual(result, self.dup)
844	n/a
845	n/a	def test_empty_intersection(self):
846	n/a	result = self.set & empty_set
847	n/a	self.assertEqual(result, empty_set)
848	n/a
849	n/a	def test_intersection_empty(self):
850	n/a	result = empty_set & self.set
851	n/a	self.assertEqual(result, empty_set)
852	n/a
853	n/a	def test_self_isdisjoint(self):
854	n/a	result = self.set.isdisjoint(self.set)
855	n/a	self.assertEqual(result, not self.set)
856	n/a
857	n/a	def test_empty_isdisjoint(self):
858	n/a	result = self.set.isdisjoint(empty_set)
859	n/a	self.assertEqual(result, True)
860	n/a
861	n/a	def test_isdisjoint_empty(self):
862	n/a	result = empty_set.isdisjoint(self.set)
863	n/a	self.assertEqual(result, True)
864	n/a
865	n/a	def test_self_symmetric_difference(self):
866	n/a	result = self.set ^ self.set
867	n/a	self.assertEqual(result, empty_set)
868	n/a
869	n/a	def test_empty_symmetric_difference(self):
870	n/a	result = self.set ^ empty_set
871	n/a	self.assertEqual(result, self.set)
872	n/a
873	n/a	def test_self_difference(self):
874	n/a	result = self.set - self.set
875	n/a	self.assertEqual(result, empty_set)
876	n/a
877	n/a	def test_empty_difference(self):
878	n/a	result = self.set - empty_set
879	n/a	self.assertEqual(result, self.dup)
880	n/a
881	n/a	def test_empty_difference_rev(self):
882	n/a	result = empty_set - self.set
883	n/a	self.assertEqual(result, empty_set)
884	n/a
885	n/a	def test_iteration(self):
886	n/a	for v in self.set:
887	n/a	self.assertIn(v, self.values)
888	n/a	setiter = iter(self.set)
889	n/a	self.assertEqual(setiter.__length_hint__(), len(self.set))
890	n/a
891	n/a	def test_pickling(self):
892	n/a	for proto in range(pickle.HIGHEST_PROTOCOL + 1):
893	n/a	p = pickle.dumps(self.set, proto)
894	n/a	copy = pickle.loads(p)
895	n/a	self.assertEqual(self.set, copy,
896	n/a	"%s != %s" % (self.set, copy))
897	n/a
898	n/a	#------------------------------------------------------------------------------
899	n/a
900	n/a	class TestBasicOpsEmpty(TestBasicOps, unittest.TestCase):
901	n/a	def setUp(self):
902	n/a	self.case = "empty set"
903	n/a	self.values = []
904	n/a	self.set = set(self.values)
905	n/a	self.dup = set(self.values)
906	n/a	self.length = 0
907	n/a	self.repr = "set()"
908	n/a
909	n/a	#------------------------------------------------------------------------------
910	n/a
911	n/a	class TestBasicOpsSingleton(TestBasicOps, unittest.TestCase):
912	n/a	def setUp(self):
913	n/a	self.case = "unit set (number)"
914	n/a	self.values = [3]
915	n/a	self.set = set(self.values)
916	n/a	self.dup = set(self.values)
917	n/a	self.length = 1
918	n/a	self.repr = "{3}"
919	n/a
920	n/a	def test_in(self):
921	n/a	self.assertIn(3, self.set)
922	n/a
923	n/a	def test_not_in(self):
924	n/a	self.assertNotIn(2, self.set)
925	n/a
926	n/a	#------------------------------------------------------------------------------
927	n/a
928	n/a	class TestBasicOpsTuple(TestBasicOps, unittest.TestCase):
929	n/a	def setUp(self):
930	n/a	self.case = "unit set (tuple)"
931	n/a	self.values = [(0, "zero")]
932	n/a	self.set = set(self.values)
933	n/a	self.dup = set(self.values)
934	n/a	self.length = 1
935	n/a	self.repr = "{(0, 'zero')}"
936	n/a
937	n/a	def test_in(self):
938	n/a	self.assertIn((0, "zero"), self.set)
939	n/a
940	n/a	def test_not_in(self):
941	n/a	self.assertNotIn(9, self.set)
942	n/a
943	n/a	#------------------------------------------------------------------------------
944	n/a
945	n/a	class TestBasicOpsTriple(TestBasicOps, unittest.TestCase):
946	n/a	def setUp(self):
947	n/a	self.case = "triple set"
948	n/a	self.values = [0, "zero", operator.add]
949	n/a	self.set = set(self.values)
950	n/a	self.dup = set(self.values)
951	n/a	self.length = 3
952	n/a	self.repr = None
953	n/a
954	n/a	#------------------------------------------------------------------------------
955	n/a
956	n/a	class TestBasicOpsString(TestBasicOps, unittest.TestCase):
957	n/a	def setUp(self):
958	n/a	self.case = "string set"
959	n/a	self.values = ["a", "b", "c"]
960	n/a	self.set = set(self.values)
961	n/a	self.dup = set(self.values)
962	n/a	self.length = 3
963	n/a
964	n/a	def test_repr(self):
965	n/a	self.check_repr_against_values()
966	n/a
967	n/a	#------------------------------------------------------------------------------
968	n/a
969	n/a	class TestBasicOpsBytes(TestBasicOps, unittest.TestCase):
970	n/a	def setUp(self):
971	n/a	self.case = "bytes set"
972	n/a	self.values = [b"a", b"b", b"c"]
973	n/a	self.set = set(self.values)
974	n/a	self.dup = set(self.values)
975	n/a	self.length = 3
976	n/a
977	n/a	def test_repr(self):
978	n/a	self.check_repr_against_values()
979	n/a
980	n/a	#------------------------------------------------------------------------------
981	n/a
982	n/a	class TestBasicOpsMixedStringBytes(TestBasicOps, unittest.TestCase):
983	n/a	def setUp(self):
984	n/a	self._warning_filters = support.check_warnings()
985	n/a	self._warning_filters.__enter__()
986	n/a	warnings.simplefilter('ignore', BytesWarning)
987	n/a	self.case = "string and bytes set"
988	n/a	self.values = ["a", "b", b"a", b"b"]
989	n/a	self.set = set(self.values)
990	n/a	self.dup = set(self.values)
991	n/a	self.length = 4
992	n/a
993	n/a	def tearDown(self):
994	n/a	self._warning_filters.__exit__(None, None, None)
995	n/a
996	n/a	def test_repr(self):
997	n/a	self.check_repr_against_values()
998	n/a
999	n/a	#==============================================================================
1000	n/a
1001	n/a	def baditer():
1002	n/a	raise TypeError
1003	n/a	yield True
1004	n/a
1005	n/a	def gooditer():
1006	n/a	yield True
1007	n/a
1008	n/a	class TestExceptionPropagation(unittest.TestCase):
1009	n/a	"""SF 628246: Set constructor should not trap iterator TypeErrors"""
1010	n/a
1011	n/a	def test_instanceWithException(self):
1012	n/a	self.assertRaises(TypeError, set, baditer())
1013	n/a
1014	n/a	def test_instancesWithoutException(self):
1015	n/a	# All of these iterables should load without exception.
1016	n/a	set([1,2,3])
1017	n/a	set((1,2,3))
1018	n/a	set({'one':1, 'two':2, 'three':3})
1019	n/a	set(range(3))
1020	n/a	set('abc')
1021	n/a	set(gooditer())
1022	n/a
1023	n/a	def test_changingSizeWhileIterating(self):
1024	n/a	s = set([1,2,3])
1025	n/a	try:
1026	n/a	for i in s:
1027	n/a	s.update([4])
1028	n/a	except RuntimeError:
1029	n/a	pass
1030	n/a	else:
1031	n/a	self.fail("no exception when changing size during iteration")
1032	n/a
1033	n/a	#==============================================================================
1034	n/a
1035	n/a	class TestSetOfSets(unittest.TestCase):
1036	n/a	def test_constructor(self):
1037	n/a	inner = frozenset([1])
1038	n/a	outer = set([inner])
1039	n/a	element = outer.pop()
1040	n/a	self.assertEqual(type(element), frozenset)
1041	n/a	outer.add(inner) # Rebuild set of sets with .add method
1042	n/a	outer.remove(inner)
1043	n/a	self.assertEqual(outer, set()) # Verify that remove worked
1044	n/a	outer.discard(inner) # Absence of KeyError indicates working fine
1045	n/a
1046	n/a	#==============================================================================
1047	n/a
1048	n/a	class TestBinaryOps(unittest.TestCase):
1049	n/a	def setUp(self):
1050	n/a	self.set = set((2, 4, 6))
1051	n/a
1052	n/a	def test_eq(self): # SF bug 643115
1053	n/a	self.assertEqual(self.set, set({2:1,4:3,6:5}))
1054	n/a
1055	n/a	def test_union_subset(self):
1056	n/a	result = self.set \| set([2])
1057	n/a	self.assertEqual(result, set((2, 4, 6)))
1058	n/a
1059	n/a	def test_union_superset(self):
1060	n/a	result = self.set \| set([2, 4, 6, 8])
1061	n/a	self.assertEqual(result, set([2, 4, 6, 8]))
1062	n/a
1063	n/a	def test_union_overlap(self):
1064	n/a	result = self.set \| set([3, 4, 5])
1065	n/a	self.assertEqual(result, set([2, 3, 4, 5, 6]))
1066	n/a
1067	n/a	def test_union_non_overlap(self):
1068	n/a	result = self.set \| set([8])
1069	n/a	self.assertEqual(result, set([2, 4, 6, 8]))
1070	n/a
1071	n/a	def test_intersection_subset(self):
1072	n/a	result = self.set & set((2, 4))
1073	n/a	self.assertEqual(result, set((2, 4)))
1074	n/a
1075	n/a	def test_intersection_superset(self):
1076	n/a	result = self.set & set([2, 4, 6, 8])
1077	n/a	self.assertEqual(result, set([2, 4, 6]))
1078	n/a
1079	n/a	def test_intersection_overlap(self):
1080	n/a	result = self.set & set([3, 4, 5])
1081	n/a	self.assertEqual(result, set([4]))
1082	n/a
1083	n/a	def test_intersection_non_overlap(self):
1084	n/a	result = self.set & set([8])
1085	n/a	self.assertEqual(result, empty_set)
1086	n/a
1087	n/a	def test_isdisjoint_subset(self):
1088	n/a	result = self.set.isdisjoint(set((2, 4)))
1089	n/a	self.assertEqual(result, False)
1090	n/a
1091	n/a	def test_isdisjoint_superset(self):
1092	n/a	result = self.set.isdisjoint(set([2, 4, 6, 8]))
1093	n/a	self.assertEqual(result, False)
1094	n/a
1095	n/a	def test_isdisjoint_overlap(self):
1096	n/a	result = self.set.isdisjoint(set([3, 4, 5]))
1097	n/a	self.assertEqual(result, False)
1098	n/a
1099	n/a	def test_isdisjoint_non_overlap(self):
1100	n/a	result = self.set.isdisjoint(set([8]))
1101	n/a	self.assertEqual(result, True)
1102	n/a
1103	n/a	def test_sym_difference_subset(self):
1104	n/a	result = self.set ^ set((2, 4))
1105	n/a	self.assertEqual(result, set([6]))
1106	n/a
1107	n/a	def test_sym_difference_superset(self):
1108	n/a	result = self.set ^ set((2, 4, 6, 8))
1109	n/a	self.assertEqual(result, set([8]))
1110	n/a
1111	n/a	def test_sym_difference_overlap(self):
1112	n/a	result = self.set ^ set((3, 4, 5))
1113	n/a	self.assertEqual(result, set([2, 3, 5, 6]))
1114	n/a
1115	n/a	def test_sym_difference_non_overlap(self):
1116	n/a	result = self.set ^ set([8])
1117	n/a	self.assertEqual(result, set([2, 4, 6, 8]))
1118	n/a
1119	n/a	#==============================================================================
1120	n/a
1121	n/a	class TestUpdateOps(unittest.TestCase):
1122	n/a	def setUp(self):
1123	n/a	self.set = set((2, 4, 6))
1124	n/a
1125	n/a	def test_union_subset(self):
1126	n/a	self.set \|= set([2])
1127	n/a	self.assertEqual(self.set, set((2, 4, 6)))
1128	n/a
1129	n/a	def test_union_superset(self):
1130	n/a	self.set \|= set([2, 4, 6, 8])
1131	n/a	self.assertEqual(self.set, set([2, 4, 6, 8]))
1132	n/a
1133	n/a	def test_union_overlap(self):
1134	n/a	self.set \|= set([3, 4, 5])
1135	n/a	self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
1136	n/a
1137	n/a	def test_union_non_overlap(self):
1138	n/a	self.set \|= set([8])
1139	n/a	self.assertEqual(self.set, set([2, 4, 6, 8]))
1140	n/a
1141	n/a	def test_union_method_call(self):
1142	n/a	self.set.update(set([3, 4, 5]))
1143	n/a	self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
1144	n/a
1145	n/a	def test_intersection_subset(self):
1146	n/a	self.set &= set((2, 4))
1147	n/a	self.assertEqual(self.set, set((2, 4)))
1148	n/a
1149	n/a	def test_intersection_superset(self):
1150	n/a	self.set &= set([2, 4, 6, 8])
1151	n/a	self.assertEqual(self.set, set([2, 4, 6]))
1152	n/a
1153	n/a	def test_intersection_overlap(self):
1154	n/a	self.set &= set([3, 4, 5])
1155	n/a	self.assertEqual(self.set, set([4]))
1156	n/a
1157	n/a	def test_intersection_non_overlap(self):
1158	n/a	self.set &= set([8])
1159	n/a	self.assertEqual(self.set, empty_set)
1160	n/a
1161	n/a	def test_intersection_method_call(self):
1162	n/a	self.set.intersection_update(set([3, 4, 5]))
1163	n/a	self.assertEqual(self.set, set([4]))
1164	n/a
1165	n/a	def test_sym_difference_subset(self):
1166	n/a	self.set ^= set((2, 4))
1167	n/a	self.assertEqual(self.set, set([6]))
1168	n/a
1169	n/a	def test_sym_difference_superset(self):
1170	n/a	self.set ^= set((2, 4, 6, 8))
1171	n/a	self.assertEqual(self.set, set([8]))
1172	n/a
1173	n/a	def test_sym_difference_overlap(self):
1174	n/a	self.set ^= set((3, 4, 5))
1175	n/a	self.assertEqual(self.set, set([2, 3, 5, 6]))
1176	n/a
1177	n/a	def test_sym_difference_non_overlap(self):
1178	n/a	self.set ^= set([8])
1179	n/a	self.assertEqual(self.set, set([2, 4, 6, 8]))
1180	n/a
1181	n/a	def test_sym_difference_method_call(self):
1182	n/a	self.set.symmetric_difference_update(set([3, 4, 5]))
1183	n/a	self.assertEqual(self.set, set([2, 3, 5, 6]))
1184	n/a
1185	n/a	def test_difference_subset(self):
1186	n/a	self.set -= set((2, 4))
1187	n/a	self.assertEqual(self.set, set([6]))
1188	n/a
1189	n/a	def test_difference_superset(self):
1190	n/a	self.set -= set((2, 4, 6, 8))
1191	n/a	self.assertEqual(self.set, set([]))
1192	n/a
1193	n/a	def test_difference_overlap(self):
1194	n/a	self.set -= set((3, 4, 5))
1195	n/a	self.assertEqual(self.set, set([2, 6]))
1196	n/a
1197	n/a	def test_difference_non_overlap(self):
1198	n/a	self.set -= set([8])
1199	n/a	self.assertEqual(self.set, set([2, 4, 6]))
1200	n/a
1201	n/a	def test_difference_method_call(self):
1202	n/a	self.set.difference_update(set([3, 4, 5]))
1203	n/a	self.assertEqual(self.set, set([2, 6]))
1204	n/a
1205	n/a	#==============================================================================
1206	n/a
1207	n/a	class TestMutate(unittest.TestCase):
1208	n/a	def setUp(self):
1209	n/a	self.values = ["a", "b", "c"]
1210	n/a	self.set = set(self.values)
1211	n/a
1212	n/a	def test_add_present(self):
1213	n/a	self.set.add("c")
1214	n/a	self.assertEqual(self.set, set("abc"))
1215	n/a
1216	n/a	def test_add_absent(self):
1217	n/a	self.set.add("d")
1218	n/a	self.assertEqual(self.set, set("abcd"))
1219	n/a
1220	n/a	def test_add_until_full(self):
1221	n/a	tmp = set()
1222	n/a	expected_len = 0
1223	n/a	for v in self.values:
1224	n/a	tmp.add(v)
1225	n/a	expected_len += 1
1226	n/a	self.assertEqual(len(tmp), expected_len)
1227	n/a	self.assertEqual(tmp, self.set)
1228	n/a
1229	n/a	def test_remove_present(self):
1230	n/a	self.set.remove("b")
1231	n/a	self.assertEqual(self.set, set("ac"))
1232	n/a
1233	n/a	def test_remove_absent(self):
1234	n/a	try:
1235	n/a	self.set.remove("d")
1236	n/a	self.fail("Removing missing element should have raised LookupError")
1237	n/a	except LookupError:
1238	n/a	pass
1239	n/a
1240	n/a	def test_remove_until_empty(self):
1241	n/a	expected_len = len(self.set)
1242	n/a	for v in self.values:
1243	n/a	self.set.remove(v)
1244	n/a	expected_len -= 1
1245	n/a	self.assertEqual(len(self.set), expected_len)
1246	n/a
1247	n/a	def test_discard_present(self):
1248	n/a	self.set.discard("c")
1249	n/a	self.assertEqual(self.set, set("ab"))
1250	n/a
1251	n/a	def test_discard_absent(self):
1252	n/a	self.set.discard("d")
1253	n/a	self.assertEqual(self.set, set("abc"))
1254	n/a
1255	n/a	def test_clear(self):
1256	n/a	self.set.clear()
1257	n/a	self.assertEqual(len(self.set), 0)
1258	n/a
1259	n/a	def test_pop(self):
1260	n/a	popped = {}
1261	n/a	while self.set:
1262	n/a	popped[self.set.pop()] = None
1263	n/a	self.assertEqual(len(popped), len(self.values))
1264	n/a	for v in self.values:
1265	n/a	self.assertIn(v, popped)
1266	n/a
1267	n/a	def test_update_empty_tuple(self):
1268	n/a	self.set.update(())
1269	n/a	self.assertEqual(self.set, set(self.values))
1270	n/a
1271	n/a	def test_update_unit_tuple_overlap(self):
1272	n/a	self.set.update(("a",))
1273	n/a	self.assertEqual(self.set, set(self.values))
1274	n/a
1275	n/a	def test_update_unit_tuple_non_overlap(self):
1276	n/a	self.set.update(("a", "z"))
1277	n/a	self.assertEqual(self.set, set(self.values + ["z"]))
1278	n/a
1279	n/a	#==============================================================================
1280	n/a
1281	n/a	class TestSubsets:
1282	n/a
1283	n/a	case2method = {"<=": "issubset",
1284	n/a	">=": "issuperset",
1285	n/a	}
1286	n/a
1287	n/a	reverse = {"==": "==",
1288	n/a	"!=": "!=",
1289	n/a	"<": ">",
1290	n/a	">": "<",
1291	n/a	"<=": ">=",
1292	n/a	">=": "<=",
1293	n/a	}
1294	n/a
1295	n/a	def test_issubset(self):
1296	n/a	x = self.left
1297	n/a	y = self.right
1298	n/a	for case in "!=", "==", "<", "<=", ">", ">=":
1299	n/a	expected = case in self.cases
1300	n/a	# Test the binary infix spelling.
1301	n/a	result = eval("x" + case + "y", locals())
1302	n/a	self.assertEqual(result, expected)
1303	n/a	# Test the "friendly" method-name spelling, if one exists.
1304	n/a	if case in TestSubsets.case2method:
1305	n/a	method = getattr(x, TestSubsets.case2method[case])
1306	n/a	result = method(y)
1307	n/a	self.assertEqual(result, expected)
1308	n/a
1309	n/a	# Now do the same for the operands reversed.
1310	n/a	rcase = TestSubsets.reverse[case]
1311	n/a	result = eval("y" + rcase + "x", locals())
1312	n/a	self.assertEqual(result, expected)
1313	n/a	if rcase in TestSubsets.case2method:
1314	n/a	method = getattr(y, TestSubsets.case2method[rcase])
1315	n/a	result = method(x)
1316	n/a	self.assertEqual(result, expected)
1317	n/a	#------------------------------------------------------------------------------
1318	n/a
1319	n/a	class TestSubsetEqualEmpty(TestSubsets, unittest.TestCase):
1320	n/a	left = set()
1321	n/a	right = set()
1322	n/a	name = "both empty"
1323	n/a	cases = "==", "<=", ">="
1324	n/a
1325	n/a	#------------------------------------------------------------------------------
1326	n/a
1327	n/a	class TestSubsetEqualNonEmpty(TestSubsets, unittest.TestCase):
1328	n/a	left = set([1, 2])
1329	n/a	right = set([1, 2])
1330	n/a	name = "equal pair"
1331	n/a	cases = "==", "<=", ">="
1332	n/a
1333	n/a	#------------------------------------------------------------------------------
1334	n/a
1335	n/a	class TestSubsetEmptyNonEmpty(TestSubsets, unittest.TestCase):
1336	n/a	left = set()
1337	n/a	right = set([1, 2])
1338	n/a	name = "one empty, one non-empty"
1339	n/a	cases = "!=", "<", "<="
1340	n/a
1341	n/a	#------------------------------------------------------------------------------
1342	n/a
1343	n/a	class TestSubsetPartial(TestSubsets, unittest.TestCase):
1344	n/a	left = set([1])
1345	n/a	right = set([1, 2])
1346	n/a	name = "one a non-empty proper subset of other"
1347	n/a	cases = "!=", "<", "<="
1348	n/a
1349	n/a	#------------------------------------------------------------------------------
1350	n/a
1351	n/a	class TestSubsetNonOverlap(TestSubsets, unittest.TestCase):
1352	n/a	left = set([1])
1353	n/a	right = set([2])
1354	n/a	name = "neither empty, neither contains"
1355	n/a	cases = "!="
1356	n/a
1357	n/a	#==============================================================================
1358	n/a
1359	n/a	class TestOnlySetsInBinaryOps:
1360	n/a
1361	n/a	def test_eq_ne(self):
1362	n/a	# Unlike the others, this is testing that == and != are allowed.
1363	n/a	self.assertEqual(self.other == self.set, False)
1364	n/a	self.assertEqual(self.set == self.other, False)
1365	n/a	self.assertEqual(self.other != self.set, True)
1366	n/a	self.assertEqual(self.set != self.other, True)
1367	n/a
1368	n/a	def test_ge_gt_le_lt(self):
1369	n/a	self.assertRaises(TypeError, lambda: self.set < self.other)
1370	n/a	self.assertRaises(TypeError, lambda: self.set <= self.other)
1371	n/a	self.assertRaises(TypeError, lambda: self.set > self.other)
1372	n/a	self.assertRaises(TypeError, lambda: self.set >= self.other)
1373	n/a
1374	n/a	self.assertRaises(TypeError, lambda: self.other < self.set)
1375	n/a	self.assertRaises(TypeError, lambda: self.other <= self.set)
1376	n/a	self.assertRaises(TypeError, lambda: self.other > self.set)
1377	n/a	self.assertRaises(TypeError, lambda: self.other >= self.set)
1378	n/a
1379	n/a	def test_update_operator(self):
1380	n/a	try:
1381	n/a	self.set \|= self.other
1382	n/a	except TypeError:
1383	n/a	pass
1384	n/a	else:
1385	n/a	self.fail("expected TypeError")
1386	n/a
1387	n/a	def test_update(self):
1388	n/a	if self.otherIsIterable:
1389	n/a	self.set.update(self.other)
1390	n/a	else:
1391	n/a	self.assertRaises(TypeError, self.set.update, self.other)
1392	n/a
1393	n/a	def test_union(self):
1394	n/a	self.assertRaises(TypeError, lambda: self.set \| self.other)
1395	n/a	self.assertRaises(TypeError, lambda: self.other \| self.set)
1396	n/a	if self.otherIsIterable:
1397	n/a	self.set.union(self.other)
1398	n/a	else:
1399	n/a	self.assertRaises(TypeError, self.set.union, self.other)
1400	n/a
1401	n/a	def test_intersection_update_operator(self):
1402	n/a	try:
1403	n/a	self.set &= self.other
1404	n/a	except TypeError:
1405	n/a	pass
1406	n/a	else:
1407	n/a	self.fail("expected TypeError")
1408	n/a
1409	n/a	def test_intersection_update(self):
1410	n/a	if self.otherIsIterable:
1411	n/a	self.set.intersection_update(self.other)
1412	n/a	else:
1413	n/a	self.assertRaises(TypeError,
1414	n/a	self.set.intersection_update,
1415	n/a	self.other)
1416	n/a
1417	n/a	def test_intersection(self):
1418	n/a	self.assertRaises(TypeError, lambda: self.set & self.other)
1419	n/a	self.assertRaises(TypeError, lambda: self.other & self.set)
1420	n/a	if self.otherIsIterable:
1421	n/a	self.set.intersection(self.other)
1422	n/a	else:
1423	n/a	self.assertRaises(TypeError, self.set.intersection, self.other)
1424	n/a
1425	n/a	def test_sym_difference_update_operator(self):
1426	n/a	try:
1427	n/a	self.set ^= self.other
1428	n/a	except TypeError:
1429	n/a	pass
1430	n/a	else:
1431	n/a	self.fail("expected TypeError")
1432	n/a
1433	n/a	def test_sym_difference_update(self):
1434	n/a	if self.otherIsIterable:
1435	n/a	self.set.symmetric_difference_update(self.other)
1436	n/a	else:
1437	n/a	self.assertRaises(TypeError,
1438	n/a	self.set.symmetric_difference_update,
1439	n/a	self.other)
1440	n/a
1441	n/a	def test_sym_difference(self):
1442	n/a	self.assertRaises(TypeError, lambda: self.set ^ self.other)
1443	n/a	self.assertRaises(TypeError, lambda: self.other ^ self.set)
1444	n/a	if self.otherIsIterable:
1445	n/a	self.set.symmetric_difference(self.other)
1446	n/a	else:
1447	n/a	self.assertRaises(TypeError, self.set.symmetric_difference, self.other)
1448	n/a
1449	n/a	def test_difference_update_operator(self):
1450	n/a	try:
1451	n/a	self.set -= self.other
1452	n/a	except TypeError:
1453	n/a	pass
1454	n/a	else:
1455	n/a	self.fail("expected TypeError")
1456	n/a
1457	n/a	def test_difference_update(self):
1458	n/a	if self.otherIsIterable:
1459	n/a	self.set.difference_update(self.other)
1460	n/a	else:
1461	n/a	self.assertRaises(TypeError,
1462	n/a	self.set.difference_update,
1463	n/a	self.other)
1464	n/a
1465	n/a	def test_difference(self):
1466	n/a	self.assertRaises(TypeError, lambda: self.set - self.other)
1467	n/a	self.assertRaises(TypeError, lambda: self.other - self.set)
1468	n/a	if self.otherIsIterable:
1469	n/a	self.set.difference(self.other)
1470	n/a	else:
1471	n/a	self.assertRaises(TypeError, self.set.difference, self.other)
1472	n/a
1473	n/a	#------------------------------------------------------------------------------
1474	n/a
1475	n/a	class TestOnlySetsNumeric(TestOnlySetsInBinaryOps, unittest.TestCase):
1476	n/a	def setUp(self):
1477	n/a	self.set = set((1, 2, 3))
1478	n/a	self.other = 19
1479	n/a	self.otherIsIterable = False
1480	n/a
1481	n/a	#------------------------------------------------------------------------------
1482	n/a
1483	n/a	class TestOnlySetsDict(TestOnlySetsInBinaryOps, unittest.TestCase):
1484	n/a	def setUp(self):
1485	n/a	self.set = set((1, 2, 3))
1486	n/a	self.other = {1:2, 3:4}
1487	n/a	self.otherIsIterable = True
1488	n/a
1489	n/a	#------------------------------------------------------------------------------
1490	n/a
1491	n/a	class TestOnlySetsOperator(TestOnlySetsInBinaryOps, unittest.TestCase):
1492	n/a	def setUp(self):
1493	n/a	self.set = set((1, 2, 3))
1494	n/a	self.other = operator.add
1495	n/a	self.otherIsIterable = False
1496	n/a
1497	n/a	#------------------------------------------------------------------------------
1498	n/a
1499	n/a	class TestOnlySetsTuple(TestOnlySetsInBinaryOps, unittest.TestCase):
1500	n/a	def setUp(self):
1501	n/a	self.set = set((1, 2, 3))
1502	n/a	self.other = (2, 4, 6)
1503	n/a	self.otherIsIterable = True
1504	n/a
1505	n/a	#------------------------------------------------------------------------------
1506	n/a
1507	n/a	class TestOnlySetsString(TestOnlySetsInBinaryOps, unittest.TestCase):
1508	n/a	def setUp(self):
1509	n/a	self.set = set((1, 2, 3))
1510	n/a	self.other = 'abc'
1511	n/a	self.otherIsIterable = True
1512	n/a
1513	n/a	#------------------------------------------------------------------------------
1514	n/a
1515	n/a	class TestOnlySetsGenerator(TestOnlySetsInBinaryOps, unittest.TestCase):
1516	n/a	def setUp(self):
1517	n/a	def gen():
1518	n/a	for i in range(0, 10, 2):
1519	n/a	yield i
1520	n/a	self.set = set((1, 2, 3))
1521	n/a	self.other = gen()
1522	n/a	self.otherIsIterable = True
1523	n/a
1524	n/a	#==============================================================================
1525	n/a
1526	n/a	class TestCopying:
1527	n/a
1528	n/a	def test_copy(self):
1529	n/a	dup = self.set.copy()
1530	n/a	dup_list = sorted(dup, key=repr)
1531	n/a	set_list = sorted(self.set, key=repr)
1532	n/a	self.assertEqual(len(dup_list), len(set_list))
1533	n/a	for i in range(len(dup_list)):
1534	n/a	self.assertTrue(dup_list[i] is set_list[i])
1535	n/a
1536	n/a	def test_deep_copy(self):
1537	n/a	dup = copy.deepcopy(self.set)
1538	n/a	##print type(dup), repr(dup)
1539	n/a	dup_list = sorted(dup, key=repr)
1540	n/a	set_list = sorted(self.set, key=repr)
1541	n/a	self.assertEqual(len(dup_list), len(set_list))
1542	n/a	for i in range(len(dup_list)):
1543	n/a	self.assertEqual(dup_list[i], set_list[i])
1544	n/a
1545	n/a	#------------------------------------------------------------------------------
1546	n/a
1547	n/a	class TestCopyingEmpty(TestCopying, unittest.TestCase):
1548	n/a	def setUp(self):
1549	n/a	self.set = set()
1550	n/a
1551	n/a	#------------------------------------------------------------------------------
1552	n/a
1553	n/a	class TestCopyingSingleton(TestCopying, unittest.TestCase):
1554	n/a	def setUp(self):
1555	n/a	self.set = set(["hello"])
1556	n/a
1557	n/a	#------------------------------------------------------------------------------
1558	n/a
1559	n/a	class TestCopyingTriple(TestCopying, unittest.TestCase):
1560	n/a	def setUp(self):
1561	n/a	self.set = set(["zero", 0, None])
1562	n/a
1563	n/a	#------------------------------------------------------------------------------
1564	n/a
1565	n/a	class TestCopyingTuple(TestCopying, unittest.TestCase):
1566	n/a	def setUp(self):
1567	n/a	self.set = set([(1, 2)])
1568	n/a
1569	n/a	#------------------------------------------------------------------------------
1570	n/a
1571	n/a	class TestCopyingNested(TestCopying, unittest.TestCase):
1572	n/a	def setUp(self):
1573	n/a	self.set = set([((1, 2), (3, 4))])
1574	n/a
1575	n/a	#==============================================================================
1576	n/a
1577	n/a	class TestIdentities(unittest.TestCase):
1578	n/a	def setUp(self):
1579	n/a	self.a = set('abracadabra')
1580	n/a	self.b = set('alacazam')
1581	n/a
1582	n/a	def test_binopsVsSubsets(self):
1583	n/a	a, b = self.a, self.b
1584	n/a	self.assertTrue(a - b < a)
1585	n/a	self.assertTrue(b - a < b)
1586	n/a	self.assertTrue(a & b < a)
1587	n/a	self.assertTrue(a & b < b)
1588	n/a	self.assertTrue(a \| b > a)
1589	n/a	self.assertTrue(a \| b > b)
1590	n/a	self.assertTrue(a ^ b < a \| b)
1591	n/a
1592	n/a	def test_commutativity(self):
1593	n/a	a, b = self.a, self.b
1594	n/a	self.assertEqual(a&b, b&a)
1595	n/a	self.assertEqual(a\|b, b\|a)
1596	n/a	self.assertEqual(a^b, b^a)
1597	n/a	if a != b:
1598	n/a	self.assertNotEqual(a-b, b-a)
1599	n/a
1600	n/a	def test_summations(self):
1601	n/a	# check that sums of parts equal the whole
1602	n/a	a, b = self.a, self.b
1603	n/a	self.assertEqual((a-b)\|(a&b)\|(b-a), a\|b)
1604	n/a	self.assertEqual((a&b)\|(a^b), a\|b)
1605	n/a	self.assertEqual(a\|(b-a), a\|b)
1606	n/a	self.assertEqual((a-b)\|b, a\|b)
1607	n/a	self.assertEqual((a-b)\|(a&b), a)
1608	n/a	self.assertEqual((b-a)\|(a&b), b)
1609	n/a	self.assertEqual((a-b)\|(b-a), a^b)
1610	n/a
1611	n/a	def test_exclusion(self):
1612	n/a	# check that inverse operations show non-overlap
1613	n/a	a, b, zero = self.a, self.b, set()
1614	n/a	self.assertEqual((a-b)&b, zero)
1615	n/a	self.assertEqual((b-a)&a, zero)
1616	n/a	self.assertEqual((a&b)&(a^b), zero)
1617	n/a
1618	n/a	# Tests derived from test_itertools.py =======================================
1619	n/a
1620	n/a	def R(seqn):
1621	n/a	'Regular generator'
1622	n/a	for i in seqn:
1623	n/a	yield i
1624	n/a
1625	n/a	class G:
1626	n/a	'Sequence using __getitem__'
1627	n/a	def __init__(self, seqn):
1628	n/a	self.seqn = seqn
1629	n/a	def __getitem__(self, i):
1630	n/a	return self.seqn[i]
1631	n/a
1632	n/a	class I:
1633	n/a	'Sequence using iterator protocol'
1634	n/a	def __init__(self, seqn):
1635	n/a	self.seqn = seqn
1636	n/a	self.i = 0
1637	n/a	def __iter__(self):
1638	n/a	return self
1639	n/a	def __next__(self):
1640	n/a	if self.i >= len(self.seqn): raise StopIteration
1641	n/a	v = self.seqn[self.i]
1642	n/a	self.i += 1
1643	n/a	return v
1644	n/a
1645	n/a	class Ig:
1646	n/a	'Sequence using iterator protocol defined with a generator'
1647	n/a	def __init__(self, seqn):
1648	n/a	self.seqn = seqn
1649	n/a	self.i = 0
1650	n/a	def __iter__(self):
1651	n/a	for val in self.seqn:
1652	n/a	yield val
1653	n/a
1654	n/a	class X:
1655	n/a	'Missing __getitem__ and __iter__'
1656	n/a	def __init__(self, seqn):
1657	n/a	self.seqn = seqn
1658	n/a	self.i = 0
1659	n/a	def __next__(self):
1660	n/a	if self.i >= len(self.seqn): raise StopIteration
1661	n/a	v = self.seqn[self.i]
1662	n/a	self.i += 1
1663	n/a	return v
1664	n/a
1665	n/a	class N:
1666	n/a	'Iterator missing __next__()'
1667	n/a	def __init__(self, seqn):
1668	n/a	self.seqn = seqn
1669	n/a	self.i = 0
1670	n/a	def __iter__(self):
1671	n/a	return self
1672	n/a
1673	n/a	class E:
1674	n/a	'Test propagation of exceptions'
1675	n/a	def __init__(self, seqn):
1676	n/a	self.seqn = seqn
1677	n/a	self.i = 0
1678	n/a	def __iter__(self):
1679	n/a	return self
1680	n/a	def __next__(self):
1681	n/a	3 // 0
1682	n/a
1683	n/a	class S:
1684	n/a	'Test immediate stop'
1685	n/a	def __init__(self, seqn):
1686	n/a	pass
1687	n/a	def __iter__(self):
1688	n/a	return self
1689	n/a	def __next__(self):
1690	n/a	raise StopIteration
1691	n/a
1692	n/a	from itertools import chain
1693	n/a	def L(seqn):
1694	n/a	'Test multiple tiers of iterators'
1695	n/a	return chain(map(lambda x:x, R(Ig(G(seqn)))))
1696	n/a
1697	n/a	class TestVariousIteratorArgs(unittest.TestCase):
1698	n/a
1699	n/a	def test_constructor(self):
1700	n/a	for cons in (set, frozenset):
1701	n/a	for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
1702	n/a	for g in (G, I, Ig, S, L, R):
1703	n/a	self.assertEqual(sorted(cons(g(s)), key=repr), sorted(g(s), key=repr))
1704	n/a	self.assertRaises(TypeError, cons , X(s))
1705	n/a	self.assertRaises(TypeError, cons , N(s))
1706	n/a	self.assertRaises(ZeroDivisionError, cons , E(s))
1707	n/a
1708	n/a	def test_inline_methods(self):
1709	n/a	s = set('november')
1710	n/a	for data in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5), 'december'):
1711	n/a	for meth in (s.union, s.intersection, s.difference, s.symmetric_difference, s.isdisjoint):
1712	n/a	for g in (G, I, Ig, L, R):
1713	n/a	expected = meth(data)
1714	n/a	actual = meth(g(data))
1715	n/a	if isinstance(expected, bool):
1716	n/a	self.assertEqual(actual, expected)
1717	n/a	else:
1718	n/a	self.assertEqual(sorted(actual, key=repr), sorted(expected, key=repr))
1719	n/a	self.assertRaises(TypeError, meth, X(s))
1720	n/a	self.assertRaises(TypeError, meth, N(s))
1721	n/a	self.assertRaises(ZeroDivisionError, meth, E(s))
1722	n/a
1723	n/a	def test_inplace_methods(self):
1724	n/a	for data in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5), 'december'):
1725	n/a	for methname in ('update', 'intersection_update',
1726	n/a	'difference_update', 'symmetric_difference_update'):
1727	n/a	for g in (G, I, Ig, S, L, R):
1728	n/a	s = set('january')
1729	n/a	t = s.copy()
1730	n/a	getattr(s, methname)(list(g(data)))
1731	n/a	getattr(t, methname)(g(data))
1732	n/a	self.assertEqual(sorted(s, key=repr), sorted(t, key=repr))
1733	n/a
1734	n/a	self.assertRaises(TypeError, getattr(set('january'), methname), X(data))
1735	n/a	self.assertRaises(TypeError, getattr(set('january'), methname), N(data))
1736	n/a	self.assertRaises(ZeroDivisionError, getattr(set('january'), methname), E(data))
1737	n/a
1738	n/a	class bad_eq:
1739	n/a	def __eq__(self, other):
1740	n/a	if be_bad:
1741	n/a	set2.clear()
1742	n/a	raise ZeroDivisionError
1743	n/a	return self is other
1744	n/a	def __hash__(self):
1745	n/a	return 0
1746	n/a
1747	n/a	class bad_dict_clear:
1748	n/a	def __eq__(self, other):
1749	n/a	if be_bad:
1750	n/a	dict2.clear()
1751	n/a	return self is other
1752	n/a	def __hash__(self):
1753	n/a	return 0
1754	n/a
1755	n/a	class TestWeirdBugs(unittest.TestCase):
1756	n/a	def test_8420_set_merge(self):
1757	n/a	# This used to segfault
1758	n/a	global be_bad, set2, dict2
1759	n/a	be_bad = False
1760	n/a	set1 = {bad_eq()}
1761	n/a	set2 = {bad_eq() for i in range(75)}
1762	n/a	be_bad = True
1763	n/a	self.assertRaises(ZeroDivisionError, set1.update, set2)
1764	n/a
1765	n/a	be_bad = False
1766	n/a	set1 = {bad_dict_clear()}
1767	n/a	dict2 = {bad_dict_clear(): None}
1768	n/a	be_bad = True
1769	n/a	set1.symmetric_difference_update(dict2)
1770	n/a
1771	n/a	def test_iter_and_mutate(self):
1772	n/a	# Issue #24581
1773	n/a	s = set(range(100))
1774	n/a	s.clear()
1775	n/a	s.update(range(100))
1776	n/a	si = iter(s)
1777	n/a	s.clear()
1778	n/a	a = list(range(100))
1779	n/a	s.update(range(100))
1780	n/a	list(si)
1781	n/a
1782	n/a	def test_merge_and_mutate(self):
1783	n/a	class X:
1784	n/a	def __hash__(self):
1785	n/a	return hash(0)
1786	n/a	def __eq__(self, o):
1787	n/a	other.clear()
1788	n/a	return False
1789	n/a
1790	n/a	other = set()
1791	n/a	other = {X() for i in range(10)}
1792	n/a	s = {0}
1793	n/a	s.update(other)
1794	n/a
1795	n/a	# Application tests (based on David Eppstein's graph recipes ====================================
1796	n/a
1797	n/a	def powerset(U):
1798	n/a	"""Generates all subsets of a set or sequence U."""
1799	n/a	U = iter(U)
1800	n/a	try:
1801	n/a	x = frozenset([next(U)])
1802	n/a	for S in powerset(U):
1803	n/a	yield S
1804	n/a	yield S \| x
1805	n/a	except StopIteration:
1806	n/a	yield frozenset()
1807	n/a
1808	n/a	def cube(n):
1809	n/a	"""Graph of n-dimensional hypercube."""
1810	n/a	singletons = [frozenset([x]) for x in range(n)]
1811	n/a	return dict([(x, frozenset([x^s for s in singletons]))
1812	n/a	for x in powerset(range(n))])
1813	n/a
1814	n/a	def linegraph(G):
1815	n/a	"""Graph, the vertices of which are edges of G,
1816	n/a	with two vertices being adjacent iff the corresponding
1817	n/a	edges share a vertex."""
1818	n/a	L = {}
1819	n/a	for x in G:
1820	n/a	for y in G[x]:
1821	n/a	nx = [frozenset([x,z]) for z in G[x] if z != y]
1822	n/a	ny = [frozenset([y,z]) for z in G[y] if z != x]
1823	n/a	L[frozenset([x,y])] = frozenset(nx+ny)
1824	n/a	return L
1825	n/a
1826	n/a	def faces(G):
1827	n/a	'Return a set of faces in G. Where a face is a set of vertices on that face'
1828	n/a	# currently limited to triangles,squares, and pentagons
1829	n/a	f = set()
1830	n/a	for v1, edges in G.items():
1831	n/a	for v2 in edges:
1832	n/a	for v3 in G[v2]:
1833	n/a	if v1 == v3:
1834	n/a	continue
1835	n/a	if v1 in G[v3]:
1836	n/a	f.add(frozenset([v1, v2, v3]))
1837	n/a	else:
1838	n/a	for v4 in G[v3]:
1839	n/a	if v4 == v2:
1840	n/a	continue
1841	n/a	if v1 in G[v4]:
1842	n/a	f.add(frozenset([v1, v2, v3, v4]))
1843	n/a	else:
1844	n/a	for v5 in G[v4]:
1845	n/a	if v5 == v3 or v5 == v2:
1846	n/a	continue
1847	n/a	if v1 in G[v5]:
1848	n/a	f.add(frozenset([v1, v2, v3, v4, v5]))
1849	n/a	return f
1850	n/a
1851	n/a
1852	n/a	class TestGraphs(unittest.TestCase):
1853	n/a
1854	n/a	def test_cube(self):
1855	n/a
1856	n/a	g = cube(3) # vert --> {v1, v2, v3}
1857	n/a	vertices1 = set(g)
1858	n/a	self.assertEqual(len(vertices1), 8) # eight vertices
1859	n/a	for edge in g.values():
1860	n/a	self.assertEqual(len(edge), 3) # each vertex connects to three edges
1861	n/a	vertices2 = set(v for edges in g.values() for v in edges)
1862	n/a	self.assertEqual(vertices1, vertices2) # edge vertices in original set
1863	n/a
1864	n/a	cubefaces = faces(g)
1865	n/a	self.assertEqual(len(cubefaces), 6) # six faces
1866	n/a	for face in cubefaces:
1867	n/a	self.assertEqual(len(face), 4) # each face is a square
1868	n/a
1869	n/a	def test_cuboctahedron(self):
1870	n/a
1871	n/a	# http://en.wikipedia.org/wiki/Cuboctahedron
1872	n/a	# 8 triangular faces and 6 square faces
1873	n/a	# 12 identical vertices each connecting a triangle and square
1874	n/a
1875	n/a	g = cube(3)
1876	n/a	cuboctahedron = linegraph(g) # V( --> {V1, V2, V3, V4}
1877	n/a	self.assertEqual(len(cuboctahedron), 12)# twelve vertices
1878	n/a
1879	n/a	vertices = set(cuboctahedron)
1880	n/a	for edges in cuboctahedron.values():
1881	n/a	self.assertEqual(len(edges), 4) # each vertex connects to four other vertices
1882	n/a	othervertices = set(edge for edges in cuboctahedron.values() for edge in edges)
1883	n/a	self.assertEqual(vertices, othervertices) # edge vertices in original set
1884	n/a
1885	n/a	cubofaces = faces(cuboctahedron)
1886	n/a	facesizes = collections.defaultdict(int)
1887	n/a	for face in cubofaces:
1888	n/a	facesizes[len(face)] += 1
1889	n/a	self.assertEqual(facesizes[3], 8) # eight triangular faces
1890	n/a	self.assertEqual(facesizes[4], 6) # six square faces
1891	n/a
1892	n/a	for vertex in cuboctahedron:
1893	n/a	edge = vertex # Cuboctahedron vertices are edges in Cube
1894	n/a	self.assertEqual(len(edge), 2) # Two cube vertices define an edge
1895	n/a	for cubevert in edge:
1896	n/a	self.assertIn(cubevert, g)
1897	n/a
1898	n/a
1899	n/a	#==============================================================================
1900	n/a
1901	n/a	if __name__ == "__main__":
1902	n/a	unittest.main()