in subversion/bindings/ctypes-python/csvn/ext/listmixin.py [0:0]
def test_list_mixin(list_class=TestList, rand_elem=None):
"""
Unit test for ListMixin.
"""
if list_class is TestList:
L1 = TestList()
L2 = TestList()
L3 = TestList()
L1.extend([L1, L2, L3])
L2.append(L3)
L3.append(L1)
assert (repr(L1) == 'TestList([TestList(...), TestList([TestList'+
'([TestList(...)])]), TestList([TestList(...)])])')
L1 = TestList()
L1.append(L1)
L2 = copy.deepcopy(L1)
assert id(L1) == id(L1[0])
assert id(L2) == id(L2[0])
L3 = copy.copy(L2)
assert id(L3) != id(L3[0])
assert id(L3[0]) == id(L2[0]) == id(L2)
if rand_elem is None:
def rand_elem():
return random.randrange(50)
def get_or_none(obj, getindex):
try:
return obj[getindex]
except IndexError:
return None
def set_or_none(obj, setindex, setvalue):
try:
obj[setindex] = setvalue
return setvalue
except IndexError:
return None
def extended_set_or_none(obj, setindex, setvalue):
try:
obj[setindex] = setvalue
return setvalue
except ValueError:
return None
def insert_or_none(obj, insertindex, insertvalue):
try:
obj.insert(insertindex, insertvalue)
except IndexError:
return None
def pop_or_none(obj, *popargs):
try:
obj.pop(*popargs)
except IndexError:
return None
def remove_or_none(obj, removevalue):
try:
obj.remove(removevalue)
except IndexError:
return None
import random
import sys
for i in [1, 3, 8, 16, 18, 29, 59, 111, 213, 501, 1013,
2021, 3122, 4039, 5054]:
x = [rand_elem() for j in range(i)]
y = list_class(x)
assert isinstance(y[:], list_class)
assert isinstance(y[:5], list_class)
assert isinstance(y[:5:2], list_class)
for j in range(100):
r = random.randrange(13)
if r == 0:
# Set element at a random index
if len(x) != 0:
k = random.randrange(-2*len(x),2*len(x))
v = rand_elem()
assert set_or_none(x, k, v) == set_or_none(y, k, v)
elif r == 1:
# Delete element at random index
if len(x) != 0:
k = random.randrange(len(x))
del x[k]
del y[k]
elif r == 2:
# In place add some elements
addelems = [rand_elem() for inx in range(random.randrange(4))]
x += addelems
y += addelems
elif r == 3:
# In place add an element
addelem = rand_elem()
x.append(addelem)
y.append(addelem)
elif r == 4:
# In place add some elements
addelems = [rand_elem() for inx in range(random.randrange(4))]
x += addelems
y += addelems
elif r == 5:
# Insert an element
addelem = rand_elem()
insertidx = random.randrange(-2*len(x), 2*len(x)+1)
assert insert_or_none(x, insertidx, addelem) == \
insert_or_none(y, insertidx, addelem)
elif r == 6:
# Pop an element
popidx = random.randrange(-2*len(x), 2*len(x)+1)
assert pop_or_none(x, popidx) == pop_or_none(y, popidx)
elif r == 7:
# Pop last element
assert pop_or_none(x) == pop_or_none(y)
elif r == 8:
# Remove an element
if len(x) != 0:
remvalue = random.choice(x)
assert remove_or_none(x, remvalue) == remove_or_none(y, remvalue)
elif r == 9:
if random.randrange(5) == 0:
# Sort
if sys.version_info[:3] >= (2, 4, 0):
r2 = random.randrange(6)
else:
r2 = random.randrange(2)
def keyfunc(keyitem):
return (keyitem - 5) ** 2
def cmpfunc(a, b):
return cmp((a+9)**2, (b-5)**3)
if r2 == 0:
x.sort()
y.sort()
elif r2 == 1:
x.sort(cmpfunc)
y.sort(cmpfunc)
elif r2 == 2:
x.sort(cmpfunc, keyfunc)
y.sort(cmpfunc, keyfunc)
elif r2 == 3:
x.sort(cmpfunc, keyfunc, True)
y.sort(cmpfunc, keyfunc, True)
elif r2 == 4:
x.sort(cmpfunc, reverse=True)
y.sort(cmpfunc, reverse=True)
elif r2 == 5:
x.sort(None, keyfunc, True)
y.sort(None, keyfunc, True)
elif r == 10:
# Remove a slice
start = random.randrange(-2*len(x), 2*len(x)+1)
end = random.randrange(-2*len(x), 2*len(x)+1)
step = random.randrange(-2*len(x), 2*len(x)+1)
r2 = random.randrange(3)
if r2 == 0:
step = random.randrange(-5, 5)
elif r2 == 1:
step = 1
if step == 0:
step = 1
del x[start:end:step]
del y[start:end:step]
elif r == 11:
# Assign to a regular slice
start = random.randrange(-2*len(x), 2*len(x)+1)
end = random.randrange(-2*len(x), 2*len(x)+1)
assignval = [rand_elem() for assignidx in
range(random.randrange(10))]
x[start:end] = assignval
y[start:end] = assignval
elif r == 12:
# Assign to an extended slice
start = random.randrange(-2*len(x), 2*len(x)+1)
end = random.randrange(-2*len(x), 2*len(x)+1)
step = random.randrange(-2*len(x), 2*len(x)+1)
r2 = random.randrange(3)
if r2 == 0:
step = random.randrange(-5, 5)
elif r2 == 1:
step = 1
if step == 0:
step = 1
if step == 1:
step = 2
indices = list(range(*slice(start, end, step).indices(len(x))))
assignval = [rand_elem() for assignidx in
indices]
if random.randrange(2) == 0:
# Make right hand value have incorrect length
if random.randrange(2) == 0 and len(assignval) > 0:
if random.randrange(2) == 0:
assignval.pop()
else:
assignval = []
else:
assignval.append(1)
assert (extended_set_or_none(x, slice(start, end, step), assignval) ==
extended_set_or_none(y, slice(start, end, step), assignval))
# Check that x == y in a variety of ways.
if len(x) != 0:
for i4 in range(20):
i3 = random.randrange(-2*len(x), 2*len(x))
assert get_or_none(x, i3) == get_or_none(y, i3)
assert list(iter(x)) == list(iter(y))
assert list(iter(iter(x))) == list(iter(iter(y)))
assert str(x) == str(y)
assert x + [1,2] == y + [1,2]
assert x * 0 == y * 0
assert x * -1 == y * -1
assert x * -5000 == y * -5000
assert x * 1 == y * 1
assert x * 2 == y * 2
assert isinstance(x + y, list)
assert x + y == x + list(y)
elems = set(x)
elems2 = set(y)
assert elems == elems2
def index_or_none(obj, search, *args):
try:
return obj.index(search, *args)
except ValueError:
return None
for key in elems:
assert x.count(key) == y.count(key)
assert index_or_none(x, key) == index_or_none(y, key)
i1 = random.randrange(-len(x)-2,len(x)+2)
i2 = random.randrange(-len(x)-2,len(x)+2)
assert index_or_none(x, key, i1, i2) == \
index_or_none(y, key, i1, i2)
assert x[:] == y[:]
# Get slices
for sliceidx in range(10):
if len(x) != 0:
start = random.randrange(-2*len(x), 2*len(x)+1)
end = random.randrange(-2*len(x), 2*len(x)+1)
step = random.randrange(-2*len(x), 2*len(x))
r2 = random.randrange(3)
if r2 == 0:
step = random.randrange(-5, 5)
elif r2 == 1:
step = 1
if step == 0:
step = 1
assert x[start:end:step] == y[start:end:step]
assert cmp(x, y) == 0
assert len(x) == len(y)
assert x == y
x.reverse()
y.reverse()
assert x == y
x.reverse()
y.reverse()
for k in range(len(x)):
assert x[k] == y[k]