def test_lazy_len(self): d = LazyDict({'1':1}) self.assertEqual(len(d), 1) d['2'] = 2 self.assertEqual(len(d), 2) d.set_stub('3', lambda x: x) self.assertEqual(len(d), 3)
def test_popitem(self): # dict.popitem() 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 = LazyDict() b = LazyDict() 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)) self.assertFalse(copymode < 0 and ta != tb) self.assertFalse(a) self.assertFalse(b) d = LazyDict() self.assertRaises(KeyError, d.popitem)
def test_items(self): d = LazyDict() self.assertEqual(set(d.items()), set()) d = LazyDict({1:2}) self.assertEqual(set(d.items()), {(1, 2)}) self.assertRaises(TypeError, d.items, None)
def test_lazy_popitem(self): d = LazyDict({1: 1}) d.set_stub(2, lambda x:x) k, v = d.popitem() self.assertEqual(k, v) k, v = d.popitem() self.assertEqual(k, v) self.assertEqual(k, 2) self.assertEqual(len(d._stubs), 0) self.assertRaises(KeyError, d.popitem)
def test_keys(self): d = LazyDict() self.assertEqual(set(d.keys()), set()) d = LazyDict({'a': 1, 'b': 2}) k = d.keys() self.assertTrue('a' in d) self.assertTrue('b' in d) self.assertEqual(set(k), {'a','b'}) self.assertRaises(TypeError, d.keys, None)
def test_setdefault(self): # dict.setdefault() d = LazyDict() 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_lazy_setdefault(self): d = LazyDict() self.assertIs(d.setdefault('key0'), None) d.set_stub('key0', lambda x:'value0') self.assertIs(d.setdefault('key0'), 'value0') d.set_stub('key0', lambda x:'value0') self.assertEqual(d.setdefault('key1', 'value1'), 'value1') self.assertEqual(d['key1'], 'value1') self.assertEqual(d.setdefault('key0', 'value2'), 'value0')
def test_lazy_keys(self): def resolver(id): p = {'b': 2, 'c': 3} return p[id] d = LazyDict({'a': 1}) d.set_stub('b', resolver) d.set_stub('c', resolver) d['d'] = 4 k = d.keys() self.assertTrue('a' in d) self.assertTrue('b' in d) self.assertTrue('c' in d) self.assertTrue('d' in d) self.assertEqual(set(k), {'a','b','c','d'})
def test_lazy_get(self): d = LazyDict({'a': 1, 'b': 2}) d.set_stub('d', lambda x:x) 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.assertEqual(d.get('d'), 'd') self.assertEqual(d.get('d', 3), 'd') self.assertRaises(TypeError, d.get) self.assertRaises(TypeError, d.get, None, None, None)
def test_lazy_items(self): d = LazyDict() d.set_stub(1, lambda x:x) self.assertEqual(set(d.items()), {(1, 1)}) d = LazyDict({1:2}) d.set_stub(2, lambda x:x) self.assertEqual(set(d.items()), {(1, 2), (2, 2)})
def test_lazy_delitem(self): d = LazyDict() d['1'] = 1 d['2'] = 2 del d['1'] self.assertEqual(len(d), 1) self.assertRaises(KeyError, d.__getitem__, '1') d.set_stub('1', lambda x:x) self.assertEqual(len(d), 2) del d['1'] self.assertEqual(len(d), 1) self.assertRaises(KeyError, d.__getitem__, '1') d.set_stub('1', lambda x:x) self.assertEqual(d['1'], '1') del d['1'] self.assertEqual(len(d), 1) self.assertRaises(KeyError, d.__getitem__, '1')
def test_get(self): d = LazyDict() self.assertIs(d.get('c'), None) self.assertEqual(d.get('c', 3), 3) d = LazyDict({'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_lazy_clear(self): d = LazyDict({1:1, 2:2, 3:3}) d.set_stub(4, lambda x:x) d.clear() self.assertEqual(d, {}) self.assertEqual(set(d.keys()), set()) self.assertEqual(set(d.values()), set()) self.assertRaises(TypeError, d.clear, None)
def test_pop(self): # Tests for pop with specified key d = LazyDict() 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 = 4503599627370496 y = 4503599627370496 h = LazyDict({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_lazy_pop(self): d = LazyDict() k, v = ('abc', 'def') d.set_stub(k, lambda x:'def') self.assertRaises(KeyError, d.pop, 'ghi') self.assertEqual(d.pop(k), v) self.assertEqual(len(d), 0) self.assertRaises(KeyError, d.pop, k) self.assertEqual(d.pop(k, v), v) d.set_stub(k, lambda x:v) self.assertEqual(d.pop(k, 1), v) self.assertRaises(TypeError, d.pop)
def test_lazy_values(self): def resolver(id): p = {'c': 3} return p[id] d = LazyDict() self.assertEqual(set(d.values()), set()) d = LazyDict({1:2}) d.set_stub('c', resolver) v = d.values() self.assertEqual(set(v), {2,3}) self.assertRaises(TypeError, d.values, None)
def test_fromkeys(self): self.assertEqual(LazyDict().fromkeys('abc'), {'a':None, 'b':None, 'c':None}) d = LazyDict() self.assertIsNot(d.fromkeys('abc'), d) self.assertEqual(d.fromkeys('abc'), LazyDict({'a':None, 'b':None, 'c':None})) self.assertEqual(d.fromkeys((4,5),0), LazyDict({4:0, 5:0})) self.assertEqual(d.fromkeys([]), LazyDict()) def g(): yield 1 self.assertEqual(d.fromkeys(g()), LazyDict({1:None})) self.assertRaises(TypeError, {}.fromkeys, 3) class dictlike(LazyDict): pass self.assertEqual(dictlike.fromkeys('a'), LazyDict({'a':None})) self.assertEqual(dictlike().fromkeys('a'), LazyDict({'a':None})) self.assertTrue(type(dictlike.fromkeys('a')) is dictlike) self.assertTrue(type(dictlike().fromkeys('a')) is dictlike) class mydict(LazyDict): def __new__(cls): return LazyDict() ud = mydict.fromkeys('ab') self.assertEqual(ud, LazyDict({'a':None, 'b':None})) self.assertTrue(isinstance(ud, LazyDict)) self.assertRaises(TypeError, dict.fromkeys) class Exc(Exception): pass class baddict1(LazyDict): def __init__(self): raise Exc() self.assertRaises(Exc, baddict1.fromkeys, [1]) class baddict2(LazyDict): def __setitem__(self, key, value): raise Exc() self.assertRaises(Exc, baddict2.fromkeys, [1]) # test fast path for dictionary inputs d = LazyDict(zip(range(6), range(6))) self.assertEqual(LazyDict.fromkeys(d, 0), LazyDict(zip(range(6), [0]*6)))
def test_lazy_copy(self): d = LazyDict({'1':1}) d['2'] = 2 x = d.copy() self.assertEqual(len(x), 2) i = {'num': 0} def r(key, i): i['num'] += 1 return i['num'] d.set_stub('3', r, i) x = d.copy() self.assertEqual(d['3'], 1) self.assertEqual(len(d._stubs), 0) self.assertEqual(len(x._stubs), 1) self.assertEqual(x['3'], 2) self.assertEqual(len(x._stubs), 0) x = d.copy() self.assertEqual(d['3'], 1) self.assertEqual(x['3'], 1)
def test_clear(self): d = LazyDict({1:1, 2:2, 3:3}) d.clear() self.assertEqual(d, {}) self.assertRaises(TypeError, d.clear, None)
def test_copy(self): d = LazyDict({1:1, 2:2, 3:3}) self.assertEqual(d.copy(), LazyDict({1:1, 2:2, 3:3})) self.assertEqual(LazyDict().copy(), LazyDict()) self.assertRaises(TypeError, d.copy, None)
def test_lazy_update(self): d = LazyDict() d.set_stub(4, lambda x:x) d.update(LazyDict({1:100})) d.update(LazyDict({2:20})) d.update({4:5}) d.update(LazyDict({1:1, 2:2, 3:3})) self.assertEqual(d, {1:1, 2:2, 3:3, 4:5}) d.update() self.assertEqual(d, {1:1, 2:2, 3:3, 4:5}) self.assertRaises((TypeError, AttributeError), d.update, None) class SimpleUserDict: def __init__(self): self.d = {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, {1:1, 2:2, 3:3})
def test_values(self): d = LazyDict() self.assertEqual(set(d.values()), set()) d = LazyDict({1:2}) self.assertEqual(set(d.values()), {2}) self.assertRaises(TypeError, d.values, None)
def test_update(self): d = LazyDict() d.update({1:100}) d.update({2:20}) d.update({1:1, 2:2, 3:3}) self.assertEqual(d, {1:1, 2:2, 3:3}) d.update() self.assertEqual(d, {1:1, 2:2, 3:3}) self.assertRaises((TypeError, AttributeError), d.update, None) class SimpleUserDict: def __init__(self): self.d = {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, {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 next = __next__ 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 next = __next__ 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() next = __next__ self.assertRaises(Exc, {}.update, badseq()) self.assertRaises(ValueError, {}.update, [(1, 2, 3)])