def test_equal_with_different_insertion_order():
x = pmap([(i, i) for i in range(50)], 10)
y = pmap([(i, i) for i in range(49, -1, -1)], 10)
assert x == y
assert not (x != y)
assert y == x
assert not (y != x)
def test_set_with_relocation():
x = pmap({"a": 1000})
x = x.set("b", 3000)
x = x.set("c", 4000)
x = x.set("d", 5000)
x = x.set("d", 6000)
assert len(x) == 4
assert x == pmap({"a": 1000, "b": 3000, "c": 4000, "d": 6000})
def test_equal_with_different_bucket_sizes():
x = pmap({"a": 1, "b": 2}, 50)
y = pmap({"a": 1, "b": 2}, 10)
assert x == y
assert not (x != y)
assert y == x
assert not (y != x)
def test_evolver_update_with_relocation():
x = pmap({"a": 1000}, pre_size=1)
e = x.evolver()
e["b"] = 3000
e["c"] = 4000
e["d"] = 5000
e["d"] = 6000
assert len(e) == 4
assert e.persistent() == pmap({"a": 1000, "b": 3000, "c": 4000, "d": 6000})
def test_same_hash_when_content_the_same_but_underlying_vector_size_differs():
x = pmap(dict((x, x) for x in range(1000)))
y = pmap({10: 10, 200: 200, 700: 700})
for z in x:
if z not in y:
x = x.remove(z)
assert x == y
assert hash(x) == hash(y)
def test_iter():
container = pmap()
for key in range(100):
value = key
container.set(key, value)
for index, key in enumerate(sorted(container)):
assert index == key and index == container[key]
def test_access_non_existing_element():
map1 = pmap()
assert len(map1) == 0
map2 = map1.set("1", 1)
assert "1" not in map1
assert map2["1"] == 1
assert "2" not in map2
def test_initialization_with_two_elements():
map = pmap({"a": 2, "b": 3})
assert len(map) == 2
assert map["a"] == 2
assert map["b"] == 3
map2 = map.remove("a")
assert "a" not in map2
assert map2["b"] == 3
def test_initialization_with_one_element():
the_map = pmap({"a": 2})
assert len(the_map) == 1
assert the_map["a"] == 2
# assert the_map.a == 2 # TODO: Implement __getattr__
assert "a" in the_map
assert the_map == the_map.discard("b")
empty_map = the_map.remove("a")
assert len(empty_map) == 0
assert "a" not in empty_map
def test_map():
map_0 = pmap()
assert len(map_0) == 0
assert hash(map_0) == -4800647303603446203
assert set(map_0.values()) == set()
map_1 = map_0.set(0, 0)
assert 0 in map_1
assert map_1.get(0) == 0
assert map_1[0] == 0
assert len(map_1) == 1
assert hash(map_1) == 2885792717948792520
assert set(map_1.values()) == {0}
map_2 = map_1.set("1", 1)
assert 0 in map_2
assert map_2.get(0) == 0
assert map_2[0] == 0
assert "1" in map_2
assert map_2.get("1") == 1
assert map_2["1"] == 1
assert len(map_2) == 2
assert set(map_2.keys()) == {0, "1"}
assert set(map_2.values()) == {0, 1}
assert set(map_2.items()) == {(0, 0), ("1", 1)}
map_3 = map_2.set(2, "2")
assert 0 in map_3
assert map_3.get(0) == 0
assert "1" in map_3
assert map_3.get("1") == 1
assert 2 in map_3
assert map_3.get(2) == "2"
assert len(map_3) == 3
assert set(map_3.values()) == {0, "2", 1}
map_4 = map_3.remove(2)
assert 0 in map_4
assert map_4.get(0) == 0
assert "1" in map_4
assert map_4.get("1") == 1
assert len(map_4) == 2
assert set(map_4.values()) == {0, 1}
assert map_0 != map_1
assert map_1 != map_2
assert map_2 != map_3
assert map_3 != map_4
assert map_2 == map_4
assert hash(map_2) == hash(map_4)
def test_bitmap_indexed_iteration():
map = pmap({"a": 2, "b": 1})
keys = set()
values = set()
count = 0
for k, v in map.iteritems():
count += 1
keys.add(k)
values.add(v)
assert count == 2
assert keys == set(["a", "b"])
assert values == set([2, 1])
def test_evolver_set_with_reallocation_edge_case():
# Demonstrates a bug in evolver that also affects updates. Under certain
# circumstances, the result of `x.update(y)` will **not** have all the
# keys from `y`.
foo = object()
x = pmap({"a": foo}, pre_size=1)
e = x.evolver()
e["b"] = 3000
# Bug is triggered when we do a reallocation and the new value is
# identical to the old one.
e["a"] = foo
y = e.persistent()
assert "b" in y
assert y is e.persistent()
def test_hash_collision_is_correctly_resolved():
dummy1 = HashDummy()
dummy2 = HashDummy()
dummy3 = HashDummy()
dummy4 = HashDummy()
map = pmap({dummy1: 1, dummy2: 2, dummy3: 3})
assert map[dummy1] == 1
assert map[dummy2] == 2
assert map[dummy3] == 3
assert dummy4 not in map
keys = set()
values = set()
for k, v in map.iteritems():
keys.add(k)
values.add(v)
assert keys == set([dummy1, dummy2, dummy3])
assert values == set([1, 2, 3])
map2 = map.set(dummy1, 11)
assert map2[dummy1] == 11
# Re-use existing structure when inserted element is the same
assert map2.set(dummy1, 11) == map2
map3 = map.set("a", 22)
assert map3["a"] == 22
assert map3[dummy3] == 3
# Remove elements
map4 = map.discard(dummy2)
assert len(map4) == 2
assert map4[dummy1] == 1
assert dummy2 not in map4
assert map4[dummy3] == 3
assert map.discard(dummy4) == map
# Empty map handling
empty_map = map4.remove(dummy1).remove(dummy3)
assert len(empty_map) == 0
assert empty_map.discard(dummy1) == empty_map
def test_initialization_with_many_elements():
init_dict = dict([(str(x), x) for x in range(1700)])
the_map = pmap(init_dict)
assert len(the_map) == 1700
assert the_map["16"] == 16
assert the_map["1699"] == 1699
assert the_map.set("256", 256) == the_map
new_map = the_map.remove("1600")
assert len(new_map) == 1699
assert "1600" not in new_map
assert new_map["1601"] == 1601
# Some NOP properties
assert new_map.discard("18888") == new_map
assert "19999" not in new_map
assert new_map["1500"] == 1500
assert new_map.set("1500", new_map["1500"]) == new_map
def test_iteration_with_many_elements():
values = list(range(0, 2000))
keys = [str(x) for x in values]
init_dict = dict(zip(keys, values))
hash_dummy1 = HashDummy()
hash_dummy2 = HashDummy()
# Throw in a couple of hash collision nodes to tests
# those properly as well
init_dict[hash_dummy1] = 12345
init_dict[hash_dummy2] = 54321
map = pmap(init_dict)
actual_values = set()
actual_keys = set()
for k, v in map.iteritems():
actual_values.add(v)
actual_keys.add(k)
assert actual_keys == set(keys + [hash_dummy1, hash_dummy2])
assert actual_values == set(values + [12345, 54321])
def test_overwrite_existing_element():
map1 = pmap({"a": 2})
map2 = map1.set("a", 3)
assert len(map2) == 1
assert map2["a"] == 3
def test_literalish_works():
# assert m() is pmap()
assert m(a=1, b=2) == pmap({"a": 1, "b": 2})
def test_iterable():
"""
PMaps can be created from iterables even though they can't be len() hinted.
"""
assert pmap(iter([("a", "b")])) == pmap([("a", "b")])
def test_map_does_not_hash_values_on_second_hash_invocation():
hashable = HashabilityControlled()
x = pmap(dict(el=hashable))
hash(x)
hashable.hashable = False
hash(x)
def test_pmap_constructor():
container = pmap()
assert len(container) == 0
container = pmap({0: "0", "1": 1, "2": "2"})
assert len(container) == 3
def test_empty_initialization():
map = pmap()
assert len(map) == 0
def test_str():
# assert str(pmap({1: 2, 3: 4})) == "pmap({1: 2, 3: 4})"
assert str(pmap({1: 2})) == "pmap({1: 2})"
def test_get_item():
nodes_container = get_test_nodes_container()
for node in nodes_container:
assert nodes_container[node] == pyrpds.pmap()
def test_get_item():
graph = get_test_graph()
for node in graph:
assert graph[node] == pyrpds.pmap()
