← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pypy/karmic

« back to all changes in this revision

Viewing changes to lib-python/2.4.1/test/test_set.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2007-04-13 09:33:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070413093309-yoojh4jcoocu2krz
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-python/2.4.1/test/test_set.py
 
1
import unittest
 
2
from test import test_support
 
3
from weakref import proxy
 
4
import operator
 
5
import copy
 
6
import pickle
 
7
import os
 
8
 
 
9
class PassThru(Exception):
 
10
    pass
 
11
 
 
12
def check_pass_thru():
 
13
    raise PassThru
 
14
    yield 1
 
15
 
 
16
class TestJointOps(unittest.TestCase):
 
17
    # Tests common to both set and frozenset
 
18
 
 
19
    def setUp(self):
 
20
        self.word = word = 'simsalabim'
 
21
        self.otherword = 'madagascar'
 
22
        self.letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
23
        self.s = self.thetype(word)
 
24
        self.d = dict.fromkeys(word)
 
25
 
 
26
    def test_new_or_init(self):
 
27
        self.assertRaises(TypeError, self.thetype, [], 2)
 
28
 
 
29
    def test_uniquification(self):
 
30
        actual = sorted(self.s)
 
31
        expected = sorted(self.d)
 
32
        self.assertEqual(actual, expected)
 
33
        self.assertRaises(PassThru, self.thetype, check_pass_thru())
 
34
        self.assertRaises(TypeError, self.thetype, [[]])
 
35
 
 
36
    def test_len(self):
 
37
        self.assertEqual(len(self.s), len(self.d))
 
38
 
 
39
    def test_contains(self):
 
40
        for c in self.letters:
 
41
            self.assertEqual(c in self.s, c in self.d)
 
42
        self.assertRaises(TypeError, self.s.__contains__, [[]])
 
43
        s = self.thetype([frozenset(self.letters)])
 
44
        self.assert_(self.thetype(self.letters) in s)
 
45
 
 
46
    def test_union(self):
 
47
        u = self.s.union(self.otherword)
 
48
        for c in self.letters:
 
49
            self.assertEqual(c in u, c in self.d or c in self.otherword)
 
50
        self.assertEqual(self.s, self.thetype(self.word))
 
51
        self.assertEqual(type(u), self.thetype)
 
52
        self.assertRaises(PassThru, self.s.union, check_pass_thru())
 
53
        self.assertRaises(TypeError, self.s.union, [[]])
 
54
        for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
55
            self.assertEqual(self.thetype('abcba').union(C('cdc')), set('abcd'))
 
56
            self.assertEqual(self.thetype('abcba').union(C('efgfe')), set('abcefg'))
 
57
            self.assertEqual(self.thetype('abcba').union(C('ccb')), set('abc'))
 
58
            self.assertEqual(self.thetype('abcba').union(C('ef')), set('abcef'))
 
59
 
 
60
    def test_or(self):
 
61
        i = self.s.union(self.otherword)
 
62
        self.assertEqual(self.s | set(self.otherword), i)
 
63
        self.assertEqual(self.s | frozenset(self.otherword), i)
 
64
        try:
 
65
            self.s | self.otherword
 
66
        except TypeError:
 
67
            pass
 
68
        else:
 
69
            self.fail("s|t did not screen-out general iterables")
 
70
 
 
71
    def test_intersection(self):
 
72
        i = self.s.intersection(self.otherword)
 
73
        for c in self.letters:
 
74
            self.assertEqual(c in i, c in self.d and c in self.otherword)
 
75
        self.assertEqual(self.s, self.thetype(self.word))
 
76
        self.assertEqual(type(i), self.thetype)
 
77
        self.assertRaises(PassThru, self.s.intersection, check_pass_thru())
 
78
        for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
79
            self.assertEqual(self.thetype('abcba').intersection(C('cdc')), set('cc'))
 
80
            self.assertEqual(self.thetype('abcba').intersection(C('efgfe')), set(''))
 
81
            self.assertEqual(self.thetype('abcba').intersection(C('ccb')), set('bc'))
 
82
            self.assertEqual(self.thetype('abcba').intersection(C('ef')), set(''))
 
83
 
 
84
    def test_and(self):
 
85
        i = self.s.intersection(self.otherword)
 
86
        self.assertEqual(self.s & set(self.otherword), i)
 
87
        self.assertEqual(self.s & frozenset(self.otherword), i)
 
88
        try:
 
89
            self.s & self.otherword
 
90
        except TypeError:
 
91
            pass
 
92
        else:
 
93
            self.fail("s&t did not screen-out general iterables")
 
94
 
 
95
    def test_difference(self):
 
96
        i = self.s.difference(self.otherword)
 
97
        for c in self.letters:
 
98
            self.assertEqual(c in i, c in self.d and c not in self.otherword)
 
99
        self.assertEqual(self.s, self.thetype(self.word))
 
100
        self.assertEqual(type(i), self.thetype)
 
101
        self.assertRaises(PassThru, self.s.difference, check_pass_thru())
 
102
        self.assertRaises(TypeError, self.s.difference, [[]])
 
103
        for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
104
            self.assertEqual(self.thetype('abcba').difference(C('cdc')), set('ab'))
 
105
            self.assertEqual(self.thetype('abcba').difference(C('efgfe')), set('abc'))
 
106
            self.assertEqual(self.thetype('abcba').difference(C('ccb')), set('a'))
 
107
            self.assertEqual(self.thetype('abcba').difference(C('ef')), set('abc'))
 
108
 
 
109
    def test_sub(self):
 
110
        i = self.s.difference(self.otherword)
 
111
        self.assertEqual(self.s - set(self.otherword), i)
 
112
        self.assertEqual(self.s - frozenset(self.otherword), i)
 
113
        try:
 
114
            self.s - self.otherword
 
115
        except TypeError:
 
116
            pass
 
117
        else:
 
118
            self.fail("s-t did not screen-out general iterables")
 
119
 
 
120
    def test_symmetric_difference(self):
 
121
        i = self.s.symmetric_difference(self.otherword)
 
122
        for c in self.letters:
 
123
            self.assertEqual(c in i, (c in self.d) ^ (c in self.otherword))
 
124
        self.assertEqual(self.s, self.thetype(self.word))
 
125
        self.assertEqual(type(i), self.thetype)
 
126
        self.assertRaises(PassThru, self.s.symmetric_difference, check_pass_thru())
 
127
        self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
 
128
        for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
129
            self.assertEqual(self.thetype('abcba').symmetric_difference(C('cdc')), set('abd'))
 
130
            self.assertEqual(self.thetype('abcba').symmetric_difference(C('efgfe')), set('abcefg'))
 
131
            self.assertEqual(self.thetype('abcba').symmetric_difference(C('ccb')), set('a'))
 
132
            self.assertEqual(self.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))
 
133
 
 
134
    def test_xor(self):
 
135
        i = self.s.symmetric_difference(self.otherword)
 
136
        self.assertEqual(self.s ^ set(self.otherword), i)
 
137
        self.assertEqual(self.s ^ frozenset(self.otherword), i)
 
138
        try:
 
139
            self.s ^ self.otherword
 
140
        except TypeError:
 
141
            pass
 
142
        else:
 
143
            self.fail("s^t did not screen-out general iterables")
 
144
 
 
145
    def test_equality(self):
 
146
        self.assertEqual(self.s, set(self.word))
 
147
        self.assertEqual(self.s, frozenset(self.word))
 
148
        self.assertEqual(self.s == self.word, False)
 
149
        self.assertNotEqual(self.s, set(self.otherword))
 
150
        self.assertNotEqual(self.s, frozenset(self.otherword))
 
151
        self.assertEqual(self.s != self.word, True)
 
152
 
 
153
    def test_setOfFrozensets(self):
 
154
        t = map(frozenset, ['abcdef', 'bcd', 'bdcb', 'fed', 'fedccba'])
 
155
        s = self.thetype(t)
 
156
        self.assertEqual(len(s), 3)
 
157
 
 
158
    def test_compare(self):
 
159
        self.assertRaises(TypeError, self.s.__cmp__, self.s)
 
160
 
 
161
    def test_sub_and_super(self):
 
162
        p, q, r = map(self.thetype, ['ab', 'abcde', 'def'])
 
163
        self.assert_(p < q)
 
164
        self.assert_(p <= q)
 
165
        self.assert_(q <= q)
 
166
        self.assert_(q > p)
 
167
        self.assert_(q >= p)
 
168
        self.failIf(q < r)
 
169
        self.failIf(q <= r)
 
170
        self.failIf(q > r)
 
171
        self.failIf(q >= r)
 
172
        self.assert_(set('a').issubset('abc'))
 
173
        self.assert_(set('abc').issuperset('a'))
 
174
        self.failIf(set('a').issubset('cbs'))
 
175
        self.failIf(set('cbs').issuperset('a'))
 
176
 
 
177
    def test_pickling(self):
 
178
        for i in (0, 1, 2):
 
179
            p = pickle.dumps(self.s, i)
 
180
            dup = pickle.loads(p)
 
181
            self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup))
 
182
            if type(self.s) not in (set, frozenset):
 
183
                self.s.x = 10
 
184
                p = pickle.dumps(self.s)
 
185
                dup = pickle.loads(p)
 
186
                self.assertEqual(self.s.x, dup.x)
 
187
 
 
188
    def test_deepcopy(self):
 
189
        class Tracer:
 
190
            def __init__(self, value):
 
191
                self.value = value
 
192
            def __hash__(self):
 
193
                return self.value
 
194
            def __deepcopy__(self, memo=None):
 
195
                return Tracer(self.value + 1)
 
196
        t = Tracer(10)
 
197
        s = self.thetype([t])
 
198
        dup = copy.deepcopy(s)
 
199
        self.assertNotEqual(id(s), id(dup))
 
200
        for elem in dup:
 
201
            newt = elem
 
202
        self.assertNotEqual(id(t), id(newt))
 
203
        self.assertEqual(t.value + 1, newt.value)
 
204
 
 
205
class TestSet(TestJointOps):
 
206
    thetype = set
 
207
 
 
208
    def test_init(self):
 
209
        s = self.thetype()
 
210
        s.__init__(self.word)
 
211
        self.assertEqual(s, set(self.word))
 
212
        s.__init__(self.otherword)
 
213
        self.assertEqual(s, set(self.otherword))
 
214
        self.assertRaises(TypeError, s.__init__, s, 2);
 
215
        self.assertRaises(TypeError, s.__init__, 1);
 
216
 
 
217
    def test_constructor_identity(self):
 
218
        s = self.thetype(range(3))
 
219
        t = self.thetype(s)
 
220
        self.assertNotEqual(id(s), id(t))
 
221
 
 
222
    def test_hash(self):
 
223
        self.assertRaises(TypeError, hash, self.s)
 
224
 
 
225
    def test_clear(self):
 
226
        self.s.clear()
 
227
        self.assertEqual(self.s, set())
 
228
        self.assertEqual(len(self.s), 0)
 
229
 
 
230
    def test_copy(self):
 
231
        dup = self.s.copy()
 
232
        self.assertEqual(self.s, dup)
 
233
        self.assertNotEqual(id(self.s), id(dup))
 
234
 
 
235
    def test_add(self):
 
236
        self.s.add('Q')
 
237
        self.assert_('Q' in self.s)
 
238
        dup = self.s.copy()
 
239
        self.s.add('Q')
 
240
        self.assertEqual(self.s, dup)
 
241
        self.assertRaises(TypeError, self.s.add, [])
 
242
 
 
243
    def test_remove(self):
 
244
        self.s.remove('a')
 
245
        self.assert_('a' not in self.s)
 
246
        self.assertRaises(KeyError, self.s.remove, 'Q')
 
247
        self.assertRaises(TypeError, self.s.remove, [])
 
248
        s = self.thetype([frozenset(self.word)])
 
249
        self.assert_(self.thetype(self.word) in s)
 
250
        s.remove(self.thetype(self.word))
 
251
        self.assert_(self.thetype(self.word) not in s)
 
252
        self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
 
253
 
 
254
    def test_discard(self):
 
255
        self.s.discard('a')
 
256
        self.assert_('a' not in self.s)
 
257
        self.s.discard('Q')
 
258
        self.assertRaises(TypeError, self.s.discard, [])
 
259
        s = self.thetype([frozenset(self.word)])
 
260
        self.assert_(self.thetype(self.word) in s)
 
261
        s.discard(self.thetype(self.word))
 
262
        self.assert_(self.thetype(self.word) not in s)
 
263
        s.discard(self.thetype(self.word))
 
264
 
 
265
    def test_pop(self):
 
266
        for i in xrange(len(self.s)):
 
267
            elem = self.s.pop()
 
268
            self.assert_(elem not in self.s)
 
269
        self.assertRaises(KeyError, self.s.pop)
 
270
 
 
271
    def test_update(self):
 
272
        retval = self.s.update(self.otherword)
 
273
        self.assertEqual(retval, None)
 
274
        for c in (self.word + self.otherword):
 
275
            self.assert_(c in self.s)
 
276
        self.assertRaises(PassThru, self.s.update, check_pass_thru())
 
277
        self.assertRaises(TypeError, self.s.update, [[]])
 
278
        for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):
 
279
            for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
280
                s = self.thetype('abcba')
 
281
                self.assertEqual(s.update(C(p)), None)
 
282
                self.assertEqual(s, set(q))
 
283
 
 
284
    def test_ior(self):
 
285
        self.s |= set(self.otherword)
 
286
        for c in (self.word + self.otherword):
 
287
            self.assert_(c in self.s)
 
288
 
 
289
    def test_intersection_update(self):
 
290
        retval = self.s.intersection_update(self.otherword)
 
291
        self.assertEqual(retval, None)
 
292
        for c in (self.word + self.otherword):
 
293
            if c in self.otherword and c in self.word:
 
294
                self.assert_(c in self.s)
 
295
            else:
 
296
                self.assert_(c not in self.s)
 
297
        self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
 
298
        self.assertRaises(TypeError, self.s.intersection_update, [[]])
 
299
        for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):
 
300
            for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
301
                s = self.thetype('abcba')
 
302
                self.assertEqual(s.intersection_update(C(p)), None)
 
303
                self.assertEqual(s, set(q))
 
304
 
 
305
    def test_iand(self):
 
306
        self.s &= set(self.otherword)
 
307
        for c in (self.word + self.otherword):
 
308
            if c in self.otherword and c in self.word:
 
309
                self.assert_(c in self.s)
 
310
            else:
 
311
                self.assert_(c not in self.s)
 
312
 
 
313
    def test_difference_update(self):
 
314
        retval = self.s.difference_update(self.otherword)
 
315
        self.assertEqual(retval, None)
 
316
        for c in (self.word + self.otherword):
 
317
            if c in self.word and c not in self.otherword:
 
318
                self.assert_(c in self.s)
 
319
            else:
 
320
                self.assert_(c not in self.s)
 
321
        self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
 
322
        self.assertRaises(TypeError, self.s.difference_update, [[]])
 
323
        self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
 
324
        for p, q in (('cdc', 'ab'), ('efgfe', 'abc'), ('ccb', 'a'), ('ef', 'abc')):
 
325
            for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
326
                s = self.thetype('abcba')
 
327
                self.assertEqual(s.difference_update(C(p)), None)
 
328
                self.assertEqual(s, set(q))
 
329
 
 
330
    def test_isub(self):
 
331
        self.s -= set(self.otherword)
 
332
        for c in (self.word + self.otherword):
 
333
            if c in self.word and c not in self.otherword:
 
334
                self.assert_(c in self.s)
 
335
            else:
 
336
                self.assert_(c not in self.s)
 
337
 
 
338
    def test_symmetric_difference_update(self):
 
339
        retval = self.s.symmetric_difference_update(self.otherword)
 
340
        self.assertEqual(retval, None)
 
341
        for c in (self.word + self.otherword):
 
342
            if (c in self.word) ^ (c in self.otherword):
 
343
                self.assert_(c in self.s)
 
344
            else:
 
345
                self.assert_(c not in self.s)
 
346
        self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
 
347
        self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
 
348
        for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):
 
349
            for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:
 
350
                s = self.thetype('abcba')
 
351
                self.assertEqual(s.symmetric_difference_update(C(p)), None)
 
352
                self.assertEqual(s, set(q))
 
353
 
 
354
    def test_ixor(self):
 
355
        self.s ^= set(self.otherword)
 
356
        for c in (self.word + self.otherword):
 
357
            if (c in self.word) ^ (c in self.otherword):
 
358
                self.assert_(c in self.s)
 
359
            else:
 
360
                self.assert_(c not in self.s)
 
361
 
 
362
    def test_weakref(self):
 
363
        s = self.thetype('gallahad')
 
364
        p = proxy(s)
 
365
        self.assertEqual(str(p), str(s))
 
366
        s = None
 
367
        self.assertRaises(ReferenceError, str, p)
 
368
 
 
369
class SetSubclass(set):
 
370
    pass
 
371
 
 
372
class TestSetSubclass(TestSet):
 
373
    thetype = SetSubclass
 
374
 
 
375
class TestFrozenSet(TestJointOps):
 
376
    thetype = frozenset
 
377
 
 
378
    def test_init(self):
 
379
        s = self.thetype(self.word)
 
380
        s.__init__(self.otherword)
 
381
        self.assertEqual(s, set(self.word))
 
382
 
 
383
    def test_constructor_identity(self):
 
384
        s = self.thetype(range(3))
 
385
        t = self.thetype(s)
 
386
        self.assertEqual(id(s), id(t))
 
387
 
 
388
    def test_hash(self):
 
389
        self.assertEqual(hash(self.thetype('abcdeb')),
 
390
                         hash(self.thetype('ebecda')))
 
391
 
 
392
    def test_copy(self):
 
393
        dup = self.s.copy()
 
394
        self.assertEqual(id(self.s), id(dup))
 
395
 
 
396
    def test_frozen_as_dictkey(self):
 
397
        seq = range(10) + list('abcdefg') + ['apple']
 
398
        key1 = self.thetype(seq)
 
399
        key2 = self.thetype(reversed(seq))
 
400
        self.assertEqual(key1, key2)
 
401
        self.assertNotEqual(id(key1), id(key2))
 
402
        d = {}
 
403
        d[key1] = 42
 
404
        self.assertEqual(d[key2], 42)
 
405
 
 
406
    def test_hash_caching(self):
 
407
        f = self.thetype('abcdcda')
 
408
        self.assertEqual(hash(f), hash(f))
 
409
 
 
410
    def test_hash_effectiveness(self):
 
411
        n = 13
 
412
        hashvalues = set()
 
413
        addhashvalue = hashvalues.add
 
414
        elemmasks = [(i+1, 1<<i) for i in range(n)]
 
415
        for i in xrange(2**n):
 
416
            addhashvalue(hash(frozenset([e for e, m in elemmasks if m&i])))
 
417
        self.assertEqual(len(hashvalues), 2**n)
 
418
 
 
419
class FrozenSetSubclass(frozenset):
 
420
    pass
 
421
 
 
422
class TestFrozenSetSubclass(TestFrozenSet):
 
423
    thetype = FrozenSetSubclass
 
424
 
 
425
    def test_constructor_identity(self):
 
426
        s = self.thetype(range(3))
 
427
        t = self.thetype(s)
 
428
        self.assertNotEqual(id(s), id(t))
 
429
 
 
430
    def test_copy(self):
 
431
        dup = self.s.copy()
 
432
        self.assertNotEqual(id(self.s), id(dup))
 
433
 
 
434
    def test_nested_empty_constructor(self):
 
435
        s = self.thetype()
 
436
        t = self.thetype(s)
 
437
        self.assertEqual(s, t)
 
438
 
 
439
# Tests taken from test_sets.py =============================================
 
440
 
 
441
empty_set = set()
 
442
 
 
443
#==============================================================================
 
444
 
 
445
class TestBasicOps(unittest.TestCase):
 
446
 
 
447
    def test_repr(self):
 
448
        if self.repr is not None:
 
449
            self.assertEqual(repr(self.set), self.repr)
 
450
 
 
451
    def test_print(self):
 
452
        try:
 
453
            fo = open(test_support.TESTFN, "wb")
 
454
            print >> fo, self.set,
 
455
            fo.close()
 
456
            fo = open(test_support.TESTFN, "rb")
 
457
            self.assertEqual(fo.read(), repr(self.set))
 
458
        finally:
 
459
            fo.close()
 
460
            os.remove(test_support.TESTFN)
 
461
 
 
462
    def test_length(self):
 
463
        self.assertEqual(len(self.set), self.length)
 
464
 
 
465
    def test_self_equality(self):
 
466
        self.assertEqual(self.set, self.set)
 
467
 
 
468
    def test_equivalent_equality(self):
 
469
        self.assertEqual(self.set, self.dup)
 
470
 
 
471
    def test_copy(self):
 
472
        self.assertEqual(self.set.copy(), self.dup)
 
473
 
 
474
    def test_self_union(self):
 
475
        result = self.set | self.set
 
476
        self.assertEqual(result, self.dup)
 
477
 
 
478
    def test_empty_union(self):
 
479
        result = self.set | empty_set
 
480
        self.assertEqual(result, self.dup)
 
481
 
 
482
    def test_union_empty(self):
 
483
        result = empty_set | self.set
 
484
        self.assertEqual(result, self.dup)
 
485
 
 
486
    def test_self_intersection(self):
 
487
        result = self.set & self.set
 
488
        self.assertEqual(result, self.dup)
 
489
 
 
490
    def test_empty_intersection(self):
 
491
        result = self.set & empty_set
 
492
        self.assertEqual(result, empty_set)
 
493
 
 
494
    def test_intersection_empty(self):
 
495
        result = empty_set & self.set
 
496
        self.assertEqual(result, empty_set)
 
497
 
 
498
    def test_self_symmetric_difference(self):
 
499
        result = self.set ^ self.set
 
500
        self.assertEqual(result, empty_set)
 
501
 
 
502
    def checkempty_symmetric_difference(self):
 
503
        result = self.set ^ empty_set
 
504
        self.assertEqual(result, self.set)
 
505
 
 
506
    def test_self_difference(self):
 
507
        result = self.set - self.set
 
508
        self.assertEqual(result, empty_set)
 
509
 
 
510
    def test_empty_difference(self):
 
511
        result = self.set - empty_set
 
512
        self.assertEqual(result, self.dup)
 
513
 
 
514
    def test_empty_difference_rev(self):
 
515
        result = empty_set - self.set
 
516
        self.assertEqual(result, empty_set)
 
517
 
 
518
    def test_iteration(self):
 
519
        for v in self.set:
 
520
            self.assert_(v in self.values)
 
521
 
 
522
    def test_pickling(self):
 
523
        p = pickle.dumps(self.set)
 
524
        copy = pickle.loads(p)
 
525
        self.assertEqual(self.set, copy,
 
526
                         "%s != %s" % (self.set, copy))
 
527
 
 
528
#------------------------------------------------------------------------------
 
529
 
 
530
class TestBasicOpsEmpty(TestBasicOps):
 
531
    def setUp(self):
 
532
        self.case   = "empty set"
 
533
        self.values = []
 
534
        self.set    = set(self.values)
 
535
        self.dup    = set(self.values)
 
536
        self.length = 0
 
537
        self.repr   = "set([])"
 
538
 
 
539
#------------------------------------------------------------------------------
 
540
 
 
541
class TestBasicOpsSingleton(TestBasicOps):
 
542
    def setUp(self):
 
543
        self.case   = "unit set (number)"
 
544
        self.values = [3]
 
545
        self.set    = set(self.values)
 
546
        self.dup    = set(self.values)
 
547
        self.length = 1
 
548
        self.repr   = "set([3])"
 
549
 
 
550
    def test_in(self):
 
551
        self.failUnless(3 in self.set)
 
552
 
 
553
    def test_not_in(self):
 
554
        self.failUnless(2 not in self.set)
 
555
 
 
556
#------------------------------------------------------------------------------
 
557
 
 
558
class TestBasicOpsTuple(TestBasicOps):
 
559
    def setUp(self):
 
560
        self.case   = "unit set (tuple)"
 
561
        self.values = [(0, "zero")]
 
562
        self.set    = set(self.values)
 
563
        self.dup    = set(self.values)
 
564
        self.length = 1
 
565
        self.repr   = "set([(0, 'zero')])"
 
566
 
 
567
    def test_in(self):
 
568
        self.failUnless((0, "zero") in self.set)
 
569
 
 
570
    def test_not_in(self):
 
571
        self.failUnless(9 not in self.set)
 
572
 
 
573
#------------------------------------------------------------------------------
 
574
 
 
575
class TestBasicOpsTriple(TestBasicOps):
 
576
    def setUp(self):
 
577
        self.case   = "triple set"
 
578
        self.values = [0, "zero", operator.add]
 
579
        self.set    = set(self.values)
 
580
        self.dup    = set(self.values)
 
581
        self.length = 3
 
582
        self.repr   = None
 
583
 
 
584
#==============================================================================
 
585
 
 
586
def baditer():
 
587
    raise TypeError
 
588
    yield True
 
589
 
 
590
def gooditer():
 
591
    yield True
 
592
 
 
593
class TestExceptionPropagation(unittest.TestCase):
 
594
    """SF 628246:  Set constructor should not trap iterator TypeErrors"""
 
595
 
 
596
    def test_instanceWithException(self):
 
597
        self.assertRaises(TypeError, set, baditer())
 
598
 
 
599
    def test_instancesWithoutException(self):
 
600
        # All of these iterables should load without exception.
 
601
        set([1,2,3])
 
602
        set((1,2,3))
 
603
        set({'one':1, 'two':2, 'three':3})
 
604
        set(xrange(3))
 
605
        set('abc')
 
606
        set(gooditer())
 
607
 
 
608
#==============================================================================
 
609
 
 
610
class TestSetOfSets(unittest.TestCase):
 
611
    def test_constructor(self):
 
612
        inner = frozenset([1])
 
613
        outer = set([inner])
 
614
        element = outer.pop()
 
615
        self.assertEqual(type(element), frozenset)
 
616
        outer.add(inner)        # Rebuild set of sets with .add method
 
617
        outer.remove(inner)
 
618
        self.assertEqual(outer, set())   # Verify that remove worked
 
619
        outer.discard(inner)    # Absence of KeyError indicates working fine
 
620
 
 
621
#==============================================================================
 
622
 
 
623
class TestBinaryOps(unittest.TestCase):
 
624
    def setUp(self):
 
625
        self.set = set((2, 4, 6))
 
626
 
 
627
    def test_eq(self):              # SF bug 643115
 
628
        self.assertEqual(self.set, set({2:1,4:3,6:5}))
 
629
 
 
630
    def test_union_subset(self):
 
631
        result = self.set | set([2])
 
632
        self.assertEqual(result, set((2, 4, 6)))
 
633
 
 
634
    def test_union_superset(self):
 
635
        result = self.set | set([2, 4, 6, 8])
 
636
        self.assertEqual(result, set([2, 4, 6, 8]))
 
637
 
 
638
    def test_union_overlap(self):
 
639
        result = self.set | set([3, 4, 5])
 
640
        self.assertEqual(result, set([2, 3, 4, 5, 6]))
 
641
 
 
642
    def test_union_non_overlap(self):
 
643
        result = self.set | set([8])
 
644
        self.assertEqual(result, set([2, 4, 6, 8]))
 
645
 
 
646
    def test_intersection_subset(self):
 
647
        result = self.set & set((2, 4))
 
648
        self.assertEqual(result, set((2, 4)))
 
649
 
 
650
    def test_intersection_superset(self):
 
651
        result = self.set & set([2, 4, 6, 8])
 
652
        self.assertEqual(result, set([2, 4, 6]))
 
653
 
 
654
    def test_intersection_overlap(self):
 
655
        result = self.set & set([3, 4, 5])
 
656
        self.assertEqual(result, set([4]))
 
657
 
 
658
    def test_intersection_non_overlap(self):
 
659
        result = self.set & set([8])
 
660
        self.assertEqual(result, empty_set)
 
661
 
 
662
    def test_sym_difference_subset(self):
 
663
        result = self.set ^ set((2, 4))
 
664
        self.assertEqual(result, set([6]))
 
665
 
 
666
    def test_sym_difference_superset(self):
 
667
        result = self.set ^ set((2, 4, 6, 8))
 
668
        self.assertEqual(result, set([8]))
 
669
 
 
670
    def test_sym_difference_overlap(self):
 
671
        result = self.set ^ set((3, 4, 5))
 
672
        self.assertEqual(result, set([2, 3, 5, 6]))
 
673
 
 
674
    def test_sym_difference_non_overlap(self):
 
675
        result = self.set ^ set([8])
 
676
        self.assertEqual(result, set([2, 4, 6, 8]))
 
677
 
 
678
    def test_cmp(self):
 
679
        a, b = set('a'), set('b')
 
680
        self.assertRaises(TypeError, cmp, a, b)
 
681
 
 
682
        # You can view this as a buglet:  cmp(a, a) does not raise TypeError,
 
683
        # because __eq__ is tried before __cmp__, and a.__eq__(a) returns True,
 
684
        # which Python thinks is good enough to synthesize a cmp() result
 
685
        # without calling __cmp__.
 
686
        self.assertEqual(cmp(a, a), 0)
 
687
 
 
688
        self.assertRaises(TypeError, cmp, a, 12)
 
689
        self.assertRaises(TypeError, cmp, "abc", a)
 
690
 
 
691
#==============================================================================
 
692
 
 
693
class TestUpdateOps(unittest.TestCase):
 
694
    def setUp(self):
 
695
        self.set = set((2, 4, 6))
 
696
 
 
697
    def test_union_subset(self):
 
698
        self.set |= set([2])
 
699
        self.assertEqual(self.set, set((2, 4, 6)))
 
700
 
 
701
    def test_union_superset(self):
 
702
        self.set |= set([2, 4, 6, 8])
 
703
        self.assertEqual(self.set, set([2, 4, 6, 8]))
 
704
 
 
705
    def test_union_overlap(self):
 
706
        self.set |= set([3, 4, 5])
 
707
        self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
 
708
 
 
709
    def test_union_non_overlap(self):
 
710
        self.set |= set([8])
 
711
        self.assertEqual(self.set, set([2, 4, 6, 8]))
 
712
 
 
713
    def test_union_method_call(self):
 
714
        self.set.update(set([3, 4, 5]))
 
715
        self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
 
716
 
 
717
    def test_intersection_subset(self):
 
718
        self.set &= set((2, 4))
 
719
        self.assertEqual(self.set, set((2, 4)))
 
720
 
 
721
    def test_intersection_superset(self):
 
722
        self.set &= set([2, 4, 6, 8])
 
723
        self.assertEqual(self.set, set([2, 4, 6]))
 
724
 
 
725
    def test_intersection_overlap(self):
 
726
        self.set &= set([3, 4, 5])
 
727
        self.assertEqual(self.set, set([4]))
 
728
 
 
729
    def test_intersection_non_overlap(self):
 
730
        self.set &= set([8])
 
731
        self.assertEqual(self.set, empty_set)
 
732
 
 
733
    def test_intersection_method_call(self):
 
734
        self.set.intersection_update(set([3, 4, 5]))
 
735
        self.assertEqual(self.set, set([4]))
 
736
 
 
737
    def test_sym_difference_subset(self):
 
738
        self.set ^= set((2, 4))
 
739
        self.assertEqual(self.set, set([6]))
 
740
 
 
741
    def test_sym_difference_superset(self):
 
742
        self.set ^= set((2, 4, 6, 8))
 
743
        self.assertEqual(self.set, set([8]))
 
744
 
 
745
    def test_sym_difference_overlap(self):
 
746
        self.set ^= set((3, 4, 5))
 
747
        self.assertEqual(self.set, set([2, 3, 5, 6]))
 
748
 
 
749
    def test_sym_difference_non_overlap(self):
 
750
        self.set ^= set([8])
 
751
        self.assertEqual(self.set, set([2, 4, 6, 8]))
 
752
 
 
753
    def test_sym_difference_method_call(self):
 
754
        self.set.symmetric_difference_update(set([3, 4, 5]))
 
755
        self.assertEqual(self.set, set([2, 3, 5, 6]))
 
756
 
 
757
    def test_difference_subset(self):
 
758
        self.set -= set((2, 4))
 
759
        self.assertEqual(self.set, set([6]))
 
760
 
 
761
    def test_difference_superset(self):
 
762
        self.set -= set((2, 4, 6, 8))
 
763
        self.assertEqual(self.set, set([]))
 
764
 
 
765
    def test_difference_overlap(self):
 
766
        self.set -= set((3, 4, 5))
 
767
        self.assertEqual(self.set, set([2, 6]))
 
768
 
 
769
    def test_difference_non_overlap(self):
 
770
        self.set -= set([8])
 
771
        self.assertEqual(self.set, set([2, 4, 6]))
 
772
 
 
773
    def test_difference_method_call(self):
 
774
        self.set.difference_update(set([3, 4, 5]))
 
775
        self.assertEqual(self.set, set([2, 6]))
 
776
 
 
777
#==============================================================================
 
778
 
 
779
class TestMutate(unittest.TestCase):
 
780
    def setUp(self):
 
781
        self.values = ["a", "b", "c"]
 
782
        self.set = set(self.values)
 
783
 
 
784
    def test_add_present(self):
 
785
        self.set.add("c")
 
786
        self.assertEqual(self.set, set("abc"))
 
787
 
 
788
    def test_add_absent(self):
 
789
        self.set.add("d")
 
790
        self.assertEqual(self.set, set("abcd"))
 
791
 
 
792
    def test_add_until_full(self):
 
793
        tmp = set()
 
794
        expected_len = 0
 
795
        for v in self.values:
 
796
            tmp.add(v)
 
797
            expected_len += 1
 
798
            self.assertEqual(len(tmp), expected_len)
 
799
        self.assertEqual(tmp, self.set)
 
800
 
 
801
    def test_remove_present(self):
 
802
        self.set.remove("b")
 
803
        self.assertEqual(self.set, set("ac"))
 
804
 
 
805
    def test_remove_absent(self):
 
806
        try:
 
807
            self.set.remove("d")
 
808
            self.fail("Removing missing element should have raised LookupError")
 
809
        except LookupError:
 
810
            pass
 
811
 
 
812
    def test_remove_until_empty(self):
 
813
        expected_len = len(self.set)
 
814
        for v in self.values:
 
815
            self.set.remove(v)
 
816
            expected_len -= 1
 
817
            self.assertEqual(len(self.set), expected_len)
 
818
 
 
819
    def test_discard_present(self):
 
820
        self.set.discard("c")
 
821
        self.assertEqual(self.set, set("ab"))
 
822
 
 
823
    def test_discard_absent(self):
 
824
        self.set.discard("d")
 
825
        self.assertEqual(self.set, set("abc"))
 
826
 
 
827
    def test_clear(self):
 
828
        self.set.clear()
 
829
        self.assertEqual(len(self.set), 0)
 
830
 
 
831
    def test_pop(self):
 
832
        popped = {}
 
833
        while self.set:
 
834
            popped[self.set.pop()] = None
 
835
        self.assertEqual(len(popped), len(self.values))
 
836
        for v in self.values:
 
837
            self.failUnless(v in popped)
 
838
 
 
839
    def test_update_empty_tuple(self):
 
840
        self.set.update(())
 
841
        self.assertEqual(self.set, set(self.values))
 
842
 
 
843
    def test_update_unit_tuple_overlap(self):
 
844
        self.set.update(("a",))
 
845
        self.assertEqual(self.set, set(self.values))
 
846
 
 
847
    def test_update_unit_tuple_non_overlap(self):
 
848
        self.set.update(("a", "z"))
 
849
        self.assertEqual(self.set, set(self.values + ["z"]))
 
850
 
 
851
#==============================================================================
 
852
 
 
853
class TestSubsets(unittest.TestCase):
 
854
 
 
855
    case2method = {"<=": "issubset",
 
856
                   ">=": "issuperset",
 
857
                  }
 
858
 
 
859
    reverse = {"==": "==",
 
860
               "!=": "!=",
 
861
               "<":  ">",
 
862
               ">":  "<",
 
863
               "<=": ">=",
 
864
               ">=": "<=",
 
865
              }
 
866
 
 
867
    def test_issubset(self):
 
868
        x = self.left
 
869
        y = self.right
 
870
        for case in "!=", "==", "<", "<=", ">", ">=":
 
871
            expected = case in self.cases
 
872
            # Test the binary infix spelling.
 
873
            result = eval("x" + case + "y", locals())
 
874
            self.assertEqual(result, expected)
 
875
            # Test the "friendly" method-name spelling, if one exists.
 
876
            if case in TestSubsets.case2method:
 
877
                method = getattr(x, TestSubsets.case2method[case])
 
878
                result = method(y)
 
879
                self.assertEqual(result, expected)
 
880
 
 
881
            # Now do the same for the operands reversed.
 
882
            rcase = TestSubsets.reverse[case]
 
883
            result = eval("y" + rcase + "x", locals())
 
884
            self.assertEqual(result, expected)
 
885
            if rcase in TestSubsets.case2method:
 
886
                method = getattr(y, TestSubsets.case2method[rcase])
 
887
                result = method(x)
 
888
                self.assertEqual(result, expected)
 
889
#------------------------------------------------------------------------------
 
890
 
 
891
class TestSubsetEqualEmpty(TestSubsets):
 
892
    left  = set()
 
893
    right = set()
 
894
    name  = "both empty"
 
895
    cases = "==", "<=", ">="
 
896
 
 
897
#------------------------------------------------------------------------------
 
898
 
 
899
class TestSubsetEqualNonEmpty(TestSubsets):
 
900
    left  = set([1, 2])
 
901
    right = set([1, 2])
 
902
    name  = "equal pair"
 
903
    cases = "==", "<=", ">="
 
904
 
 
905
#------------------------------------------------------------------------------
 
906
 
 
907
class TestSubsetEmptyNonEmpty(TestSubsets):
 
908
    left  = set()
 
909
    right = set([1, 2])
 
910
    name  = "one empty, one non-empty"
 
911
    cases = "!=", "<", "<="
 
912
 
 
913
#------------------------------------------------------------------------------
 
914
 
 
915
class TestSubsetPartial(TestSubsets):
 
916
    left  = set([1])
 
917
    right = set([1, 2])
 
918
    name  = "one a non-empty proper subset of other"
 
919
    cases = "!=", "<", "<="
 
920
 
 
921
#------------------------------------------------------------------------------
 
922
 
 
923
class TestSubsetNonOverlap(TestSubsets):
 
924
    left  = set([1])
 
925
    right = set([2])
 
926
    name  = "neither empty, neither contains"
 
927
    cases = "!="
 
928
 
 
929
#==============================================================================
 
930
 
 
931
class TestOnlySetsInBinaryOps(unittest.TestCase):
 
932
 
 
933
    def test_eq_ne(self):
 
934
        # Unlike the others, this is testing that == and != *are* allowed.
 
935
        self.assertEqual(self.other == self.set, False)
 
936
        self.assertEqual(self.set == self.other, False)
 
937
        self.assertEqual(self.other != self.set, True)
 
938
        self.assertEqual(self.set != self.other, True)
 
939
 
 
940
    def test_ge_gt_le_lt(self):
 
941
        self.assertRaises(TypeError, lambda: self.set < self.other)
 
942
        self.assertRaises(TypeError, lambda: self.set <= self.other)
 
943
        self.assertRaises(TypeError, lambda: self.set > self.other)
 
944
        self.assertRaises(TypeError, lambda: self.set >= self.other)
 
945
 
 
946
        self.assertRaises(TypeError, lambda: self.other < self.set)
 
947
        self.assertRaises(TypeError, lambda: self.other <= self.set)
 
948
        self.assertRaises(TypeError, lambda: self.other > self.set)
 
949
        self.assertRaises(TypeError, lambda: self.other >= self.set)
 
950
 
 
951
    def test_update_operator(self):
 
952
        try:
 
953
            self.set |= self.other
 
954
        except TypeError:
 
955
            pass
 
956
        else:
 
957
            self.fail("expected TypeError")
 
958
 
 
959
    def test_update(self):
 
960
        if self.otherIsIterable:
 
961
            self.set.update(self.other)
 
962
        else:
 
963
            self.assertRaises(TypeError, self.set.update, self.other)
 
964
 
 
965
    def test_union(self):
 
966
        self.assertRaises(TypeError, lambda: self.set | self.other)
 
967
        self.assertRaises(TypeError, lambda: self.other | self.set)
 
968
        if self.otherIsIterable:
 
969
            self.set.union(self.other)
 
970
        else:
 
971
            self.assertRaises(TypeError, self.set.union, self.other)
 
972
 
 
973
    def test_intersection_update_operator(self):
 
974
        try:
 
975
            self.set &= self.other
 
976
        except TypeError:
 
977
            pass
 
978
        else:
 
979
            self.fail("expected TypeError")
 
980
 
 
981
    def test_intersection_update(self):
 
982
        if self.otherIsIterable:
 
983
            self.set.intersection_update(self.other)
 
984
        else:
 
985
            self.assertRaises(TypeError,
 
986
                              self.set.intersection_update,
 
987
                              self.other)
 
988
 
 
989
    def test_intersection(self):
 
990
        self.assertRaises(TypeError, lambda: self.set & self.other)
 
991
        self.assertRaises(TypeError, lambda: self.other & self.set)
 
992
        if self.otherIsIterable:
 
993
            self.set.intersection(self.other)
 
994
        else:
 
995
            self.assertRaises(TypeError, self.set.intersection, self.other)
 
996
 
 
997
    def test_sym_difference_update_operator(self):
 
998
        try:
 
999
            self.set ^= self.other
 
1000
        except TypeError:
 
1001
            pass
 
1002
        else:
 
1003
            self.fail("expected TypeError")
 
1004
 
 
1005
    def test_sym_difference_update(self):
 
1006
        if self.otherIsIterable:
 
1007
            self.set.symmetric_difference_update(self.other)
 
1008
        else:
 
1009
            self.assertRaises(TypeError,
 
1010
                              self.set.symmetric_difference_update,
 
1011
                              self.other)
 
1012
 
 
1013
    def test_sym_difference(self):
 
1014
        self.assertRaises(TypeError, lambda: self.set ^ self.other)
 
1015
        self.assertRaises(TypeError, lambda: self.other ^ self.set)
 
1016
        if self.otherIsIterable:
 
1017
            self.set.symmetric_difference(self.other)
 
1018
        else:
 
1019
            self.assertRaises(TypeError, self.set.symmetric_difference, self.other)
 
1020
 
 
1021
    def test_difference_update_operator(self):
 
1022
        try:
 
1023
            self.set -= self.other
 
1024
        except TypeError:
 
1025
            pass
 
1026
        else:
 
1027
            self.fail("expected TypeError")
 
1028
 
 
1029
    def test_difference_update(self):
 
1030
        if self.otherIsIterable:
 
1031
            self.set.difference_update(self.other)
 
1032
        else:
 
1033
            self.assertRaises(TypeError,
 
1034
                              self.set.difference_update,
 
1035
                              self.other)
 
1036
 
 
1037
    def test_difference(self):
 
1038
        self.assertRaises(TypeError, lambda: self.set - self.other)
 
1039
        self.assertRaises(TypeError, lambda: self.other - self.set)
 
1040
        if self.otherIsIterable:
 
1041
            self.set.difference(self.other)
 
1042
        else:
 
1043
            self.assertRaises(TypeError, self.set.difference, self.other)
 
1044
 
 
1045
#------------------------------------------------------------------------------
 
1046
 
 
1047
class TestOnlySetsNumeric(TestOnlySetsInBinaryOps):
 
1048
    def setUp(self):
 
1049
        self.set   = set((1, 2, 3))
 
1050
        self.other = 19
 
1051
        self.otherIsIterable = False
 
1052
 
 
1053
#------------------------------------------------------------------------------
 
1054
 
 
1055
class TestOnlySetsDict(TestOnlySetsInBinaryOps):
 
1056
    def setUp(self):
 
1057
        self.set   = set((1, 2, 3))
 
1058
        self.other = {1:2, 3:4}
 
1059
        self.otherIsIterable = True
 
1060
 
 
1061
#------------------------------------------------------------------------------
 
1062
 
 
1063
class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
 
1064
    def setUp(self):
 
1065
        self.set   = set((1, 2, 3))
 
1066
        self.other = operator.add
 
1067
        self.otherIsIterable = False
 
1068
 
 
1069
#------------------------------------------------------------------------------
 
1070
 
 
1071
class TestOnlySetsTuple(TestOnlySetsInBinaryOps):
 
1072
    def setUp(self):
 
1073
        self.set   = set((1, 2, 3))
 
1074
        self.other = (2, 4, 6)
 
1075
        self.otherIsIterable = True
 
1076
 
 
1077
#------------------------------------------------------------------------------
 
1078
 
 
1079
class TestOnlySetsString(TestOnlySetsInBinaryOps):
 
1080
    def setUp(self):
 
1081
        self.set   = set((1, 2, 3))
 
1082
        self.other = 'abc'
 
1083
        self.otherIsIterable = True
 
1084
 
 
1085
#------------------------------------------------------------------------------
 
1086
 
 
1087
class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):
 
1088
    def setUp(self):
 
1089
        def gen():
 
1090
            for i in xrange(0, 10, 2):
 
1091
                yield i
 
1092
        self.set   = set((1, 2, 3))
 
1093
        self.other = gen()
 
1094
        self.otherIsIterable = True
 
1095
 
 
1096
#==============================================================================
 
1097
 
 
1098
class TestCopying(unittest.TestCase):
 
1099
 
 
1100
    def test_copy(self):
 
1101
        dup = self.set.copy()
 
1102
        dup_list = list(dup); dup_list.sort()
 
1103
        set_list = list(self.set); set_list.sort()
 
1104
        self.assertEqual(len(dup_list), len(set_list))
 
1105
        for i in range(len(dup_list)):
 
1106
            self.failUnless(dup_list[i] is set_list[i])
 
1107
 
 
1108
    def test_deep_copy(self):
 
1109
        dup = copy.deepcopy(self.set)
 
1110
        ##print type(dup), repr(dup)
 
1111
        dup_list = list(dup); dup_list.sort()
 
1112
        set_list = list(self.set); set_list.sort()
 
1113
        self.assertEqual(len(dup_list), len(set_list))
 
1114
        for i in range(len(dup_list)):
 
1115
            self.assertEqual(dup_list[i], set_list[i])
 
1116
 
 
1117
#------------------------------------------------------------------------------
 
1118
 
 
1119
class TestCopyingEmpty(TestCopying):
 
1120
    def setUp(self):
 
1121
        self.set = set()
 
1122
 
 
1123
#------------------------------------------------------------------------------
 
1124
 
 
1125
class TestCopyingSingleton(TestCopying):
 
1126
    def setUp(self):
 
1127
        self.set = set(["hello"])
 
1128
 
 
1129
#------------------------------------------------------------------------------
 
1130
 
 
1131
class TestCopyingTriple(TestCopying):
 
1132
    def setUp(self):
 
1133
        self.set = set(["zero", 0, None])
 
1134
 
 
1135
#------------------------------------------------------------------------------
 
1136
 
 
1137
class TestCopyingTuple(TestCopying):
 
1138
    def setUp(self):
 
1139
        self.set = set([(1, 2)])
 
1140
 
 
1141
#------------------------------------------------------------------------------
 
1142
 
 
1143
class TestCopyingNested(TestCopying):
 
1144
    def setUp(self):
 
1145
        self.set = set([((1, 2), (3, 4))])
 
1146
 
 
1147
#==============================================================================
 
1148
 
 
1149
class TestIdentities(unittest.TestCase):
 
1150
    def setUp(self):
 
1151
        self.a = set('abracadabra')
 
1152
        self.b = set('alacazam')
 
1153
 
 
1154
    def test_binopsVsSubsets(self):
 
1155
        a, b = self.a, self.b
 
1156
        self.assert_(a - b < a)
 
1157
        self.assert_(b - a < b)
 
1158
        self.assert_(a & b < a)
 
1159
        self.assert_(a & b < b)
 
1160
        self.assert_(a | b > a)
 
1161
        self.assert_(a | b > b)
 
1162
        self.assert_(a ^ b < a | b)
 
1163
 
 
1164
    def test_commutativity(self):
 
1165
        a, b = self.a, self.b
 
1166
        self.assertEqual(a&b, b&a)
 
1167
        self.assertEqual(a|b, b|a)
 
1168
        self.assertEqual(a^b, b^a)
 
1169
        if a != b:
 
1170
            self.assertNotEqual(a-b, b-a)
 
1171
 
 
1172
    def test_summations(self):
 
1173
        # check that sums of parts equal the whole
 
1174
        a, b = self.a, self.b
 
1175
        self.assertEqual((a-b)|(a&b)|(b-a), a|b)
 
1176
        self.assertEqual((a&b)|(a^b), a|b)
 
1177
        self.assertEqual(a|(b-a), a|b)
 
1178
        self.assertEqual((a-b)|b, a|b)
 
1179
        self.assertEqual((a-b)|(a&b), a)
 
1180
        self.assertEqual((b-a)|(a&b), b)
 
1181
        self.assertEqual((a-b)|(b-a), a^b)
 
1182
 
 
1183
    def test_exclusion(self):
 
1184
        # check that inverse operations show non-overlap
 
1185
        a, b, zero = self.a, self.b, set()
 
1186
        self.assertEqual((a-b)&b, zero)
 
1187
        self.assertEqual((b-a)&a, zero)
 
1188
        self.assertEqual((a&b)&(a^b), zero)
 
1189
 
 
1190
# Tests derived from test_itertools.py =======================================
 
1191
 
 
1192
def R(seqn):
 
1193
    'Regular generator'
 
1194
    for i in seqn:
 
1195
        yield i
 
1196
 
 
1197
class G:
 
1198
    'Sequence using __getitem__'
 
1199
    def __init__(self, seqn):
 
1200
        self.seqn = seqn
 
1201
    def __getitem__(self, i):
 
1202
        return self.seqn[i]
 
1203
 
 
1204
class I:
 
1205
    'Sequence using iterator protocol'
 
1206
    def __init__(self, seqn):
 
1207
        self.seqn = seqn
 
1208
        self.i = 0
 
1209
    def __iter__(self):
 
1210
        return self
 
1211
    def next(self):
 
1212
        if self.i >= len(self.seqn): raise StopIteration
 
1213
        v = self.seqn[self.i]
 
1214
        self.i += 1
 
1215
        return v
 
1216
 
 
1217
class Ig:
 
1218
    'Sequence using iterator protocol defined with a generator'
 
1219
    def __init__(self, seqn):
 
1220
        self.seqn = seqn
 
1221
        self.i = 0
 
1222
    def __iter__(self):
 
1223
        for val in self.seqn:
 
1224
            yield val
 
1225
 
 
1226
class X:
 
1227
    'Missing __getitem__ and __iter__'
 
1228
    def __init__(self, seqn):
 
1229
        self.seqn = seqn
 
1230
        self.i = 0
 
1231
    def next(self):
 
1232
        if self.i >= len(self.seqn): raise StopIteration
 
1233
        v = self.seqn[self.i]
 
1234
        self.i += 1
 
1235
        return v
 
1236
 
 
1237
class N:
 
1238
    'Iterator missing next()'
 
1239
    def __init__(self, seqn):
 
1240
        self.seqn = seqn
 
1241
        self.i = 0
 
1242
    def __iter__(self):
 
1243
        return self
 
1244
 
 
1245
class E:
 
1246
    'Test propagation of exceptions'
 
1247
    def __init__(self, seqn):
 
1248
        self.seqn = seqn
 
1249
        self.i = 0
 
1250
    def __iter__(self):
 
1251
        return self
 
1252
    def next(self):
 
1253
        3 // 0
 
1254
 
 
1255
class S:
 
1256
    'Test immediate stop'
 
1257
    def __init__(self, seqn):
 
1258
        pass
 
1259
    def __iter__(self):
 
1260
        return self
 
1261
    def next(self):
 
1262
        raise StopIteration
 
1263
 
 
1264
from itertools import chain, imap
 
1265
def L(seqn):
 
1266
    'Test multiple tiers of iterators'
 
1267
    return chain(imap(lambda x:x, R(Ig(G(seqn)))))
 
1268
 
 
1269
class TestVariousIteratorArgs(unittest.TestCase):
 
1270
 
 
1271
    def test_constructor(self):
 
1272
        for cons in (set, frozenset):
 
1273
            for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
 
1274
                for g in (G, I, Ig, S, L, R):
 
1275
                    self.assertEqual(sorted(cons(g(s))), sorted(g(s)))
 
1276
                self.assertRaises(TypeError, cons , X(s))
 
1277
                self.assertRaises(TypeError, cons , N(s))
 
1278
                self.assertRaises(ZeroDivisionError, cons , E(s))
 
1279
 
 
1280
    def test_inline_methods(self):
 
1281
        s = set('november')
 
1282
        for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
 
1283
            for meth in (s.union, s.intersection, s.difference, s.symmetric_difference):
 
1284
                for g in (G, I, Ig, L, R):
 
1285
                    expected = meth(data)
 
1286
                    actual = meth(G(data))
 
1287
                    self.assertEqual(sorted(actual), sorted(expected))
 
1288
                self.assertRaises(TypeError, meth, X(s))
 
1289
                self.assertRaises(TypeError, meth, N(s))
 
1290
                self.assertRaises(ZeroDivisionError, meth, E(s))
 
1291
 
 
1292
    def test_inplace_methods(self):
 
1293
        for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
 
1294
            for methname in ('update', 'intersection_update',
 
1295
                             'difference_update', 'symmetric_difference_update'):
 
1296
                for g in (G, I, Ig, S, L, R):
 
1297
                    s = set('january')
 
1298
                    t = s.copy()
 
1299
                    getattr(s, methname)(list(g(data)))
 
1300
                    getattr(t, methname)(g(data))
 
1301
                    self.assertEqual(sorted(s), sorted(t))
 
1302
 
 
1303
                self.assertRaises(TypeError, getattr(set('january'), methname), X(data))
 
1304
                self.assertRaises(TypeError, getattr(set('january'), methname), N(data))
 
1305
                self.assertRaises(ZeroDivisionError, getattr(set('january'), methname), E(data))
 
1306
 
 
1307
#==============================================================================
 
1308
 
 
1309
def test_main(verbose=None):
 
1310
    import sys
 
1311
    from test import test_sets
 
1312
    test_classes = (
 
1313
        TestSet,
 
1314
        TestSetSubclass,
 
1315
        TestFrozenSet,
 
1316
        TestFrozenSetSubclass,
 
1317
        TestSetOfSets,
 
1318
        TestExceptionPropagation,
 
1319
        TestBasicOpsEmpty,
 
1320
        TestBasicOpsSingleton,
 
1321
        TestBasicOpsTuple,
 
1322
        TestBasicOpsTriple,
 
1323
        TestBinaryOps,
 
1324
        TestUpdateOps,
 
1325
        TestMutate,
 
1326
        TestSubsetEqualEmpty,
 
1327
        TestSubsetEqualNonEmpty,
 
1328
        TestSubsetEmptyNonEmpty,
 
1329
        TestSubsetPartial,
 
1330
        TestSubsetNonOverlap,
 
1331
        TestOnlySetsNumeric,
 
1332
        TestOnlySetsDict,
 
1333
        TestOnlySetsOperator,
 
1334
        TestOnlySetsTuple,
 
1335
        TestOnlySetsString,
 
1336
        TestOnlySetsGenerator,
 
1337
        TestCopyingEmpty,
 
1338
        TestCopyingSingleton,
 
1339
        TestCopyingTriple,
 
1340
        TestCopyingTuple,
 
1341
        TestCopyingNested,
 
1342
        TestIdentities,
 
1343
        TestVariousIteratorArgs,
 
1344
        )
 
1345
 
 
1346
    test_support.run_unittest(*test_classes)
 
1347
 
 
1348
    # verify reference counting
 
1349
    if verbose and hasattr(sys, "gettotalrefcount"):
 
1350
        import gc
 
1351
        counts = [None] * 5
 
1352
        for i in xrange(len(counts)):
 
1353
            test_support.run_unittest(*test_classes)
 
1354
            gc.collect()
 
1355
            counts[i] = sys.gettotalrefcount()
 
1356
        print counts
 
1357
 
 
1358
if __name__ == "__main__":
 
1359
    test_main(verbose=True)