def time(store):
tm = TreeMap()
start = time_ns()
for i in store:
tm.put(i, i)
end = time_ns()
return end - start
def test_get():
m = TreeMap()
# permitsNullKeys=False, permitsNullValues=True, usesIdentity=False
put(m, 'A', True, None)
put(m, 'A', False, True)
put(m, 'B', True, None)
put(m, 'A', False, False)
try:
m.get(None)
pytest.fail('did not reject None key')
except TypeError:
pass
except Exception as e:
print('unexpected exception')
raise e
try:
m.put(None, True)
pytest.fail('did not reject None key')
except TypeError:
pass
except Exception as e:
print('unexpected exception')
raise e
try:
put(m, 'C', None, None)
put(m, 'C', True, None)
put(m, 'C', None, True)
except Exception as e:
print('unexpected exception')
raise e
def test():
m = TreeMap(none_low)
m.put('a', 'A')
m.put('b', 'B')
m.put('c', 'C')
assert m.to_string() == '{a=A, b=B, c=C}'
assert m.head_map('b').to_string() == '{a=A}'
assert m.tail_map('b').to_string() == '{b=B, c=C}'
assert m.head_map(None).to_string() == '{}'
assert m.tail_map(None).to_string() == '{a=A, b=B, c=C}'
m = TreeMap(none_high)
m.put('a', 'A')
m.put('b', 'B')
m.put('c', 'C')
assert m.to_string() == '{a=A, b=B, c=C}'
assert m.head_map('b').to_string() == '{a=A}'
assert m.tail_map('b').to_string() == '{b=B, c=C}'
assert m.head_map(None).to_string() == '{a=A, b=B, c=C}'
assert m.tail_map(None).to_string() == '{}'
m.put(None, 'NONE')
assert m.to_string() == '{a=A, b=B, c=C, None=NONE}'
assert m.head_map('b').to_string() == '{a=A}'
assert m.tail_map('b').to_string() == '{b=B, c=C, None=NONE}'
assert m.head_map(None).to_string() == '{a=A, b=B, c=C}'
assert m.tail_map(None).to_string() == '{None=NONE}'
def make(null_values):
tm = TreeMap()
for each in range(self.TEST_SIZE):
key = self.KEYS[each]
value = ((None if each == 0 else self.VALUES[each])
if null_values else self.VALUES[each])
tm.put(key, value)
return tm
def test():
map = TreeMap()
assert not map.contains_value('haoranpeng')
assert not map.contains_value(None)
map.put('a', None)
map.put('b', 'haoranpeng')
assert map.contains_value('haoranpeng')
assert map.contains_value(None)
def test():
m = TreeMap()
m.put(1, 1)
m.put(2, 2)
m.put(3, 3)
m2 = m.sub_map(2, 2)
with pytest.raises(KeyError):
m2.first_key()
with pytest.raises(KeyError):
m2.last_key()
m3 = m.sub_map(2, 3)
assert m3.first_key() == 2
assert m3.last_key() == 2
def test_map():
map = TreeMap()
for each in range(TEST_SIZE):
map.put(KEYS[each], VALUES[each])
keys = map.key_set().to_list()
keys.sort()
for each in range(TEST_SIZE):
assert keys[each] == KEYS[each]
values = map.values().to_list()
values.sort()
for each in range(TEST_SIZE):
assert values[each] == VALUES[each]
entries = map.entry_set().to_list()
entries.sort(key=lambda e: e.get_key())
for each in range(TEST_SIZE):
assert (entries[each].get_key() == KEYS[each]
and entries[each].get_value() == VALUES[each])
def test_main(self):
m = TreeMap()
self.test_navigable_map_removers(m)
self.test_navigable_map(m)
self.test_navigable_map(m.head_map(6, False))
self.test_navigable_map(m.head_map(5, True))
self.test_navigable_map(m.tail_map(0, False))
self.test_navigable_map(m.tail_map(1, True))
self.test_navigable_map(m.sub_map(1, 6, True, False))
self.test_navigable_map(m.sub_map(0, 5, False, True))
self.check_functional_invariants(m)
m.clear()
assert m.put(3333, 77777) is None
assert m.put(9134, 74982) is None
assert m.get(9134) == 74982
assert m.put(9134, 1382) == 74982
assert m.get(9134) == 1382
assert m.size() == 2
self.check_functional_invariants(m)
def test():
m1 = TreeMap(none_at_end)
assert m1.put('a', 'a') is None
assert m1.put('b', 'b') is None
assert m1.put('c', 'c') is None
assert m1.put(None, 'd') is None
m2 = TreeMap(none_at_end)
m2.put_all(m1)
assert m1.last_key() is None
assert m1.get(m1.last_key()) == 'd'
assert m1.remove(m1.last_key()) == 'd'
assert m1.last_key() == 'c'
assert m2.entry_set().to_string() == '[a=a, b=b, c=c, None=d]'
m3 = m2.tail_map('b')
assert m3.last_key() is None
assert m3.get(m3.last_key()) == 'd'
assert m3.remove(m3.last_key()) == 'd'
assert m3.last_key() == 'c'
#!/usr/bin/env python
import pytest
from pytreemap import TreeMap
__author__ = 'Haoran Peng'
__email__ = '*****@*****.**'
__license__ = 'GPL-2.0'
m = TreeMap()
for i in range(18):
m.put(i, i)
@pytest.mark.parametrize('c', [m.values(), m.key_set(), m.entry_set()])
def test(c):
it = iter(c)
with pytest.raises(StopIteration):
while True:
next(it)
def test():
comparable = TreeMap()
with pytest.raises(TypeError):
comparable.put(None, 'anything')
comparable.put('test', 'anything')
with pytest.raises(TypeError):
comparable.put(None, 'anything')
def case_insensitive_order(a, b):
x, y = a.lower(), b.lower()
if x < y:
return -1
elif x > y:
return 1
else:
return 0
comparator = TreeMap(case_insensitive_order)
with pytest.raises(Exception):
comparator.put(None, 'anything')
comparator.put('test', 'anything')
with pytest.raises(Exception):
comparator.put(None, 'anything')
comparator.clear()
with pytest.raises(Exception):
comparator.put(object(), 'anything')
