def test_values(self): d = CuteSleekValueDict(null_callback) self.assertEqual(list(d.values()), []) d = CuteSleekValueDict(null_callback, {1: 2}) self.assertEqual(list(d.values()), [2]) self.assertRaises(TypeError, d.values, None)
def test_none(): '''Test that `CuteSleekValueDict` can handle a value of `None`.''' d = { 1: None, 2: None, (1,): None, (1, (1,)): None, sum: None, None: None } csvd = CuteSleekValueDict( counter, d ) assert sequence_tools.are_equal_regardless_of_order(csvd.keys(), d.keys()) assert sequence_tools.are_equal_regardless_of_order(csvd.values(), d.values()) assert sequence_tools.are_equal_regardless_of_order(csvd.items(), d.items()) for key in csvd.iterkeys(): assert key in csvd assert csvd[key] is None
def test_popitem(self): if sys_tools.is_pypy: raise nose.SkipTest("Pypy doesn't maintain dict order.") for copymode in -1, +1: # -1: b has same structure as a # +1: b is a.copy() for log2size in range(12): size = 2**log2size a = CuteSleekValueDict(null_callback) b = CuteSleekValueDict(null_callback) for i in range(size): a[repr(i)] = i if copymode < 0: b[repr(i)] = i if copymode > 0: b = a.copy() for i in range(size): ka, va = ta = a.popitem() self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) if copymode < 0: self.assertEqual(ta, tb) self.assertFalse(a) self.assertFalse(b) d = CuteSleekValueDict(null_callback) self.assertRaises(KeyError, d.popitem)
def test_setdefault(self): d = CuteSleekValueDict(null_callback) self.assertIs(d.setdefault('key0'), None) d.setdefault('key0', []) self.assertIs(d.setdefault('key0'), None) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) self.assertEqual(len(d['key']), 2) self.assertRaises(TypeError, d.setdefault) class Exc(Exception): pass class BadHash(object): fail = False def __hash__(self): if self.fail: raise Exc() else: return 42 x = BadHash() d[x] = 42 x.fail = True self.assertRaises(Exc, d.setdefault, x, [])
def test_one_by_one(): volatile_things = [A(), 1, 4.5, 'meow', b'woof', [1, 2], (1, 2), {1: 2}, {1, 2, 3}] unvolatile_things = [__builtins__, list, type, sum] # Using len(csvd) as our key; just to guarantee we're not running over an # existing key. while volatile_things: volatile_thing = volatile_things.pop() csvd = CuteSleekValueDict(counter) if _is_weakreffable(volatile_thing): csvd[len(csvd)] = volatile_thing count = counter() del volatile_thing gc_tools.collect() assert counter() == count + 2 else: csvd[len(csvd)] = volatile_thing count = counter() del volatile_thing gc_tools.collect() assert counter() == count + 1 while unvolatile_things: unvolatile_thing = unvolatile_things.pop() csvd = CuteSleekValueDict(counter) csvd[len(csvd)] = unvolatile_thing count = counter() del unvolatile_thing gc_tools.collect() assert counter() == count + 1
def test_items(self): d = CuteSleekValueDict(null_callback) self.assertEqual(d.items(), []) d = CuteSleekValueDict(null_callback, {1: 2}) self.assertEqual(d.items(), [(1, 2)]) self.assertRaises(TypeError, d.items, None)
def test_keys(self): d = CuteSleekValueDict(null_callback) self.assertEqual(d.keys(), []) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) k = d.keys() self.assertTrue(d.has_key('a')) self.assertTrue(d.has_key('b')) self.assertRaises(TypeError, d.keys, None)
def test_has_key(self): d = CuteSleekValueDict(null_callback) self.assertFalse('a' in d) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) k = list(d.keys()) k.sort() self.assertEqual(k, ['a', 'b']) self.assertRaises(TypeError, d.has_key)
def test_keys(self): d = CuteSleekValueDict(null_callback) self.assertEqual(list(d.keys()), []) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) k = list(d.keys()) self.assertTrue('a' in d) self.assertTrue('b' in d) self.assertRaises(TypeError, d.keys, None)
def test_constructor(self): # calling built-in types without argument must return empty self.assertEqual( CuteSleekValueDict(null_callback), CuteSleekValueDict(null_callback) ) self.assertIsNot( CuteSleekValueDict(null_callback), CuteSleekValueDict(null_callback) )
def test_empty_presized_dict_in_freelist(self): # Bug #3537: if an empty but presized dict with a size larger # than 7 was in the freelist, it triggered an assertion failure with self.assertRaises(ZeroDivisionError): d = CuteSleekValueDict( null_callback, {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None, 'f': None, 'g': None, 'h': None} ) d = CuteSleekValueDict(null_callback)
def test_get(self): d = CuteSleekValueDict(null_callback) self.assertIs(d.get('c'), None) self.assertEqual(d.get('c', 3), 3) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) self.assertIs(d.get('c'), None) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) self.assertRaises(TypeError, d.get) self.assertRaises(TypeError, d.get, None, None, None)
def test_contains(self): d = CuteSleekValueDict(null_callback) self.assertNotIn('a', d) self.assertFalse('a' in d) self.assertTrue('a' not in d) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) self.assertIn('a', d) self.assertIn('b', d) self.assertNotIn('c', d) self.assertRaises(TypeError, d.__contains__)
def test_copy(self): d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) self.assertEqual( d.copy(), CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) ) self.assertEqual( CuteSleekValueDict(null_callback).copy(), CuteSleekValueDict(null_callback) ) self.assertRaises(TypeError, d.copy, None)
def test_bool(self): self.assertIs( not CuteSleekValueDict(null_callback), True ) self.assertTrue(CuteSleekValueDict(null_callback, {1: 2})) self.assertIs(bool(CuteSleekValueDict(null_callback)), False) self.assertIs( bool(CuteSleekValueDict(null_callback, {1: 2})), True )
def test_bad_key(self): # Dictionary lookups should fail if __cmp__() raises an exception. class CustomException(Exception): pass class BadDictKey: def __hash__(self): return hash(self.__class__) def __cmp__(self, other): if isinstance(other, self.__class__): raise CustomException return other d = CuteSleekValueDict(null_callback) x1 = BadDictKey() x2 = BadDictKey() d[x1] = 1 locals()['CuteSleekValueDict'] = CuteSleekValueDict locals()['null_callback'] = null_callback for stmt in [ 'd[x2] = 2', 'z = d[x2]', 'x2 in d', 'd.has_key(x2)', 'd.get(x2)', 'd.setdefault(x2, 42)', 'd.pop(x2)', 'd.update(CuteSleekValueDict(null_callback, {x2: 2}))' ]: with self.assertRaises(CustomException): exec stmt in locals()
def test_mutatingiteration(self): # changing dict size during iteration d = CuteSleekValueDict(null_callback) d[1] = 1 with self.assertRaises(RuntimeError): for i in d: d[i + 1] = 1
def test_missing(self): # Make sure dict doesn't have a __missing__ method self.assertFalse(hasattr(CuteSleekValueDict, "__missing__")) self.assertFalse( hasattr(CuteSleekValueDict(null_callback), "__missing__")) # Test several cases: # (D) subclass defines __missing__ method returning a value # (E) subclass defines __missing__ method raising RuntimeError # (F) subclass sets __missing__ instance variable (no effect) # (G) subclass doesn't define __missing__ at a all class D(CuteSleekValueDict): def __missing__(self, key): return 42 d = D(null_callback, CuteSleekValueDict(null_callback, {1: 2, 3: 4})) self.assertEqual(d[1], 2) self.assertEqual(d[3], 4) self.assertNotIn(2, d) self.assertNotIn(2, d.keys()) self.assertEqual(d[2], 42) class E(CuteSleekValueDict): def __missing__(self, key): raise RuntimeError(key) e = E(null_callback) with self.assertRaises(RuntimeError) as c: e[42] self.assertEqual(c.exception.args, (42, )) class F(dict): def __init__(self): # An instance variable __missing__ should have no effect self.__missing__ = lambda key: None f = F() with self.assertRaises(KeyError) as c: f[42] #self.assertEqual(c.exception.args, (42,)) class G(dict): pass g = G() with self.assertRaises(KeyError) as c: g[42]
class SimpleUserDict: def __init__(self): self.d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) def keys(self): return self.d.keys() def __getitem__(self, i): return self.d[i]
def test_getitem(self): d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) self.assertEqual(d['a'], 1) self.assertEqual(d['b'], 2) d['c'] = 3 d['a'] = 4 self.assertEqual(d['c'], 3) self.assertEqual(d['a'], 4) del d['b'] self.assertEqual(d, CuteSleekValueDict(null_callback, { 'a': 4, 'c': 3 })) self.assertRaises(TypeError, d.__getitem__) class BadEq(object): def __eq__(self, other): raise Exc() def __hash__(self): return 24 d = CuteSleekValueDict(null_callback) d[BadEq()] = 42 self.assertRaises(KeyError, d.__getitem__, 23) class Exc(Exception): pass class BadHash(object): fail = False def __hash__(self): if self.fail: raise Exc() else: return 42 x = BadHash() d[x] = 42 x.fail = True self.assertRaises(Exc, d.__getitem__, x)
class SimpleUserDict: def __init__(self): self.d = CuteSleekValueDict( null_callback, {1: 1, 2: 2, 3: 3} ) def keys(self): return list(self.d.keys()) def __getitem__(self, i): return self.d[i]
def test_pop(self): # Tests for pop with specified key d = CuteSleekValueDict(null_callback) k, v = 'abc', 'def' d[k] = v self.assertRaises(KeyError, d.pop, 'ghi') self.assertEqual(d.pop(k), v) self.assertEqual(len(d), 0) self.assertRaises(KeyError, d.pop, k) # verify longs/ints get same value when key > 32 bits # (for 64-bit archs). See SF bug #689659. (MAKES NO SENSE ON PY3) x = 4503599627370496 y = 4503599627370496 h = CuteSleekValueDict( null_callback, {x: 'anything', y: 'something else'} ) self.assertEqual(h[x], h[y]) self.assertEqual(d.pop(k, v), v) d[k] = v self.assertEqual(d.pop(k, 1), v) self.assertRaises(TypeError, d.pop) class Exc(Exception): pass class BadHash(object): fail = False def __hash__(self): if self.fail: raise Exc() else: return 42 x = BadHash() d[x] = 42 x.fail = True self.assertRaises(Exc, d.pop, x)
def test_values(self): d = CuteSleekValueDict(null_callback) self.assertEqual(d.values(), []) d = CuteSleekValueDict(null_callback, {1: 2}) self.assertEqual(d.values(), [2]) self.assertRaises(TypeError, d.values, None)
def test_none(): '''Test that `CuteSleekValueDict` can handle a value of `None`.''' d = { 1: None, 2: None, (1, ): None, (1, (1, )): None, sum: None, None: None } csvd = CuteSleekValueDict(counter, d) assert sequence_tools.are_equal_regardless_of_order( list(csvd.keys()), list(d.keys())) assert sequence_tools.are_equal_regardless_of_order( list(csvd.values()), list(d.values())) assert sequence_tools.are_equal_regardless_of_order( list(csvd.items()), list(d.items())) for key in csvd.keys(): assert key in csvd assert csvd[key] is None
def test_items(self): d = CuteSleekValueDict(null_callback) self.assertEqual(list(d.items()), []) d = CuteSleekValueDict(null_callback, {1: 2}) self.assertEqual(list(d.items()), [(1, 2)]) self.assertRaises(TypeError, d.items, None)
def test_resize1(self): # Dict resizing bug, found by Jack Jansen in 2.2 CVS development. # This version got an assert failure in debug build, infinite loop in # release build. Unfortunately, provoking this kind of stuff requires # a mix of inserts and deletes hitting exactly the right hash codes in # exactly the right order, and I can't think of a randomized approach # that would be *likely* to hit a failing case in reasonable time. d = CuteSleekValueDict(null_callback) for i in range(5): d[i] = i for i in range(5): del d[i] for i in range(5, 9): # i==8 was the problem d[i] = i
def test_container_iterator(self): # Bug #3680: tp_traverse was not implemented for dictiter objects class C(object): pass iterators = (CuteSleekValueDict.iteritems, CuteSleekValueDict.itervalues, CuteSleekValueDict.iterkeys) for i in iterators: obj = C() ref = weakref.ref(obj) container = CuteSleekValueDict(null_callback, {obj: 1}) obj.x = i(container) del obj, container gc_tools.collect() self.assertIs(ref(), None, "Cycle was not collected")
def test_resize2(self): # Another dict resizing bug (SF bug #1456209). # This caused Segmentation faults or Illegal instructions. class X(object): def __hash__(self): return 5 def __eq__(self, other): if resizing: d.clear() return False d = CuteSleekValueDict(null_callback) resizing = False d[X()] = 1 d[X()] = 2 d[X()] = 3 d[X()] = 4 d[X()] = 5 # now trigger a resize resizing = True d[9] = 6
def test_pop(self): # Tests for pop with specified key d = CuteSleekValueDict(null_callback) k, v = 'abc', 'def' d[k] = v self.assertRaises(KeyError, d.pop, 'ghi') self.assertEqual(d.pop(k), v) self.assertEqual(len(d), 0) self.assertRaises(KeyError, d.pop, k) # verify longs/ints get same value when key > 32 bits # (for 64-bit archs). See SF bug #689659. x = 4503599627370496L y = 4503599627370496 h = CuteSleekValueDict(null_callback, { x: 'anything', y: 'something else' }) self.assertEqual(h[x], h[y]) self.assertEqual(d.pop(k, v), v) d[k] = v self.assertEqual(d.pop(k, 1), v) self.assertRaises(TypeError, d.pop) class Exc(Exception): pass class BadHash(object): fail = False def __hash__(self): if self.fail: raise Exc() else: return 42 x = BadHash() d[x] = 42 x.fail = True self.assertRaises(Exc, d.pop, x)
def test_clear(self): d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) d.clear() self.assertEqual(d, CuteSleekValueDict(null_callback)) self.assertRaises(TypeError, d.clear, None)
def test_update(self): d = CuteSleekValueDict(null_callback) d.update(CuteSleekValueDict(null_callback, {1: 100})) d.update({2: 20}) d.update(CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3})) self.assertEqual( d, CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) ) d.update() self.assertEqual( d, CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) ) self.assertRaises((TypeError, AttributeError), d.update, None) class SimpleUserDict: def __init__(self): self.d = CuteSleekValueDict( null_callback, {1: 1, 2: 2, 3: 3} ) def keys(self): return list(self.d.keys()) def __getitem__(self, i): return self.d[i] d.clear() d.update(SimpleUserDict()) self.assertEqual( d, CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) ) class Exc(Exception): pass d.clear() class FailingUserDict: def keys(self): raise Exc self.assertRaises(Exc, d.update, FailingUserDict()) class FailingUserDict: def keys(self): class BogonIter: def __init__(self): self.i = 1 def __iter__(self): return self def __next__(self): if self.i: self.i = 0 return 'a' raise Exc return BogonIter() def __getitem__(self, key): return key self.assertRaises(Exc, d.update, FailingUserDict()) class FailingUserDict: def keys(self): class BogonIter: def __init__(self): self.i = ord('a') def __iter__(self): return self def __next__(self): if self.i <= ord('z'): rtn = chr(self.i) self.i += 1 return rtn raise StopIteration return BogonIter() def __getitem__(self, key): raise Exc self.assertRaises(Exc, d.update, FailingUserDict()) class badseq(object): def __iter__(self): return self def __next__(self): raise Exc() self.assertRaises(Exc, CuteSleekValueDict(null_callback).update, badseq()) self.assertRaises( ValueError, CuteSleekValueDict(null_callback).update, [(1, 2, 3)] )
def test_len(self): d = CuteSleekValueDict(null_callback) self.assertEqual(len(d), 0) d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2}) self.assertEqual(len(d), 2)
def __init__(self): self.d = CuteSleekValueDict( null_callback, {1: 1, 2: 2, 3: 3} )
def test_fromkeys(self): self.assertEqual( CuteSleekValueDict.fromkeys('abc'), CuteSleekValueDict(null_callback, {'a': None, 'b': None, 'c': None} ) ) d = CuteSleekValueDict(null_callback) self.assertIsNot(d.fromkeys('abc'), d) self.assertEqual( d.fromkeys('abc'), CuteSleekValueDict(null_callback, {'a': None, 'b': None, 'c': None}) ) self.assertEqual( d.fromkeys((4, 5), 0), CuteSleekValueDict(null_callback, {4: 0, 5: 0}) ) self.assertEqual( d.fromkeys([]), CuteSleekValueDict(null_callback) ) def g(): yield 1 self.assertEqual( d.fromkeys(g()), CuteSleekValueDict(null_callback, {1: None}) ) self.assertRaises( TypeError, CuteSleekValueDict(null_callback).fromkeys, 3 ) class CSVDoid(CuteSleekValueDict): pass self.assertEqual( CSVDoid.fromkeys('a'), CuteSleekValueDict(null_callback, {'a': None}) ) self.assertEqual( CSVDoid(null_callback).fromkeys('a'), CuteSleekValueDict(null_callback, {'a': None}) ) self.assertIsInstance( CSVDoid.fromkeys('a'), CSVDoid ) self.assertIsInstance( CSVDoid(null_callback).fromkeys('a'), CSVDoid ) #class myCSVD(CuteSleekValueDict): #def __new__(cls, callback): #return UserDict.UserDict() #ud = myCSVD.fromkeys('ab') #self.assertEqual( #ud, #CuteSleekValueDict(null_callback, {'a': None, 'b': None}) #) #self.assertIsInstance( #ud, #UserDict.UserDict #) self.assertRaises(TypeError, CuteSleekValueDict.fromkeys) class Exc(Exception): pass class badCSVD1(CuteSleekValueDict): def __init__(self, callback): raise Exc() self.assertRaises(Exc, badCSVD1.fromkeys, [1]) class BadSeq(object): def __iter__(self): return self def __next__(self): raise Exc() self.assertRaises(Exc, CuteSleekValueDict.fromkeys, BadSeq()) class badCSVD2(dict): def __setitem__(self, key, value): raise Exc() self.assertRaises(Exc, badCSVD2.fromkeys, [1]) # test fast path for dictionary inputs d = CuteSleekValueDict(null_callback, list(zip(list(range(6)), list(range(6))))) self.assertEqual( CuteSleekValueDict.fromkeys(d, 0), CuteSleekValueDict(null_callback, list(zip(list(range(6)), [0]*6))))
def test_tuple_keyerror(self): # SF #1576657 d = CuteSleekValueDict(null_callback) with self.assertRaises(KeyError) as c: d[(1, )]
def test_update(self): d = CuteSleekValueDict(null_callback) d.update(CuteSleekValueDict(null_callback, {1: 100})) d.update({2: 20}) d.update(CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3})) self.assertEqual(d, CuteSleekValueDict(null_callback, { 1: 1, 2: 2, 3: 3 })) d.update() self.assertEqual(d, CuteSleekValueDict(null_callback, { 1: 1, 2: 2, 3: 3 })) self.assertRaises((TypeError, AttributeError), d.update, None) class SimpleUserDict: def __init__(self): self.d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3}) def keys(self): return self.d.keys() def __getitem__(self, i): return self.d[i] d.clear() d.update(SimpleUserDict()) self.assertEqual(d, CuteSleekValueDict(null_callback, { 1: 1, 2: 2, 3: 3 })) class Exc(Exception): pass d.clear() class FailingUserDict: def keys(self): raise Exc self.assertRaises(Exc, d.update, FailingUserDict()) class FailingUserDict: def keys(self): class BogonIter: def __init__(self): self.i = 1 def __iter__(self): return self def next(self): if self.i: self.i = 0 return 'a' raise Exc return BogonIter() def __getitem__(self, key): return key self.assertRaises(Exc, d.update, FailingUserDict()) class FailingUserDict: def keys(self): class BogonIter: def __init__(self): self.i = ord('a') def __iter__(self): return self def next(self): if self.i <= ord('z'): rtn = chr(self.i) self.i += 1 return rtn raise StopIteration return BogonIter() def __getitem__(self, key): raise Exc self.assertRaises(Exc, d.update, FailingUserDict()) class badseq(object): def __iter__(self): return self def next(self): raise Exc() self.assertRaises(Exc, CuteSleekValueDict(null_callback).update, badseq()) self.assertRaises(ValueError, CuteSleekValueDict(null_callback).update, [(1, 2, 3)])
def __init__(self): self.d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3})
def test_fromkeys(self): self.assertEqual( CuteSleekValueDict.fromkeys('abc'), CuteSleekValueDict(null_callback, { 'a': None, 'b': None, 'c': None })) d = CuteSleekValueDict(null_callback) self.assertIsNot(d.fromkeys('abc'), d) self.assertEqual( d.fromkeys('abc'), CuteSleekValueDict(null_callback, { 'a': None, 'b': None, 'c': None })) self.assertEqual(d.fromkeys((4, 5), 0), CuteSleekValueDict(null_callback, { 4: 0, 5: 0 })) self.assertEqual(d.fromkeys([]), CuteSleekValueDict(null_callback)) def g(): yield 1 self.assertEqual(d.fromkeys(g()), CuteSleekValueDict(null_callback, {1: None})) self.assertRaises(TypeError, CuteSleekValueDict(null_callback).fromkeys, 3) class CSVDoid(CuteSleekValueDict): pass self.assertEqual(CSVDoid.fromkeys('a'), CuteSleekValueDict(null_callback, {'a': None})) self.assertEqual( CSVDoid(null_callback).fromkeys('a'), CuteSleekValueDict(null_callback, {'a': None})) self.assertIsInstance(CSVDoid.fromkeys('a'), CSVDoid) self.assertIsInstance(CSVDoid(null_callback).fromkeys('a'), CSVDoid) class myCSVD(CuteSleekValueDict): def __new__(cls, callback): return UserDict.UserDict() ud = myCSVD.fromkeys('ab') self.assertEqual( ud, CuteSleekValueDict(null_callback, { 'a': None, 'b': None })) self.assertIsInstance(ud, UserDict.UserDict) self.assertRaises(TypeError, CuteSleekValueDict.fromkeys) class Exc(Exception): pass class badCSVD1(CuteSleekValueDict): def __init__(self, callback): raise Exc() self.assertRaises(Exc, badCSVD1.fromkeys, [1]) class BadSeq(object): def __iter__(self): return self def next(self): raise Exc() self.assertRaises(Exc, CuteSleekValueDict.fromkeys, BadSeq()) class badCSVD2(dict): def __setitem__(self, key, value): raise Exc() self.assertRaises(Exc, badCSVD2.fromkeys, [1]) # test fast path for dictionary inputs d = CuteSleekValueDict(null_callback, zip(range(6), range(6))) self.assertEqual( CuteSleekValueDict.fromkeys(d, 0), CuteSleekValueDict(null_callback, zip(range(6), [0] * 6)))