def test_map_mut_21(self):
# Issue 24:
# Array nodes, while in mutation, failed to increment the
# internal count of elements when adding a new key to it.
# Because the internal count
h = self.Map()
for i in range(18):
# Create more than 16 keys to trigger the root bitmap
# node to be converted into an array node
h = h.set(HashKey(i, i), i)
with h.mutate() as m:
# Add one new key to the array node
m[HashKey(18, 18)] = 18
# Add another key -- after this the old code failed
# to increment the number of elements in the mutated
# array node.
m[HashKey(19, 19)] = 19
h = m.finish()
for i in range(20):
# Start deleting keys one by one. Because array node
# element count was accounted incorrectly (smaller by 1
# than it actually is, the mutation for "del h[18]" would
# create an empty array node, clipping the "19" key).
# Before the issue #24 fix, the below line would crash
# on i=19.
h = h.delete(HashKey(i, i))
def test_hashkey_helper_1(self):
k1 = HashKey(10, 'aaa')
k2 = HashKey(10, 'bbb')
self.assertNotEqual(k1, k2)
self.assertEqual(hash(k1), hash(k2))
d = dict()
d[k1] = 'a'
d[k2] = 'b'
self.assertEqual(d[k1], 'a')
self.assertEqual(d[k2], 'b')
def test_map_delete_5(self):
h = self.Map()
keys = []
for i in range(17):
key = HashKey(i, str(i))
keys.append(key)
h = h.set(key, 'val-{}'.format(i))
collision_key16 = HashKey(16, '18')
h = h.set(collision_key16, 'collision')
# ArrayNode(id=0x10f8b9318):
# 0::
# BitmapNode(size=2 count=1 bitmap=0b1):
# <Key name:0 hash:0>: 'val-0'
#
# ... 14 more BitmapNodes ...
#
# 15::
# BitmapNode(size=2 count=1 bitmap=0b1):
# <Key name:15 hash:15>: 'val-15'
#
# 16::
# BitmapNode(size=2 count=1 bitmap=0b1):
# NULL:
# CollisionNode(size=4 id=0x10f2f5af8):
# <Key name:16 hash:16>: 'val-16'
# <Key name:18 hash:16>: 'collision'
self.assertEqual(len(h), 18)
h = h.delete(keys[2])
self.assertEqual(len(h), 17)
h = h.delete(collision_key16)
self.assertEqual(len(h), 16)
h = h.delete(keys[16])
self.assertEqual(len(h), 15)
h = h.delete(keys[1])
self.assertEqual(len(h), 14)
with self.assertRaises(KeyError) as ex:
h.delete(keys[1])
self.assertIs(ex.exception.args[0], keys[1])
self.assertEqual(len(h), 14)
for key in keys:
if key in h:
h = h.delete(key)
self.assertEqual(len(h), 0)
def test_map_eq_2(self):
A = HashKey(100, 'A')
Er = HashKey(100, 'Er', error_on_eq_to=A)
h1 = self.Map()
h1 = h1.set(A, 'a')
h2 = self.Map()
h2 = h2.set(Er, 'a')
with self.assertRaisesRegex(ValueError, 'cannot compare'):
h1 == h2
with self.assertRaisesRegex(ValueError, 'cannot compare'):
h1 != h2
def test_map_eq_1(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(120, 'E')
h1 = self.Map()
h1 = h1.set(A, 'a')
h1 = h1.set(B, 'b')
h1 = h1.set(C, 'c')
h1 = h1.set(D, 'd')
h2 = self.Map()
h2 = h2.set(A, 'a')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.set(B, 'b')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.set(C, 'c')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.set(D, 'd2')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.set(D, 'd')
self.assertTrue(h1 == h2)
self.assertFalse(h1 != h2)
h2 = h2.set(E, 'e')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.delete(D)
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h2 = h2.set(E, 'd')
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
def test_map_mut_20(self):
# Issue 24:
h = self.Map()
for i in range(19):
# Create more than 16 keys to trigger the root bitmap
# node to be converted into an array node
h = h.set(HashKey(i, i), i)
h = h.set(HashKey(18, '18-collision'), 18)
with h.mutate() as m:
del m[HashKey(18, 18)]
del m[HashKey(18, '18-collision')]
# The pre-issue-24 code failed to update the number of array
# node element, so at this point it would be greater than it
# actually is.
h = m.finish()
# Any of the below operations shouldn't crash the debug build.
with h.mutate() as m:
for i in range(18):
del m[HashKey(i, i)]
h = m.finish()
h = h.set(HashKey(21, 21), 21)
h = h.set(HashKey(22, 22), 22)
def test_map_in_1(self):
A = HashKey(100, 'A')
AA = HashKey(100, 'A')
B = HashKey(101, 'B')
h = self.Map()
h = h.set(A, 1)
self.assertTrue(A in h)
self.assertFalse(B in h)
with self.assertRaises(EqError):
with HashKeyCrasher(error_on_eq=True):
AA in h
with self.assertRaises(HashingError):
with HashKeyCrasher(error_on_hash=True):
AA in h
def test_map_mut_13(self):
key1 = HashKey(123, 'aaa')
key2 = HashKey(123, 'aaa')
m = self.Map({key1: 123})
mm = m.mutate()
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
del mm[key2]
mm = m.mutate()
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
mm.pop(key2, None)
mm = m.mutate()
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
mm.set(key2, 123)
def test_repr_2(self):
h = self.Map()
A = HashKey(100, 'A')
with self.assertRaises(ReprError):
with HashKeyCrasher(error_on_repr=True):
repr(h.set(1, 2).set(A, 3).set(3, 4))
with self.assertRaises(ReprError):
with HashKeyCrasher(error_on_repr=True):
repr(h.set(1, 2).set(2, A).set(3, 4))
def test_map_delete_3(self):
A = HashKey(0b00000000001100100, 'A')
B = HashKey(0b00000000001100101, 'B')
C = HashKey(0b11000011100000100, 'C')
D = HashKey(0b11000011100000100, 'D')
X = HashKey(0b01000011100000100, 'Z')
Y = HashKey(0b11000011100000100, 'Y')
E = HashKey(0b00000000001101000, 'E')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
self.assertEqual(len(h), 5)
h = h.set(C, 'c') # trigger branch in CollisionNode.assoc
self.assertEqual(len(h), 5)
orig_len = len(h)
with self.assertRaises(KeyError):
h.delete(X)
with self.assertRaises(KeyError):
h.delete(Y)
# BitmapNode(size=6 bitmap=0b100110000):
# NULL:
# BitmapNode(size=4 bitmap=0b1000000000000000000001000):
# <Key name:A hash:100>: 'a'
# NULL:
# CollisionNode(size=4 id=0x108572410):
# <Key name:C hash:100100>: 'c'
# <Key name:D hash:100100>: 'd'
# <Key name:B hash:101>: 'b'
# <Key name:E hash:104>: 'e'
h = h.delete(A)
self.assertEqual(len(h), orig_len - 1)
h = h.delete(E)
self.assertEqual(len(h), orig_len - 2)
self.assertEqual(h.get(C), 'c')
self.assertEqual(h.get(B), 'b')
h2 = h.delete(C)
self.assertEqual(len(h2), orig_len - 3)
h2 = h.delete(D)
self.assertEqual(len(h2), orig_len - 3)
self.assertEqual(len(h), orig_len - 2)
def test_map_delete_4(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(100100, 'E')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
orig_len = len(h)
# BitmapNode(size=4 bitmap=0b110000):
# NULL:
# BitmapNode(size=4 bitmap=0b1000000000000000000001000):
# <Key name:A hash:100>: 'a'
# NULL:
# CollisionNode(size=6 id=0x10515ef30):
# <Key name:C hash:100100>: 'c'
# <Key name:D hash:100100>: 'd'
# <Key name:E hash:100100>: 'e'
# <Key name:B hash:101>: 'b'
h = h.delete(D)
self.assertEqual(len(h), orig_len - 1)
h = h.delete(E)
self.assertEqual(len(h), orig_len - 2)
h = h.delete(C)
self.assertEqual(len(h), orig_len - 3)
h = h.delete(A)
self.assertEqual(len(h), orig_len - 4)
h = h.delete(B)
self.assertEqual(len(h), 0)
def test_map_mut_9(self):
key1 = HashKey(123, 'aaa')
src = {key1: 123}
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
self.Map(src)
src = [(1, 2), (key1, 123)]
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
self.Map(src)
def test_hash_2(self):
h = self.Map()
A = HashKey(100, 'A')
m = h.set(1, 2).set(A, 3).set(3, 4)
with self.assertRaises(HashingError):
with HashKeyCrasher(error_on_hash=True):
hash(m)
m = h.set(1, 2).set(2, A).set(3, 4)
with self.assertRaises(HashingError):
with HashKeyCrasher(error_on_hash=True):
hash(m)
def test_map_getitem_1(self):
A = HashKey(100, 'A')
AA = HashKey(100, 'A')
B = HashKey(101, 'B')
h = self.Map()
h = h.set(A, 1)
self.assertEqual(h[A], 1)
self.assertEqual(h[AA], 1)
with self.assertRaises(KeyError):
h[B]
with self.assertRaises(EqError):
with HashKeyCrasher(error_on_eq=True):
h[AA]
with self.assertRaises(HashingError):
with HashKeyCrasher(error_on_hash=True):
h[AA]
def test_map_mut_8(self):
key1 = HashKey(123, 'aaa')
key2 = HashKey(123, 'bbb')
h = self.Map({key1: 123})
self.assertEqual(dict(h.items()), {key1: 123})
upd = {key2: 1}
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
h.update(upd)
upd = self.Map({key2: 'zzz'})
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
h.update(upd)
upd = [(1, 2), (key2, 'zzz')]
with HashKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
h.update(upd)
self.assertEqual(dict(h.items()), {key1: 123})
def test_map_mut_stress(self):
COLLECTION_SIZE = 7000
TEST_ITERS_EVERY = 647
RUN_XTIMES = 3
for _ in range(RUN_XTIMES):
h = self.Map()
d = dict()
for i in range(COLLECTION_SIZE // TEST_ITERS_EVERY):
hm = h.mutate()
for j in range(TEST_ITERS_EVERY):
key = random.randint(1, 100000)
key = HashKey(key % 271, str(key))
hm.set(key, key)
d[key] = key
self.assertEqual(len(hm), len(d))
h2 = hm.finish()
self.assertEqual(dict(h2.items()), d)
h = h2
self.assertEqual(dict(h.items()), d)
self.assertEqual(len(h), len(d))
it = iter(tuple(d.keys()))
for i in range(COLLECTION_SIZE // TEST_ITERS_EVERY):
hm = h.mutate()
for j in range(TEST_ITERS_EVERY):
try:
key = next(it)
except StopIteration:
break
del d[key]
del hm[key]
self.assertEqual(len(hm), len(d))
h2 = hm.finish()
self.assertEqual(dict(h2.items()), d)
h = h2
self.assertEqual(dict(h.items()), d)
self.assertEqual(len(h), len(d))
def test_map_collision_1(self):
k1 = HashKey(10, 'aaa')
k2 = HashKey(10, 'bbb')
k3 = HashKey(10, 'ccc')
h = self.Map()
h2 = h.set(k1, 'a')
h3 = h2.set(k2, 'b')
self.assertEqual(h.get(k1), None)
self.assertEqual(h.get(k2), None)
self.assertEqual(h2.get(k1), 'a')
self.assertEqual(h2.get(k2), None)
self.assertEqual(h3.get(k1), 'a')
self.assertEqual(h3.get(k2), 'b')
h4 = h3.set(k2, 'cc')
h5 = h4.set(k3, 'aa')
self.assertEqual(h3.get(k1), 'a')
self.assertEqual(h3.get(k2), 'b')
self.assertEqual(h4.get(k1), 'a')
self.assertEqual(h4.get(k2), 'cc')
self.assertEqual(h4.get(k3), None)
self.assertEqual(h5.get(k1), 'a')
self.assertEqual(h5.get(k2), 'cc')
self.assertEqual(h5.get(k2), 'cc')
self.assertEqual(h5.get(k3), 'aa')
self.assertEqual(len(h), 0)
self.assertEqual(len(h2), 1)
self.assertEqual(len(h3), 2)
self.assertEqual(len(h4), 2)
self.assertEqual(len(h5), 3)
def test_map_collision_2(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(0b011000011100000100, 'C')
D = HashKey(0b011000011100000100, 'D')
E = HashKey(0b1011000011100000100, 'E')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
# BitmapNode(size=6 bitmap=0b100110000):
# NULL:
# BitmapNode(size=4 bitmap=0b1000000000000000000001000):
# <Key name:A hash:100>: 'a'
# NULL:
# CollisionNode(size=4 id=0x108572410):
# <Key name:C hash:100100>: 'c'
# <Key name:D hash:100100>: 'd'
# <Key name:B hash:101>: 'b'
h = h.set(E, 'e')
def test_map_gc_2(self):
A = HashKey(100, 'A')
h = self.Map()
h = h.set(A, 'a')
h = h.set(A, h)
ref = weakref.ref(h)
hi = iter(h.items())
next(hi)
del h, hi
gc.collect()
gc.collect()
gc.collect()
self.assertIsNone(ref())
def test_map_delete_1(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(102, 'C')
D = HashKey(103, 'D')
E = HashKey(104, 'E')
Z = HashKey(-100, 'Z')
Er = HashKey(103, 'Er', error_on_eq_to=D)
h = self.Map()
h = h.set(A, 'a')
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
orig_len = len(h)
# BitmapNode(size=10 bitmap=0b111110000 id=0x10eadc618):
# <Key name:A hash:100>: 'a'
# <Key name:B hash:101>: 'b'
# <Key name:C hash:102>: 'c'
# <Key name:D hash:103>: 'd'
# <Key name:E hash:104>: 'e'
h = h.delete(C)
self.assertEqual(len(h), orig_len - 1)
with self.assertRaisesRegex(ValueError, 'cannot compare'):
h.delete(Er)
h = h.delete(D)
self.assertEqual(len(h), orig_len - 2)
with self.assertRaises(KeyError) as ex:
h.delete(Z)
self.assertIs(ex.exception.args[0], Z)
h = h.delete(A)
self.assertEqual(len(h), orig_len - 3)
self.assertEqual(h.get(A, 42), 42)
self.assertEqual(h.get(B), 'b')
self.assertEqual(h.get(E), 'e')
def test_map_mut_10(self):
key1 = HashKey(123, 'aaa')
m = self.Map({key1: 123})
mm = m.mutate()
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
del mm[key1]
mm = m.mutate()
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
mm.pop(key1, None)
mm = m.mutate()
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
mm.set(key1, 123)
def test_map_gc_1(self):
A = HashKey(100, 'A')
h = self.Map()
h = h.set(0, 0) # empty Map node is memoized in _map.c
ref = weakref.ref(h)
a = []
a.append(a)
a.append(h)
b = []
a.append(b)
b.append(a)
h = h.set(A, b)
del h, a, b
gc.collect()
gc.collect()
gc.collect()
self.assertIsNone(ref())
def test_map_mut_7(self):
key = HashKey(123, 'aaa')
h = self.Map({'a': 1, 'b': 2}, z=100)
self.assertEqual(dict(h.items()), {'a': 1, 'b': 2, 'z': 100})
upd = {key: 1}
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
h.update(upd)
upd = self.Map({key: 'zzz'})
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
h.update(upd)
upd = [(1, 2), (key, 'zzz')]
with HashKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
h.update(upd)
self.assertEqual(dict(h.items()), {'a': 1, 'b': 2, 'z': 100})
def test_map_values_1(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(100100, 'E')
F = HashKey(110, 'F')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
h = h.set(F, 'f')
self.assertEqual(set(list(h.values())), {'a', 'b', 'c', 'd', 'e', 'f'})
def test_map_keys_1(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(100100, 'E')
F = HashKey(110, 'F')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
h = h.set(F, 'f')
self.assertEqual(set(list(h.keys())), {A, B, C, D, E, F})
self.assertEqual(set(list(h)), {A, B, C, D, E, F})
def test_map_items_2(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(100100, 'E')
F = HashKey(110, 'F')
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
h = h.set(F, 'f')
it = h.items()
self.assertEqual(set(list(it)), {(A, 'a'), (B, 'b'), (C, 'c'),
(D, 'd'), (E, 'e'), (F, 'f')})
def test_none_collision_2(self):
key = HashKey(not_collision, 'a')
m = self.Map().set(None, 1).set(key, 2)
self.assertEqual(len(m), 2)
self.assertTrue(key in m)
self.assertTrue(None in m)
self.assertEqual(m[key], 2)
self.assertEqual
m = m.set(None, 0)
self.assertEqual(len(m), 2)
self.assertTrue(key in m)
self.assertTrue(None in m)
for level in range(7):
key2 = NoneCollision('b', level)
self.assertFalse(key2 in m)
m2 = m.set(key2, 1)
self.assertEqual(len(m2), 3)
self.assertTrue(key in m2)
self.assertTrue(None in m2)
self.assertTrue(key2 in m2)
self.assertEqual(m2[key], 2)
self.assertEqual(m2[None], 0)
self.assertEqual(m2[key2], 1)
m2 = m2.set(None, 1)
self.assertEqual(len(m2), 3)
self.assertTrue(key in m2)
self.assertTrue(None in m2)
self.assertTrue(key2 in m2)
self.assertEqual(m2[key], 2)
self.assertEqual(m2[None], 1)
self.assertEqual(m2[key2], 1)
m2 = m2.set(None, 2)
self.assertEqual(len(m2), 3)
self.assertTrue(key in m2)
self.assertTrue(None in m2)
self.assertTrue(key2 in m2)
self.assertEqual(m2[key], 2)
self.assertEqual(m2[None], 2)
self.assertEqual(m2[key2], 1)
m3 = m2.delete(key)
self.assertEqual(len(m3), 2)
self.assertTrue(None in m3)
self.assertTrue(key2 in m3)
self.assertFalse(key in m3)
self.assertEqual(m3[None], 2)
self.assertEqual(m3[key2], 1)
with self.assertRaises(KeyError):
m3.delete(key)
m3 = m2.delete(key2)
self.assertEqual(len(m3), 2)
self.assertTrue(None in m3)
self.assertTrue(key in m3)
self.assertFalse(key2 in m3)
self.assertEqual(m3[None], 2)
self.assertEqual(m3[key], 2)
with self.assertRaises(KeyError):
m3.delete(key2)
m3 = m2.delete(None)
self.assertEqual(len(m3), 2)
self.assertTrue(key in m3)
self.assertTrue(key2 in m3)
self.assertFalse(None in m3)
self.assertEqual(m3[key], 2)
self.assertEqual(m3[key2], 1)
with self.assertRaises(KeyError):
m3.delete(None)
m2 = m.delete(None)
self.assertEqual(len(m2), 1)
self.assertFalse(None in m2)
self.assertTrue(key in m2)
self.assertEqual(m2[key], 2)
with self.assertRaises(KeyError):
m2.delete(None)
m2 = m.delete(key)
self.assertEqual(len(m2), 1)
self.assertFalse(key in m2)
self.assertTrue(None in m2)
self.assertEqual(m2[None], 0)
with self.assertRaises(KeyError):
m2.delete(key)
def test_map_delete_2(self):
A = HashKey(100, 'A')
B = HashKey(201001, 'B')
C = HashKey(101001, 'C')
BLike = HashKey(201001, 'B-like')
D = HashKey(103, 'D')
E = HashKey(104, 'E')
Z = HashKey(-100, 'Z')
Er = HashKey(201001, 'Er', error_on_eq_to=B)
h = self.Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
h = h.set(B, 'b') # trigger branch in BitmapNode.assoc
with self.assertRaises(KeyError):
h.delete(BLike) # trigger branch in BitmapNode.without
orig_len = len(h)
# BitmapNode(size=8 bitmap=0b1110010000):
# <Key name:A hash:100>: 'a'
# <Key name:D hash:103>: 'd'
# <Key name:E hash:104>: 'e'
# NULL:
# BitmapNode(size=4 bitmap=0b100000000001000000000):
# <Key name:B hash:201001>: 'b'
# <Key name:C hash:101001>: 'c'
with self.assertRaisesRegex(ValueError, 'cannot compare'):
h.delete(Er)
with self.assertRaises(KeyError) as ex:
h.delete(Z)
self.assertIs(ex.exception.args[0], Z)
self.assertEqual(len(h), orig_len)
h = h.delete(C)
self.assertEqual(len(h), orig_len - 1)
h = h.delete(B)
self.assertEqual(len(h), orig_len - 2)
h = h.delete(A)
self.assertEqual(len(h), orig_len - 3)
self.assertEqual(h.get(D), 'd')
self.assertEqual(h.get(E), 'e')
with self.assertRaises(KeyError):
h = h.delete(A)
with self.assertRaises(KeyError):
h = h.delete(B)
h = h.delete(D)
h = h.delete(E)
self.assertEqual(len(h), 0)