from test
import test_support
from weakref
import proxy
class PassThru(Exception):
class TestJointOps(unittest
.TestCase
):
# Tests common to both set and frozenset
self
.word
= word
= 'simsalabim'
self
.otherword
= 'madagascar'
self
.letters
= 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
self
.s
= self
.thetype(word
)
self
.d
= dict.fromkeys(word
)
def test_new_or_init(self
):
self
.assertRaises(TypeError, self
.thetype
, [], 2)
def test_uniquification(self
):
expected
= sorted(self
.d
)
self
.assertEqual(actual
, expected
)
self
.assertRaises(PassThru
, self
.thetype
, check_pass_thru())
self
.assertRaises(TypeError, self
.thetype
, [[]])
self
.assertEqual(len(self
.s
), len(self
.d
))
self
.assertEqual(c
in self
.s
, c
in self
.d
)
self
.assertRaises(TypeError, self
.s
.__contains
__, [[]])
s
= self
.thetype([frozenset(self
.letters
)])
self
.assert_(self
.thetype(self
.letters
) in s
)
u
= self
.s
.union(self
.otherword
)
self
.assertEqual(c
in u
, c
in self
.d
or c
in self
.otherword
)
self
.assertEqual(self
.s
, self
.thetype(self
.word
))
self
.assertEqual(type(u
), self
.thetype
)
self
.assertRaises(PassThru
, self
.s
.union
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.union
, [[]])
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
self
.assertEqual(self
.thetype('abcba').union(C('cdc')), set('abcd'))
self
.assertEqual(self
.thetype('abcba').union(C('efgfe')), set('abcefg'))
self
.assertEqual(self
.thetype('abcba').union(C('ccb')), set('abc'))
self
.assertEqual(self
.thetype('abcba').union(C('ef')), set('abcef'))
i
= self
.s
.union(self
.otherword
)
self
.assertEqual(self
.s |
set(self
.otherword
), i
)
self
.assertEqual(self
.s |
frozenset(self
.otherword
), i
)
self
.fail("s|t did not screen-out general iterables")
def test_intersection(self
):
i
= self
.s
.intersection(self
.otherword
)
self
.assertEqual(c
in i
, c
in self
.d
and c
in self
.otherword
)
self
.assertEqual(self
.s
, self
.thetype(self
.word
))
self
.assertEqual(type(i
), self
.thetype
)
self
.assertRaises(PassThru
, self
.s
.intersection
, check_pass_thru())
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
self
.assertEqual(self
.thetype('abcba').intersection(C('cdc')), set('cc'))
self
.assertEqual(self
.thetype('abcba').intersection(C('efgfe')), set(''))
self
.assertEqual(self
.thetype('abcba').intersection(C('ccb')), set('bc'))
self
.assertEqual(self
.thetype('abcba').intersection(C('ef')), set(''))
i
= self
.s
.intersection(self
.otherword
)
self
.assertEqual(self
.s
& set(self
.otherword
), i
)
self
.assertEqual(self
.s
& frozenset(self
.otherword
), i
)
self
.fail("s&t did not screen-out general iterables")
def test_difference(self
):
i
= self
.s
.difference(self
.otherword
)
self
.assertEqual(c
in i
, c
in self
.d
and c
not in self
.otherword
)
self
.assertEqual(self
.s
, self
.thetype(self
.word
))
self
.assertEqual(type(i
), self
.thetype
)
self
.assertRaises(PassThru
, self
.s
.difference
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.difference
, [[]])
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
self
.assertEqual(self
.thetype('abcba').difference(C('cdc')), set('ab'))
self
.assertEqual(self
.thetype('abcba').difference(C('efgfe')), set('abc'))
self
.assertEqual(self
.thetype('abcba').difference(C('ccb')), set('a'))
self
.assertEqual(self
.thetype('abcba').difference(C('ef')), set('abc'))
i
= self
.s
.difference(self
.otherword
)
self
.assertEqual(self
.s
- set(self
.otherword
), i
)
self
.assertEqual(self
.s
- frozenset(self
.otherword
), i
)
self
.fail("s-t did not screen-out general iterables")
def test_symmetric_difference(self
):
i
= self
.s
.symmetric_difference(self
.otherword
)
self
.assertEqual(c
in i
, (c
in self
.d
) ^
(c
in self
.otherword
))
self
.assertEqual(self
.s
, self
.thetype(self
.word
))
self
.assertEqual(type(i
), self
.thetype
)
self
.assertRaises(PassThru
, self
.s
.symmetric_difference
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.symmetric_difference
, [[]])
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
self
.assertEqual(self
.thetype('abcba').symmetric_difference(C('cdc')), set('abd'))
self
.assertEqual(self
.thetype('abcba').symmetric_difference(C('efgfe')), set('abcefg'))
self
.assertEqual(self
.thetype('abcba').symmetric_difference(C('ccb')), set('a'))
self
.assertEqual(self
.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))
i
= self
.s
.symmetric_difference(self
.otherword
)
self
.assertEqual(self
.s ^
set(self
.otherword
), i
)
self
.assertEqual(self
.s ^
frozenset(self
.otherword
), i
)
self
.fail("s^t did not screen-out general iterables")
self
.assertEqual(self
.s
, set(self
.word
))
self
.assertEqual(self
.s
, frozenset(self
.word
))
self
.assertEqual(self
.s
== self
.word
, False)
self
.assertNotEqual(self
.s
, set(self
.otherword
))
self
.assertNotEqual(self
.s
, frozenset(self
.otherword
))
self
.assertEqual(self
.s
!= self
.word
, True)
def test_setOfFrozensets(self
):
t
= map(frozenset, ['abcdef', 'bcd', 'bdcb', 'fed', 'fedccba'])
self
.assertEqual(len(s
), 3)
self
.assertRaises(TypeError, self
.s
.__cmp
__, self
.s
)
def test_sub_and_super(self
):
p
, q
, r
= map(self
.thetype
, ['ab', 'abcde', 'def'])
self
.assert_(set('a').issubset('abc'))
self
.assert_(set('abc').issuperset('a'))
self
.failIf(set('a').issubset('cbs'))
self
.failIf(set('cbs').issuperset('a'))
p
= pickle
.dumps(self
.s
, i
)
self
.assertEqual(self
.s
, dup
, "%s != %s" % (self
.s
, dup
))
if type(self
.s
) not in (set, frozenset):
self
.assertEqual(self
.s
.x
, dup
.x
)
def __init__(self
, value
):
def __deepcopy__(self
, memo
=None):
return Tracer(self
.value
+ 1)
self
.assertNotEqual(id(s
), id(dup
))
self
.assertNotEqual(id(t
), id(newt
))
self
.assertEqual(t
.value
+ 1, newt
.value
)
# Create a nest of cycles to exercise overall ref count check
s
= set(A() for i
in xrange(1000))
def test_subclass_with_custom_hash(self
):
class TestSet(TestJointOps
):
self
.assertEqual(s
, set(self
.word
))
s
.__init
__(self
.otherword
)
self
.assertEqual(s
, set(self
.otherword
))
self
.assertRaises(TypeError, s
.__init
__, s
, 2);
self
.assertRaises(TypeError, s
.__init
__, 1);
def test_constructor_identity(self
):
s
= self
.thetype(range(3))
self
.assertNotEqual(id(s
), id(t
))
self
.assertRaises(TypeError, hash, self
.s
)
self
.assertEqual(self
.s
, set())
self
.assertEqual(len(self
.s
), 0)
self
.assertEqual(self
.s
, dup
)
self
.assertNotEqual(id(self
.s
), id(dup
))
self
.assert_('Q' in self
.s
)
self
.assertEqual(self
.s
, dup
)
self
.assertRaises(TypeError, self
.s
.add
, [])
self
.assert_('a' not in self
.s
)
self
.assertRaises(KeyError, self
.s
.remove
, 'Q')
self
.assertRaises(TypeError, self
.s
.remove
, [])
s
= self
.thetype([frozenset(self
.word
)])
self
.assert_(self
.thetype(self
.word
) in s
)
s
.remove(self
.thetype(self
.word
))
self
.assert_(self
.thetype(self
.word
) not in s
)
self
.assertRaises(KeyError, self
.s
.remove
, self
.thetype(self
.word
))
self
.assert_('a' not in self
.s
)
self
.assertRaises(TypeError, self
.s
.discard
, [])
s
= self
.thetype([frozenset(self
.word
)])
self
.assert_(self
.thetype(self
.word
) in s
)
s
.discard(self
.thetype(self
.word
))
self
.assert_(self
.thetype(self
.word
) not in s
)
s
.discard(self
.thetype(self
.word
))
for i
in xrange(len(self
.s
)):
self
.assert_(elem
not in self
.s
)
self
.assertRaises(KeyError, self
.s
.pop
)
retval
= self
.s
.update(self
.otherword
)
self
.assertEqual(retval
, None)
for c
in (self
.word
+ self
.otherword
):
self
.assert_(c
in self
.s
)
self
.assertRaises(PassThru
, self
.s
.update
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.update
, [[]])
for p
, q
in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
s
= self
.thetype('abcba')
self
.assertEqual(s
.update(C(p
)), None)
self
.assertEqual(s
, set(q
))
self
.s |
= set(self
.otherword
)
for c
in (self
.word
+ self
.otherword
):
self
.assert_(c
in self
.s
)
def test_intersection_update(self
):
retval
= self
.s
.intersection_update(self
.otherword
)
self
.assertEqual(retval
, None)
for c
in (self
.word
+ self
.otherword
):
if c
in self
.otherword
and c
in self
.word
:
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
self
.assertRaises(PassThru
, self
.s
.intersection_update
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.intersection_update
, [[]])
for p
, q
in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
s
= self
.thetype('abcba')
self
.assertEqual(s
.intersection_update(C(p
)), None)
self
.assertEqual(s
, set(q
))
self
.s
&= set(self
.otherword
)
for c
in (self
.word
+ self
.otherword
):
if c
in self
.otherword
and c
in self
.word
:
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
def test_difference_update(self
):
retval
= self
.s
.difference_update(self
.otherword
)
self
.assertEqual(retval
, None)
for c
in (self
.word
+ self
.otherword
):
if c
in self
.word
and c
not in self
.otherword
:
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
self
.assertRaises(PassThru
, self
.s
.difference_update
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.difference_update
, [[]])
self
.assertRaises(TypeError, self
.s
.symmetric_difference_update
, [[]])
for p
, q
in (('cdc', 'ab'), ('efgfe', 'abc'), ('ccb', 'a'), ('ef', 'abc')):
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
s
= self
.thetype('abcba')
self
.assertEqual(s
.difference_update(C(p
)), None)
self
.assertEqual(s
, set(q
))
self
.s
-= set(self
.otherword
)
for c
in (self
.word
+ self
.otherword
):
if c
in self
.word
and c
not in self
.otherword
:
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
def test_symmetric_difference_update(self
):
retval
= self
.s
.symmetric_difference_update(self
.otherword
)
self
.assertEqual(retval
, None)
for c
in (self
.word
+ self
.otherword
):
if (c
in self
.word
) ^
(c
in self
.otherword
):
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
self
.assertRaises(PassThru
, self
.s
.symmetric_difference_update
, check_pass_thru())
self
.assertRaises(TypeError, self
.s
.symmetric_difference_update
, [[]])
for p
, q
in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):
for C
in set, frozenset, dict.fromkeys
, str, unicode, list, tuple:
s
= self
.thetype('abcba')
self
.assertEqual(s
.symmetric_difference_update(C(p
)), None)
self
.assertEqual(s
, set(q
))
self
.s ^
= set(self
.otherword
)
for c
in (self
.word
+ self
.otherword
):
if (c
in self
.word
) ^
(c
in self
.otherword
):
self
.assert_(c
in self
.s
)
self
.assert_(c
not in self
.s
)
def test_inplace_on_self(self
):
self
.assertEqual(t
, self
.s
)
self
.assertEqual(t
, self
.s
)
self
.assertEqual(t
, self
.thetype())
self
.assertEqual(t
, self
.thetype())
s
= self
.thetype('gallahad')
self
.assertEqual(str(p
), str(s
))
self
.assertRaises(ReferenceError, str, p
)
class TestSetSubclass(TestSet
):
class TestFrozenSet(TestJointOps
):
s
= self
.thetype(self
.word
)
s
.__init
__(self
.otherword
)
self
.assertEqual(s
, set(self
.word
))
def test_constructor_identity(self
):
s
= self
.thetype(range(3))
self
.assertEqual(id(s
), id(t
))
self
.assertEqual(hash(self
.thetype('abcdeb')),
hash(self
.thetype('ebecda')))
self
.assertEqual(id(self
.s
), id(dup
))
def test_frozen_as_dictkey(self
):
seq
= range(10) + list('abcdefg') + ['apple']
key2
= self
.thetype(reversed(seq
))
self
.assertEqual(key1
, key2
)
self
.assertNotEqual(id(key1
), id(key2
))
self
.assertEqual(d
[key2
], 42)
def test_hash_caching(self
):
f
= self
.thetype('abcdcda')
self
.assertEqual(hash(f
), hash(f
))
def test_hash_effectiveness(self
):
addhashvalue
= hashvalues
.add
elemmasks
= [(i
+1, 1<<i
) for i
in range(n
)]
addhashvalue(hash(frozenset([e
for e
, m
in elemmasks
if m
&i
])))
self
.assertEqual(len(hashvalues
), 2**n
)
class FrozenSetSubclass(frozenset):
class TestFrozenSetSubclass(TestFrozenSet
):
thetype
= FrozenSetSubclass
def test_constructor_identity(self
):
s
= self
.thetype(range(3))
self
.assertNotEqual(id(s
), id(t
))
self
.assertNotEqual(id(self
.s
), id(dup
))
def test_nested_empty_constructor(self
):
# Tests taken from test_sets.py =============================================
#==============================================================================
class TestBasicOps(unittest
.TestCase
):
if self
.repr is not None:
self
.assertEqual(repr(self
.set), self
.repr)
fo
= open(test_support
.TESTFN
, "wb")
fo
= open(test_support
.TESTFN
, "rb")
self
.assertEqual(fo
.read(), repr(self
.set))
os
.remove(test_support
.TESTFN
)
self
.assertEqual(len(self
.set), self
.length
)
def test_self_equality(self
):
self
.assertEqual(self
.set, self
.set)
def test_equivalent_equality(self
):
self
.assertEqual(self
.set, self
.dup
)
self
.assertEqual(self
.set.copy(), self
.dup
)
def test_self_union(self
):
result
= self
.set | self
.set
self
.assertEqual(result
, self
.dup
)
def test_empty_union(self
):
result
= self
.set | empty_set
self
.assertEqual(result
, self
.dup
)
def test_union_empty(self
):
result
= empty_set | self
.set
self
.assertEqual(result
, self
.dup
)
def test_self_intersection(self
):
result
= self
.set & self
.set
self
.assertEqual(result
, self
.dup
)
def test_empty_intersection(self
):
result
= self
.set & empty_set
self
.assertEqual(result
, empty_set
)
def test_intersection_empty(self
):
result
= empty_set
& self
.set
self
.assertEqual(result
, empty_set
)
def test_self_symmetric_difference(self
):
result
= self
.set ^ self
.set
self
.assertEqual(result
, empty_set
)
def checkempty_symmetric_difference(self
):
result
= self
.set ^ empty_set
self
.assertEqual(result
, self
.set)
def test_self_difference(self
):
result
= self
.set - self
.set
self
.assertEqual(result
, empty_set
)
def test_empty_difference(self
):
result
= self
.set - empty_set
self
.assertEqual(result
, self
.dup
)
def test_empty_difference_rev(self
):
result
= empty_set
- self
.set
self
.assertEqual(result
, empty_set
)
def test_iteration(self
):
self
.assert_(v
in self
.values
)
p
= pickle
.dumps(self
.set)
self
.assertEqual(self
.set, copy
,
"%s != %s" % (self
.set, copy
))
#------------------------------------------------------------------------------
class TestBasicOpsEmpty(TestBasicOps
):
self
.set = set(self
.values
)
self
.dup
= set(self
.values
)
#------------------------------------------------------------------------------
class TestBasicOpsSingleton(TestBasicOps
):
self
.case
= "unit set (number)"
self
.set = set(self
.values
)
self
.dup
= set(self
.values
)
self
.failUnless(3 in self
.set)
self
.failUnless(2 not in self
.set)
#------------------------------------------------------------------------------
class TestBasicOpsTuple(TestBasicOps
):
self
.case
= "unit set (tuple)"
self
.values
= [(0, "zero")]
self
.set = set(self
.values
)
self
.dup
= set(self
.values
)
self
.repr = "set([(0, 'zero')])"
self
.failUnless((0, "zero") in self
.set)
self
.failUnless(9 not in self
.set)
#------------------------------------------------------------------------------
class TestBasicOpsTriple(TestBasicOps
):
self
.values
= [0, "zero", operator
.add
]
self
.set = set(self
.values
)
self
.dup
= set(self
.values
)
#==============================================================================
class TestExceptionPropagation(unittest
.TestCase
):
"""SF 628246: Set constructor should not trap iterator TypeErrors"""
def test_instanceWithException(self
):
self
.assertRaises(TypeError, set, baditer())
def test_instancesWithoutException(self
):
# All of these iterables should load without exception.
set({'one':1, 'two':2, 'three':3})
#==============================================================================
class TestSetOfSets(unittest
.TestCase
):
def test_constructor(self
):
self
.assertEqual(type(element
), frozenset)
outer
.add(inner
) # Rebuild set of sets with .add method
self
.assertEqual(outer
, set()) # Verify that remove worked
outer
.discard(inner
) # Absence of KeyError indicates working fine
#==============================================================================
class TestBinaryOps(unittest
.TestCase
):
self
.set = set((2, 4, 6))
def test_eq(self
): # SF bug 643115
self
.assertEqual(self
.set, set({2:1,4:3,6:5}))
def test_union_subset(self
):
result
= self
.set |
set([2])
self
.assertEqual(result
, set((2, 4, 6)))
def test_union_superset(self
):
result
= self
.set |
set([2, 4, 6, 8])
self
.assertEqual(result
, set([2, 4, 6, 8]))
def test_union_overlap(self
):
result
= self
.set |
set([3, 4, 5])
self
.assertEqual(result
, set([2, 3, 4, 5, 6]))
def test_union_non_overlap(self
):
result
= self
.set |
set([8])
self
.assertEqual(result
, set([2, 4, 6, 8]))
def test_intersection_subset(self
):
result
= self
.set & set((2, 4))
self
.assertEqual(result
, set((2, 4)))
def test_intersection_superset(self
):
result
= self
.set & set([2, 4, 6, 8])
self
.assertEqual(result
, set([2, 4, 6]))
def test_intersection_overlap(self
):
result
= self
.set & set([3, 4, 5])
self
.assertEqual(result
, set([4]))
def test_intersection_non_overlap(self
):
result
= self
.set & set([8])
self
.assertEqual(result
, empty_set
)
def test_sym_difference_subset(self
):
result
= self
.set ^
set((2, 4))
self
.assertEqual(result
, set([6]))
def test_sym_difference_superset(self
):
result
= self
.set ^
set((2, 4, 6, 8))
self
.assertEqual(result
, set([8]))
def test_sym_difference_overlap(self
):
result
= self
.set ^
set((3, 4, 5))
self
.assertEqual(result
, set([2, 3, 5, 6]))
def test_sym_difference_non_overlap(self
):
result
= self
.set ^
set([8])
self
.assertEqual(result
, set([2, 4, 6, 8]))
a
, b
= set('a'), set('b')
self
.assertRaises(TypeError, cmp, a
, b
)
# You can view this as a buglet: cmp(a, a) does not raise TypeError,
# because __eq__ is tried before __cmp__, and a.__eq__(a) returns True,
# which Python thinks is good enough to synthesize a cmp() result
# without calling __cmp__.
self
.assertEqual(cmp(a
, a
), 0)
self
.assertRaises(TypeError, cmp, a
, 12)
self
.assertRaises(TypeError, cmp, "abc", a
)
#==============================================================================
class TestUpdateOps(unittest
.TestCase
):
self
.set = set((2, 4, 6))
def test_union_subset(self
):
self
.assertEqual(self
.set, set((2, 4, 6)))
def test_union_superset(self
):
self
.set |
= set([2, 4, 6, 8])
self
.assertEqual(self
.set, set([2, 4, 6, 8]))
def test_union_overlap(self
):
self
.set |
= set([3, 4, 5])
self
.assertEqual(self
.set, set([2, 3, 4, 5, 6]))
def test_union_non_overlap(self
):
self
.assertEqual(self
.set, set([2, 4, 6, 8]))
def test_union_method_call(self
):
self
.set.update(set([3, 4, 5]))
self
.assertEqual(self
.set, set([2, 3, 4, 5, 6]))
def test_intersection_subset(self
):
self
.assertEqual(self
.set, set((2, 4)))
def test_intersection_superset(self
):
self
.set &= set([2, 4, 6, 8])
self
.assertEqual(self
.set, set([2, 4, 6]))
def test_intersection_overlap(self
):
self
.set &= set([3, 4, 5])
self
.assertEqual(self
.set, set([4]))
def test_intersection_non_overlap(self
):
self
.assertEqual(self
.set, empty_set
)
def test_intersection_method_call(self
):
self
.set.intersection_update(set([3, 4, 5]))
self
.assertEqual(self
.set, set([4]))
def test_sym_difference_subset(self
):
self
.assertEqual(self
.set, set([6]))
def test_sym_difference_superset(self
):
self
.set ^
= set((2, 4, 6, 8))
self
.assertEqual(self
.set, set([8]))
def test_sym_difference_overlap(self
):
self
.set ^
= set((3, 4, 5))
self
.assertEqual(self
.set, set([2, 3, 5, 6]))
def test_sym_difference_non_overlap(self
):
self
.assertEqual(self
.set, set([2, 4, 6, 8]))
def test_sym_difference_method_call(self
):
self
.set.symmetric_difference_update(set([3, 4, 5]))
self
.assertEqual(self
.set, set([2, 3, 5, 6]))
def test_difference_subset(self
):
self
.assertEqual(self
.set, set([6]))
def test_difference_superset(self
):
self
.set -= set((2, 4, 6, 8))
self
.assertEqual(self
.set, set([]))
def test_difference_overlap(self
):
self
.set -= set((3, 4, 5))
self
.assertEqual(self
.set, set([2, 6]))
def test_difference_non_overlap(self
):
self
.assertEqual(self
.set, set([2, 4, 6]))
def test_difference_method_call(self
):
self
.set.difference_update(set([3, 4, 5]))
self
.assertEqual(self
.set, set([2, 6]))
#==============================================================================
class TestMutate(unittest
.TestCase
):
self
.values
= ["a", "b", "c"]
self
.set = set(self
.values
)
def test_add_present(self
):
self
.assertEqual(self
.set, set("abc"))
def test_add_absent(self
):
self
.assertEqual(self
.set, set("abcd"))
def test_add_until_full(self
):
self
.assertEqual(len(tmp
), expected_len
)
self
.assertEqual(tmp
, self
.set)
def test_remove_present(self
):
self
.assertEqual(self
.set, set("ac"))
def test_remove_absent(self
):
self
.fail("Removing missing element should have raised LookupError")
def test_remove_until_empty(self
):
expected_len
= len(self
.set)
self
.assertEqual(len(self
.set), expected_len
)
def test_discard_present(self
):
self
.assertEqual(self
.set, set("ab"))
def test_discard_absent(self
):
self
.assertEqual(self
.set, set("abc"))
self
.assertEqual(len(self
.set), 0)
popped
[self
.set.pop()] = None
self
.assertEqual(len(popped
), len(self
.values
))
self
.failUnless(v
in popped
)
def test_update_empty_tuple(self
):
self
.assertEqual(self
.set, set(self
.values
))
def test_update_unit_tuple_overlap(self
):
self
.assertEqual(self
.set, set(self
.values
))
def test_update_unit_tuple_non_overlap(self
):
self
.set.update(("a", "z"))
self
.assertEqual(self
.set, set(self
.values
+ ["z"]))
#==============================================================================
class TestSubsets(unittest
.TestCase
):
case2method
= {"<=": "issubset",
for case
in "!=", "==", "<", "<=", ">", ">=":
expected
= case
in self
.cases
# Test the binary infix spelling.
result
= eval("x" + case
+ "y", locals())
self
.assertEqual(result
, expected
)
# Test the "friendly" method-name spelling, if one exists.
if case
in TestSubsets
.case2method
:
method
= getattr(x
, TestSubsets
.case2method
[case
])
self
.assertEqual(result
, expected
)
# Now do the same for the operands reversed.
rcase
= TestSubsets
.reverse
[case
]
result
= eval("y" + rcase
+ "x", locals())
self
.assertEqual(result
, expected
)
if rcase
in TestSubsets
.case2method
:
method
= getattr(y
, TestSubsets
.case2method
[rcase
])
self
.assertEqual(result
, expected
)
#------------------------------------------------------------------------------
class TestSubsetEqualEmpty(TestSubsets
):
#------------------------------------------------------------------------------
class TestSubsetEqualNonEmpty(TestSubsets
):
#------------------------------------------------------------------------------
class TestSubsetEmptyNonEmpty(TestSubsets
):
name
= "one empty, one non-empty"
#------------------------------------------------------------------------------
class TestSubsetPartial(TestSubsets
):
name
= "one a non-empty proper subset of other"
#------------------------------------------------------------------------------
class TestSubsetNonOverlap(TestSubsets
):
name
= "neither empty, neither contains"
#==============================================================================
class TestOnlySetsInBinaryOps(unittest
.TestCase
):
# Unlike the others, this is testing that == and != *are* allowed.
self
.assertEqual(self
.other
== self
.set, False)
self
.assertEqual(self
.set == self
.other
, False)
self
.assertEqual(self
.other
!= self
.set, True)
self
.assertEqual(self
.set != self
.other
, True)
def test_ge_gt_le_lt(self
):
self
.assertRaises(TypeError, lambda: self
.set < self
.other
)
self
.assertRaises(TypeError, lambda: self
.set <= self
.other
)
self
.assertRaises(TypeError, lambda: self
.set > self
.other
)
self
.assertRaises(TypeError, lambda: self
.set >= self
.other
)
self
.assertRaises(TypeError, lambda: self
.other
< self
.set)
self
.assertRaises(TypeError, lambda: self
.other
<= self
.set)
self
.assertRaises(TypeError, lambda: self
.other
> self
.set)
self
.assertRaises(TypeError, lambda: self
.other
>= self
.set)
def test_update_operator(self
):
self
.fail("expected TypeError")
self
.set.update(self
.other
)
self
.assertRaises(TypeError, self
.set.update
, self
.other
)
self
.assertRaises(TypeError, lambda: self
.set | self
.other
)
self
.assertRaises(TypeError, lambda: self
.other | self
.set)
self
.set.union(self
.other
)
self
.assertRaises(TypeError, self
.set.union
, self
.other
)
def test_intersection_update_operator(self
):
self
.fail("expected TypeError")
def test_intersection_update(self
):
self
.set.intersection_update(self
.other
)
self
.assertRaises(TypeError,
self
.set.intersection_update
,
def test_intersection(self
):
self
.assertRaises(TypeError, lambda: self
.set & self
.other
)
self
.assertRaises(TypeError, lambda: self
.other
& self
.set)
self
.set.intersection(self
.other
)
self
.assertRaises(TypeError, self
.set.intersection
, self
.other
)
def test_sym_difference_update_operator(self
):
self
.fail("expected TypeError")
def test_sym_difference_update(self
):
self
.set.symmetric_difference_update(self
.other
)
self
.assertRaises(TypeError,
self
.set.symmetric_difference_update
,
def test_sym_difference(self
):
self
.assertRaises(TypeError, lambda: self
.set ^ self
.other
)
self
.assertRaises(TypeError, lambda: self
.other ^ self
.set)
self
.set.symmetric_difference(self
.other
)
self
.assertRaises(TypeError, self
.set.symmetric_difference
, self
.other
)
def test_difference_update_operator(self
):
self
.fail("expected TypeError")
def test_difference_update(self
):
self
.set.difference_update(self
.other
)
self
.assertRaises(TypeError,
self
.set.difference_update
,
def test_difference(self
):
self
.assertRaises(TypeError, lambda: self
.set - self
.other
)
self
.assertRaises(TypeError, lambda: self
.other
- self
.set)
self
.set.difference(self
.other
)
self
.assertRaises(TypeError, self
.set.difference
, self
.other
)
#------------------------------------------------------------------------------
class TestOnlySetsNumeric(TestOnlySetsInBinaryOps
):
self
.set = set((1, 2, 3))
self
.otherIsIterable
= False
#------------------------------------------------------------------------------
class TestOnlySetsDict(TestOnlySetsInBinaryOps
):
self
.set = set((1, 2, 3))
self
.otherIsIterable
= True
#------------------------------------------------------------------------------
class TestOnlySetsOperator(TestOnlySetsInBinaryOps
):
self
.set = set((1, 2, 3))
self
.other
= operator
.add
self
.otherIsIterable
= False
#------------------------------------------------------------------------------
class TestOnlySetsTuple(TestOnlySetsInBinaryOps
):
self
.set = set((1, 2, 3))
self
.otherIsIterable
= True
#------------------------------------------------------------------------------
class TestOnlySetsString(TestOnlySetsInBinaryOps
):
self
.set = set((1, 2, 3))
self
.otherIsIterable
= True
#------------------------------------------------------------------------------
class TestOnlySetsGenerator(TestOnlySetsInBinaryOps
):
for i
in xrange(0, 10, 2):
self
.set = set((1, 2, 3))
self
.otherIsIterable
= True
#==============================================================================
class TestCopying(unittest
.TestCase
):
dup_list
= list(dup
); dup_list
.sort()
set_list
= list(self
.set); set_list
.sort()
self
.assertEqual(len(dup_list
), len(set_list
))
for i
in range(len(dup_list
)):
self
.failUnless(dup_list
[i
] is set_list
[i
])
def test_deep_copy(self
):
dup
= copy
.deepcopy(self
.set)
##print type(dup), repr(dup)
dup_list
= list(dup
); dup_list
.sort()
set_list
= list(self
.set); set_list
.sort()
self
.assertEqual(len(dup_list
), len(set_list
))
for i
in range(len(dup_list
)):
self
.assertEqual(dup_list
[i
], set_list
[i
])
#------------------------------------------------------------------------------
class TestCopyingEmpty(TestCopying
):
#------------------------------------------------------------------------------
class TestCopyingSingleton(TestCopying
):
self
.set = set(["hello"])
#------------------------------------------------------------------------------
class TestCopyingTriple(TestCopying
):
self
.set = set(["zero", 0, None])
#------------------------------------------------------------------------------
class TestCopyingTuple(TestCopying
):
#------------------------------------------------------------------------------
class TestCopyingNested(TestCopying
):
self
.set = set([((1, 2), (3, 4))])
#==============================================================================
class TestIdentities(unittest
.TestCase
):
self
.a
= set('abracadabra')
def test_binopsVsSubsets(self
):
self
.assert_(a ^ b
< a | b
)
def test_commutativity(self
):
self
.assertEqual(a
&b
, b
&a
)
self
.assertEqual(a|b
, b|a
)
self
.assertEqual(a^b
, b^a
)
self
.assertNotEqual(a
-b
, b
-a
)
def test_summations(self
):
# check that sums of parts equal the whole
self
.assertEqual((a
-b
)|
(a
&b
)|
(b
-a
), a|b
)
self
.assertEqual((a
&b
)|
(a^b
), a|b
)
self
.assertEqual(a|
(b
-a
), a|b
)
self
.assertEqual((a
-b
)|b
, a|b
)
self
.assertEqual((a
-b
)|
(a
&b
), a
)
self
.assertEqual((b
-a
)|
(a
&b
), b
)
self
.assertEqual((a
-b
)|
(b
-a
), a^b
)
def test_exclusion(self
):
# check that inverse operations show non-overlap
a
, b
, zero
= self
.a
, self
.b
, set()
self
.assertEqual((a
-b
)&b
, zero
)
self
.assertEqual((b
-a
)&a
, zero
)
self
.assertEqual((a
&b
)&(a^b
), zero
)
# Tests derived from test_itertools.py =======================================
'Sequence using __getitem__'
def __init__(self
, seqn
):
def __getitem__(self
, i
):
'Sequence using iterator protocol'
def __init__(self
, seqn
):
if self
.i
>= len(self
.seqn
): raise StopIteration
'Sequence using iterator protocol defined with a generator'
def __init__(self
, seqn
):
'Missing __getitem__ and __iter__'
def __init__(self
, seqn
):
if self
.i
>= len(self
.seqn
): raise StopIteration
'Iterator missing next()'
def __init__(self
, seqn
):
'Test propagation of exceptions'
def __init__(self
, seqn
):
def __init__(self
, seqn
):
from itertools
import chain
, imap
'Test multiple tiers of iterators'
return chain(imap(lambda x
:x
, R(Ig(G(seqn
)))))
class TestVariousIteratorArgs(unittest
.TestCase
):
def test_constructor(self
):
for cons
in (set, frozenset):
for s
in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
for g
in (G
, I
, Ig
, S
, L
, R
):
self
.assertEqual(sorted(cons(g(s
))), sorted(g(s
)))
self
.assertRaises(TypeError, cons
, X(s
))
self
.assertRaises(TypeError, cons
, N(s
))
self
.assertRaises(ZeroDivisionError, cons
, E(s
))
def test_inline_methods(self
):
for data
in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
for meth
in (s
.union
, s
.intersection
, s
.difference
, s
.symmetric_difference
):
for g
in (G
, I
, Ig
, L
, R
):
self
.assertEqual(sorted(actual
), sorted(expected
))
self
.assertRaises(TypeError, meth
, X(s
))
self
.assertRaises(TypeError, meth
, N(s
))
self
.assertRaises(ZeroDivisionError, meth
, E(s
))
def test_inplace_methods(self
):
for data
in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
for methname
in ('update', 'intersection_update',
'difference_update', 'symmetric_difference_update'):
for g
in (G
, I
, Ig
, S
, L
, R
):
getattr(s
, methname
)(list(g(data
)))
getattr(t
, methname
)(g(data
))
self
.assertEqual(sorted(s
), sorted(t
))
self
.assertRaises(TypeError, getattr(set('january'), methname
), X(data
))
self
.assertRaises(TypeError, getattr(set('january'), methname
), N(data
))
self
.assertRaises(ZeroDivisionError, getattr(set('january'), methname
), E(data
))
#==============================================================================
def test_main(verbose
=None):
from test
import test_sets
TestExceptionPropagation
,
test_support
.run_unittest(*test_classes
)
# verify reference counting
if verbose
and hasattr(sys
, "gettotalrefcount"):
for i
in xrange(len(counts
)):
test_support
.run_unittest(*test_classes
)
counts
[i
] = sys
.gettotalrefcount()
if __name__
== "__main__":