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