def testdup_compare(self):
for i in range(5):
t = random_pair_tree(0, self.n, size=self.n, compare=pair_compare)
u = avl.new(t)
v = t[:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u, pair_compare))
self.assertTrue(v.verify() == 1)
self.assertTrue(equal_tree(t, v, pair_compare))
t = avl.new(compare=pair_compare)
u = avl.new(t)
self.assertTrue(verify_empty(u))
def testdup_basic(self):
for i in range(10):
t = random_int_tree(0, self.n, size=self.n)
u = avl.new(t)
v = t[:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
self.assertTrue(v.verify() == 1)
self.assertTrue(equal_tree(t, v))
t = avl.new()
u = avl.new(t)
self.assertTrue(verify_empty(u))
def testdup_compare(self):
for i in range(5):
t = random_pair_tree(0, self.n, size=self.n, compare=pair_compare)
u = avl.new(t)
v = t[:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u, pair_compare))
self.assertTrue(v.verify() == 1)
self.assertTrue(equal_tree(t, v, pair_compare))
t = avl.new(compare=pair_compare)
u = avl.new(t)
self.assertTrue(verify_empty(u))
def testdup_basic(self):
for i in range(10):
t = random_int_tree(0, self.n, size=self.n)
u = avl.new(t)
v = t[:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
self.assertTrue(v.verify() == 1)
self.assertTrue(equal_tree(t, v))
t = avl.new()
u = avl.new(t)
self.assertTrue(verify_empty(u))
def testnew_compare_basic(self):
random.shuffle(self.list)
pairs = [(i, 0) for i in self.list]
for i in range(self._times):
t = avl.new(pairs, compare=pair_compare)
self.assertTrue(verify_len(t, self.size))
for p in pairs:
self.assertTrue(p in t)
def testnew_basic(self):
for i in range(self._times):
random.shuffle(self.list)
t = avl.new(self.list, unique=0)
self.assertTrue(t.verify() == 1 and len(t) == self.size)
for n in self.list:
self.assertTrue(n in t)
t = None
def testnew_basic(self):
for i in range(self._times):
random.shuffle(self.list)
t = avl.new(self.list, unique=0)
self.assertTrue(t.verify() == 1 and len(t) == self.size)
for n in self.list:
self.assertTrue(n in t)
t = None
def testnew_compare_basic(self):
random.shuffle(self.list)
pairs = [(i, 0) for i in self.list]
for i in range(self._times):
t = avl.new(pairs, compare=pair_compare)
self.assertTrue(verify_len(t, self.size))
for p in pairs:
self.assertTrue(p in t)
def testnew_basic_unique(self):
for i in range(self._times):
random.shuffle(self.list)
list3 = self.list * 3
t = avl.new(list3, unique=1)
self.assertTrue(verify_len(t, self.size))
for n in self.list:
self.assertTrue(n in t)
t = None
def testnew_compare_unique(self):
random.shuffle(self.list)
tuples = [(i, 0) for i in self.list]
tuples3 = tuples * 3
for i in range(self._times):
t = avl.new(tuples3, compare=pair_compare, unique=1)
self.assertTrue(verify_len(t, self.size))
for u in tuples:
self.assertTrue(u in t)
def testnew_compare_unique(self):
random.shuffle(self.list)
tuples = [(i, 0) for i in self.list]
tuples3 = tuples * 3
for i in range(self._times):
t = avl.new(tuples3, compare=pair_compare, unique=1)
self.assertTrue(verify_len(t, self.size))
for u in tuples:
self.assertTrue(u in t)
def testins_bad(self):
t = avl.new([(5, 6), (2, 8), (7, -1), (-1, 1), (2, -3)],
compare=pair_compare)
for i in range(5):
self.assertRaises(TypeError, t.insert, 66)
self.assertRaises(TypeError, t.has_key, 66)
self.assertFalse(66 in t)
t.insert((3, 3))
self.assertTrue(t.verify() == 1)
def testdel_lessbasic(self):
n = 1000
t = avl.new()
for i in range(3):
for k in gen_ints(0, n):
t.insert(k)
self.assertTrue(t.verify() == 1)
# params for sequence
modulo = n
step = 37
for i in range(10):
u = avl.new(t)
for k in gen_ints_perm(step, modulo):
while k in u:
u.remove(k)
self.assertFalse(k in u)
self.assertTrue(u.verify() == 1)
self.assertTrue(len(u) == 0, 'len='+str(len(u))+' '+str(u))
def testdel_lessbasic(self):
n = 1000
t = avl.new()
for i in range(3):
for k in gen_ints(0, n):
t.insert(k)
self.assertTrue(t.verify() == 1)
# params for sequence
modulo = n
step = 37
for i in range(10):
u = avl.new(t)
for k in gen_ints_perm(step, modulo):
while k in u:
u.remove(k)
self.assertFalse(k in u)
self.assertTrue(u.verify() == 1)
self.assertTrue(len(u) == 0, 'len=' + str(len(u)) + ' ' + str(u))
def testins_bad(self):
t = avl.new([(5, 6), (2, 8), (7, -1), (-1, 1), (2, -3)],
compare=pair_compare)
for i in range(5):
self.assertRaises(TypeError, t.insert, 66)
self.assertRaises(TypeError, t.has_key, 66)
self.assertFalse(66 in t)
t.insert((3, 3))
self.assertTrue(t.verify() == 1)
def testnew_basic_unique(self):
for i in range(self._times):
random.shuffle(self.list)
list3 = self.list * 3
t = avl.new(list3, unique=1)
self.assertTrue(verify_len(t, self.size))
for n in self.list:
self.assertTrue(n in t)
t = None
def testnew_compare_dupes(self):
random.shuffle(self.list)
pairs = [(i, 0) for i in self.list]
pairs3 = pairs * 3
size3 = self.size * 3
for i in range(self._times):
t = avl.new(pairs3, compare=pair_compare, unique=0)
self.assertTrue(verify_len(t, size3))
for p in pairs:
self.assertTrue(p in t)
def testnew_compare_dupes(self):
random.shuffle(self.list)
pairs = [(i, 0) for i in self.list]
pairs3 = pairs * 3
size3 = self.size * 3
for i in range(self._times):
t = avl.new(pairs3, compare=pair_compare, unique=0)
self.assertTrue(verify_len(t, size3))
for p in pairs:
self.assertTrue(p in t)
def testseq_spaninsert(self):
n = 5000
t = avl.new(compare=lambda x, y: cmp(y, x))
for i in range(2):
for i in gen_ints(0, 3*n):
e = random.randint(-n, n)
a1, a2 = t.span(e)
t.insert(e, a2)
self.assertTrue(t.span(e) == (a1, a2+1))
self.assertTrue(verify_len(t, 3*n))
t.clear()
def testseq_spaninsert(self):
n = 5000
t = avl.new(compare=lambda x, y: cmp(y, x))
for i in range(2):
for i in gen_ints(0, 3 * n):
e = random.randint(-n, n)
a1, a2 = t.span(e)
t.insert(e, a2)
self.assertTrue(t.span(e) == (a1, a2 + 1))
self.assertTrue(verify_len(t, 3 * n))
t.clear()
def testseq_sliceconcat(self):
n = 2000
e = avl.new()
t = range_tree(0, n)
self.assertTrue(verify_empty(e+e))
self.assertTrue(equal_tree(t+e, t))
self.assertTrue(equal_tree(e+t, t))
for a in gen_ints_perm(50, n):
u = t[:a] + t[a:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
u = None
def testdump_compare(self):
t = avl.new(self.list1, compare=revlowercmp)
for proto in [0, 2]:
f = BytesIO()
p = pickle.Pickler(f, proto)
t.dump(p)
f.seek(0)
p = pickle.Unpickler(f)
u = avl.load(p)
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
f.close()
def testdump_compare(self):
t = avl.new(self.list1, compare=revlowercmp)
for proto in [0, 2]:
f = BytesIO()
p = pickle.Pickler(f, proto)
t.dump(p)
f.seek(0)
p = pickle.Unpickler(f)
u = avl.load(p)
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
f.close()
def testseq_sliceconcat(self):
n = 2000
e = avl.new()
t = range_tree(0, n)
self.assertTrue(verify_empty(e + e))
self.assertTrue(equal_tree(t + e, t))
self.assertTrue(equal_tree(e + t, t))
for a in gen_ints_perm(50, n):
u = t[:a] + t[a:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
u = None
def testseq_index(self):
t = avl.new()
n = 5000
for r in range(3):
for i in range(3):
for k in gen_ints_perm(11, n):
t.insert(k)
self.assertTrue(verify_len(t, n*3))
for i in gen_ints(0, n):
self.assertTrue(t.index(i) == i*3)
a, b = t.span(i)
self.assertTrue((a == i*3) and (b-a == 3))
t.clear()
def testseq_insert(self):
n = 5000
t = avl.new()
self.assertRaises(IndexError, t.insert, 'out', 1)
self.assertRaises(IndexError, t.insert, 'out', -13)
for i in gen_ints_perm(373, n):
t.insert(2 * i)
self.assertTrue(t.verify() == 1)
for i in range(3):
u = avl.new(t)
for k in gen_ints(0, n):
odd = 2 * k + 1
u.insert(odd, odd)
self.assertTrue(u[odd] == odd)
self.assertTrue(u.verify() == 1)
self.assertTrue(len(u) == 2 * n)
for i in range(100):
u.append(2 * n)
for i in range(100):
u.insert(0, 0)
self.assertTrue(u.verify() == 1)
list = None # noqa
def testseq_insert(self):
n = 5000
t = avl.new()
self.assertRaises(IndexError, t.insert, 'out', 1)
self.assertRaises(IndexError, t.insert, 'out', -13)
for i in gen_ints_perm(373, n):
t.insert(2*i)
self.assertTrue(t.verify() == 1)
for i in range(3):
u = avl.new(t)
for k in gen_ints(0, n):
odd = 2*k+1
u.insert(odd, odd)
self.assertTrue(u[odd] == odd)
self.assertTrue(u.verify() == 1)
self.assertTrue(len(u) == 2*n)
for i in range(100):
u.append(2*n)
for i in range(100):
u.insert(0, 0)
self.assertTrue(u.verify() == 1)
list = None # noqa
def testseq_concatinplace(self):
self.assertRaises(TypeError, avl.new().concat, [])
n = 2000
e = avl.new()
t = range_tree(0, n)
u = t[:]
u.concat(e)
self.assertTrue(equal_tree(t, u))
e.concat(u)
self.assertTrue(equal_tree(e, u))
u += avl.new()
self.assertTrue(equal_tree(t, u))
e.clear()
e += t
self.assertTrue(equal_tree(e, t))
e.clear()
for a in gen_ints_perm(100, n):
u = t[:a]
u += t[a:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
u = None
def testseq_concatinplace(self):
self.assertRaises(TypeError, avl.new().concat, [])
n = 2000
e = avl.new()
t = range_tree(0, n)
u = t[:]
u.concat(e)
self.assertTrue(equal_tree(t, u))
e.concat(u)
self.assertTrue(equal_tree(e, u))
u += avl.new()
self.assertTrue(equal_tree(t, u))
e.clear()
e += t
self.assertTrue(equal_tree(e, t))
e.clear()
for a in gen_ints_perm(100, n):
u = t[:a]
u += t[a:]
self.assertTrue(u.verify() == 1)
self.assertTrue(equal_tree(t, u))
u = None
def testseq_index(self):
t = avl.new()
n = 5000
for r in range(3):
for i in range(3):
for k in gen_ints_perm(11, n):
t.insert(k)
self.assertTrue(verify_len(t, n * 3))
for i in gen_ints(0, n):
self.assertTrue(t.index(i) == i * 3)
a, b = t.span(i)
self.assertTrue((a == i * 3) and (b - a == 3))
t.clear()
def testiter_remove(self):
for start in range(1, self.n+1):
u = avl.new(self.t)
self.assertTrue(u.verify() == 1)
j = iter(u)
for i in range(start):
next(j)
index = j.index()
self.assertTrue(index == start-1)
while index < len(u):
j.remove()
# self.assertTrue(u.verify() == 1)
self.assertTrue(j.index() == index)
self.assertRaises(avl.Error, j.remove)
self.assertTrue(u.verify() == 1)
def testiter_remove(self):
for start in range(1, self.n + 1):
u = avl.new(self.t)
self.assertTrue(u.verify() == 1)
j = iter(u)
for i in range(start):
next(j)
index = j.index()
self.assertTrue(index == start - 1)
while index < len(u):
j.remove()
# self.assertTrue(u.verify() == 1)
self.assertTrue(j.index() == index)
self.assertRaises(avl.Error, j.remove)
self.assertTrue(u.verify() == 1)
def testdel_basic(self):
t = avl.new()
t.remove(1)
t.remove(-2)
self.assertTrue(verify_empty(t))
t = range_tree(-2000, +2000)
self.assertTrue(t.verify() == 1)
n = len(t)
# no-op
others = list(range(-2100, -2000)) + list(range(2000, 2100))
random.shuffle(others)
for i in others:
t.remove(i)
self.assertTrue(verify_len(t, n))
others = None
# empty trees
lst = list(range(-2000, 2000))
for i in range(10):
random.shuffle(lst)
u = avl.new(t)
for k in lst:
u.remove(k)
self.assertFalse(k in u)
self.assertTrue(verify_empty(u))
def testdel_basic(self):
t = avl.new()
t.remove(1)
t.remove(-2)
self.assertTrue(verify_empty(t))
t = range_tree(-2000, +2000)
self.assertTrue(t.verify() == 1)
n = len(t)
# no-op
others = list(range(-2100, -2000)) + list(range(2000, 2100))
random.shuffle(others)
for i in others:
t.remove(i)
self.assertTrue(verify_len(t, n))
others = None
# empty trees
lst = list(range(-2000, 2000))
for i in range(10):
random.shuffle(lst)
u = avl.new(t)
for k in lst:
u.remove(k)
self.assertFalse(k in u)
self.assertTrue(verify_empty(u))
def testseq_removedupes(self):
n = 2500
steps = [501, 7, 1003, 1863]
repeats = len(steps)
t = avl.new()
for step in steps:
for k in gen_ints_perm(step, n):
t.insert(k)
for k in gen_ints_perm(1209, n):
a, b = t.span(k)
self.assertTrue(b - a == repeats)
self.assertTrue(a == 0 or t[a - 1] < k)
self.assertTrue(b == len(t) or t[b] > k)
for i in range(repeats):
t.remove_at(a)
self.assertTrue(t.span(k) == (a, a))
self.assertTrue(verify_empty(t))
def testseq_removedupes(self):
n = 2500
steps = [501, 7, 1003, 1863]
repeats = len(steps)
t = avl.new()
for step in steps:
for k in gen_ints_perm(step, n):
t.insert(k)
for k in gen_ints_perm(1209, n):
a, b = t.span(k)
self.assertTrue(b-a == repeats)
self.assertTrue(a == 0 or t[a-1] < k)
self.assertTrue(b == len(t) or t[b] > k)
for i in range(repeats):
t.remove_at(a)
self.assertTrue(t.span(k) == (a, a))
self.assertTrue(verify_empty(t))
def testseq_basic(self):
t = avl.new()
for step, modulo in [(491, 2000), (313, 10000)]:
for i in gen_ints_perm(step, modulo):
t.insert(i)
for i in gen_ints(0, modulo):
self.assertTrue(t.index(i) == i)
self.assertTrue(t[i] == i)
self.assertTrue(t[-i - 1] == t[modulo - i - 1])
for i in gen_ints(-100, 0):
self.assertTrue(t.index(i) == -1)
for i in gen_ints(modulo, modulo + 100):
self.assertTrue(t.index(i) == -1)
t.clear()
self.assertRaises(IndexError, self.geti, t, 11)
self.assertRaises(IndexError, self.geti, t, -5)
def testseq_basic(self):
t = avl.new()
for step, modulo in [(491, 2000), (313, 10000)]:
for i in gen_ints_perm(step, modulo):
t.insert(i)
for i in gen_ints(0, modulo):
self.assertTrue(t.index(i) == i)
self.assertTrue(t[i] == i)
self.assertTrue(t[-i-1] == t[modulo-i-1])
for i in gen_ints(-100, 0):
self.assertTrue(t.index(i) == -1)
for i in gen_ints(modulo, modulo+100):
self.assertTrue(t.index(i) == -1)
t.clear()
self.assertRaises(IndexError, self.geti, t, 11)
self.assertRaises(IndexError, self.geti, t, -5)
def testiter_basic(self):
t = avl.new()
j = iter(t) # before first
k = t.iter(1) # after last
self.assertRaises(StopIteration, j.__next__)
self.assertRaises(StopIteration, j.prev)
self.assertRaises(StopIteration, k.__next__)
self.assertRaises(StopIteration, k.prev)
t.insert('bb')
self.assertRaises(StopIteration, j.prev)
self.assertRaises(StopIteration, k.__next__)
self.assertTrue(next(j) == 'bb')
self.assertTrue(k.prev() == 'bb')
self.assertRaises(StopIteration, j.__next__)
self.assertRaises(StopIteration, k.prev)
self.assertTrue(j.prev() == 'bb')
self.assertTrue(next(k) == 'bb')
self.assertTrue(j.cur() == 'bb' and k.cur() == 'bb')
t.insert('aa')
self.assertTrue(j.prev() == 'aa')
t.insert('cc')
self.assertTrue(next(k) == 'cc')
def testiter_basic(self):
t = avl.new()
j = iter(t) # before first
k = t.iter(1) # after last
self.assertRaises(StopIteration, j.__next__)
self.assertRaises(StopIteration, j.prev)
self.assertRaises(StopIteration, k.__next__)
self.assertRaises(StopIteration, k.prev)
t.insert('bb')
self.assertRaises(StopIteration, j.prev)
self.assertRaises(StopIteration, k.__next__)
self.assertTrue(next(j) == 'bb')
self.assertTrue(k.prev() == 'bb')
self.assertRaises(StopIteration, j.__next__)
self.assertRaises(StopIteration, k.prev)
self.assertTrue(j.prev() == 'bb')
self.assertTrue(next(k) == 'bb')
self.assertTrue(j.cur() == 'bb' and k.cur() == 'bb')
t.insert('aa')
self.assertTrue(j.prev() == 'aa')
t.insert('cc')
self.assertTrue(next(k) == 'cc')
def random_pair_tree(lo, hi, size=1000, compare=None):
t = avl.new(compare=compare)
for i in gen_ints(0, size):
t.insert((random.randint(lo, hi-1), 0))
return t
def testfrom_iter_compare(self):
a = self.list1 + [string.lower(s) for s in self.list1]
t = avl.new(a, unique=0, compare=revlowercmp)
u = avl.from_iter(iter(t), len(t), compare=revlowercmp)
self.assertTrue(u.verify() == 1)
def random_pair_tree(lo, hi, size=1000, compare=None):
t = avl.new(compare=compare)
for i in gen_ints(0, size):
t.insert((random.randint(lo, hi - 1), 0))
return t
def testfrom_iter_compare(self):
a = self.list1 + [string.lower(s) for s in self.list1]
t = avl.new(a, unique=0, compare=revlowercmp)
u = avl.from_iter(iter(t), len(t), compare=revlowercmp)
self.assertTrue(u.verify() == 1)
def range_tree(lo, hi, compare=None):
t = avl.new(compare=compare)
for i in gen_ints(lo, hi):
t.insert(i)
return t
def testiter_forloop(self):
list = self.orig[:]
for i in range(5):
random.shuffle(list)
for k in avl.new(list):
self.assertTrue(k == self.orig[k])
def testiter_forloop(self):
list = self.orig[:]
for i in range(5):
random.shuffle(list)
for k in avl.new(list):
self.assertTrue(k == self.orig[k])
def range_tree(lo, hi, compare=None):
t = avl.new(compare=compare)
for i in gen_ints(lo, hi):
t.insert(i)
return t