| # Check every path through every method of UserList |
| |
| from UserList import UserList |
| from test_support import TestFailed |
| |
| # Use check instead of assert so -O doesn't render the |
| # test useless. |
| # XXX: could use the verify function in test_support instead |
| def check(predicate, msg): |
| if not predicate: |
| raise TestFailed(msg + " failed") |
| |
| l0 = [] |
| l1 = [0] |
| l2 = [0, 1] |
| |
| # Test constructors |
| |
| u = UserList() |
| u0 = UserList(l0) |
| u1 = UserList(l1) |
| u2 = UserList(l2) |
| |
| uu = UserList(u) |
| uu0 = UserList(u0) |
| uu1 = UserList(u1) |
| uu2 = UserList(u2) |
| |
| v = UserList(tuple(u)) |
| class OtherList: |
| def __init__(self, initlist): |
| self.__data = initlist |
| def __len__(self): |
| return len(self.__data) |
| def __getitem__(self, i): |
| return self.__data[i] |
| v0 = UserList(OtherList(u0)) |
| vv = UserList("this is also a sequence") |
| |
| # Test __repr__ |
| |
| check(str(u0) == str(l0), "str(u0) == str(l0)") |
| check(repr(u1) == repr(l1), "repr(u1) == repr(l1)") |
| check(`u2` == `l2`, "`u2` == `l2`") |
| |
| # Test __cmp__ and __len__ |
| |
| def mycmp(a, b): |
| r = cmp(a, b) |
| if r < 0: return -1 |
| if r > 0: return 1 |
| return r |
| |
| all = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2] |
| for a in all: |
| for b in all: |
| check(mycmp(a, b) == mycmp(len(a), len(b)), |
| "mycmp(a, b) == mycmp(len(a), len(b))") |
| |
| # Test __getitem__ |
| |
| for i in range(len(u2)): |
| check(u2[i] == i, "u2[i] == i") |
| |
| # Test __setitem__ |
| |
| uu2[0] = 0 |
| uu2[1] = 100 |
| try: |
| uu2[2] = 200 |
| except IndexError: |
| pass |
| else: |
| raise TestFailed("uu2[2] shouldn't be assignable") |
| |
| # Test __delitem__ |
| |
| del uu2[1] |
| del uu2[0] |
| try: |
| del uu2[0] |
| except IndexError: |
| pass |
| else: |
| raise TestFailed("uu2[0] shouldn't be deletable") |
| |
| # Test __getslice__ |
| |
| for i in range(-3, 4): |
| check(u2[:i] == l2[:i], "u2[:i] == l2[:i]") |
| check(u2[i:] == l2[i:], "u2[i:] == l2[i:]") |
| for j in range(-3, 4): |
| check(u2[i:j] == l2[i:j], "u2[i:j] == l2[i:j]") |
| |
| # Test __setslice__ |
| |
| for i in range(-3, 4): |
| u2[:i] = l2[:i] |
| check(u2 == l2, "u2 == l2") |
| u2[i:] = l2[i:] |
| check(u2 == l2, "u2 == l2") |
| for j in range(-3, 4): |
| u2[i:j] = l2[i:j] |
| check(u2 == l2, "u2 == l2") |
| |
| uu2 = u2[:] |
| uu2[:0] = [-2, -1] |
| check(uu2 == [-2, -1, 0, 1], "uu2 == [-2, -1, 0, 1]") |
| uu2[0:] = [] |
| check(uu2 == [], "uu2 == []") |
| |
| # Test __contains__ |
| for i in u2: |
| check(i in u2, "i in u2") |
| for i in min(u2)-1, max(u2)+1: |
| check(i not in u2, "i not in u2") |
| |
| # Test __delslice__ |
| |
| uu2 = u2[:] |
| del uu2[1:2] |
| del uu2[0:1] |
| check(uu2 == [], "uu2 == []") |
| |
| uu2 = u2[:] |
| del uu2[1:] |
| del uu2[:1] |
| check(uu2 == [], "uu2 == []") |
| |
| # Test __add__, __radd__, __mul__ and __rmul__ |
| |
| check(u1 + [] == [] + u1 == u1, "u1 + [] == [] + u1 == u1") |
| check(u1 + [1] == u2, "u1 + [1] == u2") |
| check([-1] + u1 == [-1, 0], "[-1] + u1 == [-1, 0]") |
| check(u2 == u2*1 == 1*u2, "u2 == u2*1 == 1*u2") |
| check(u2+u2 == u2*2 == 2*u2, "u2+u2 == u2*2 == 2*u2") |
| check(u2+u2+u2 == u2*3 == 3*u2, "u2+u2+u2 == u2*3 == 3*u2") |
| |
| # Test append |
| |
| u = u1[:] |
| u.append(1) |
| check(u == u2, "u == u2") |
| |
| # Test insert |
| |
| u = u2[:] |
| u.insert(0, -1) |
| check(u == [-1, 0, 1], "u == [-1, 0, 1]") |
| |
| # Test pop |
| |
| u = [-1] + u2 |
| u.pop() |
| check(u == [-1, 0], "u == [-1, 0]") |
| u.pop(0) |
| check(u == [0], "u == [0]") |
| |
| # Test remove |
| |
| u = u2[:] |
| u.remove(1) |
| check(u == u1, "u == u1") |
| |
| # Test count |
| u = u2*3 |
| check(u.count(0) == 3, "u.count(0) == 3") |
| check(u.count(1) == 3, "u.count(1) == 3") |
| check(u.count(2) == 0, "u.count(2) == 0") |
| |
| |
| # Test index |
| |
| check(u2.index(0) == 0, "u2.index(0) == 0") |
| check(u2.index(1) == 1, "u2.index(1) == 1") |
| try: |
| u2.index(2) |
| except ValueError: |
| pass |
| else: |
| raise TestFailed("expected ValueError") |
| |
| # Test reverse |
| |
| u = u2[:] |
| u.reverse() |
| check(u == [1, 0], "u == [1, 0]") |
| u.reverse() |
| check(u == u2, "u == u2") |
| |
| # Test sort |
| |
| u = UserList([1, 0]) |
| u.sort() |
| check(u == u2, "u == u2") |
| |
| # Test extend |
| |
| u = u1[:] |
| u.extend(u2) |
| check(u == u1 + u2, "u == u1 + u2") |