ben
/
mwparserfromhell
mirror of https://github.com/earwig/mwparserfromhell
1
1
Fork 0
Code Releases 24 Activity
Browse Source

Unit tests for several SmartList slice bugs 

See https://github.com/earwig/mwparserfromhell/issues/226

Also added tests for step != 1
pull/227/head
Yuri Astrakhan 4 years ago
parent
3fcbe7b404
commit
2ffd3d1ddb
1 changed files with 223 additions and 126 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +223
    -126
      tests/test_smart_list.py

+ 223
- 126
tests/test_smart_list.py View File

@@ -21,18 +21,21 @@
# SOFTWARE.

from __future__ import unicode_literals

import unittest

from mwparserfromhell.compat import py3k, range
from mwparserfromhell.smart_list import SmartList, _ListProxy


class TestSmartList(unittest.TestCase):
"""Test cases for the SmartList class and its child, _ListProxy."""

def _test_get_set_del_item(self, builder):
def _test_get_set_del_item(self, builder, assertEqualIter):
"""Run tests on __get/set/delitem__ of a list built with *builder*."""
def assign(L, s1, s2, s3, val):
L[s1:s2:s3] = val

def delete(L, s1):
del L[s1]

@@ -41,48 +44,48 @@ class TestSmartList(unittest.TestCase):

self.assertEqual(1, list1[1])
self.assertEqual("one", list1[-2])
self.assertEqual([2, 3], list1[2:4])
assertEqualIter([2, 3], list1[2:4])
self.assertRaises(IndexError, lambda: list1[6])
self.assertRaises(IndexError, lambda: list1[-7])

self.assertEqual([0, 1, 2], list1[:3])
self.assertEqual([0, 1, 2, 3, "one", "two"], list1[:])
self.assertEqual([3, "one", "two"], list1[3:])
self.assertEqual([3, "one", "two"], list1[3:100])
self.assertEqual(["one", "two"], list1[-2:])
self.assertEqual([0, 1], list1[:-4])
self.assertEqual([], list1[6:])
self.assertEqual([], list1[4:2])
self.assertEqual([0, 2, "one"], list1[0:5:2])
self.assertEqual([0, 2], list1[0:-3:2])
self.assertEqual([0, 1, 2, 3, "one", "two"], list1[::])
self.assertEqual([2, 3, "one", "two"], list1[2::])
self.assertEqual([0, 1, 2, 3], list1[:4:])
self.assertEqual([2, 3], list1[2:4:])
self.assertEqual([0, 2, 4, 6, 8], list2[::2])
self.assertEqual([2, 5, 8], list2[2::3])
self.assertEqual([0, 3], list2[:6:3])
self.assertEqual([2, 5, 8], list2[-8:9:3])
self.assertEqual([], list2[100000:1000:-100])
assertEqualIter([0, 1, 2], list1[:3])
assertEqualIter([0, 1, 2, 3, "one", "two"], list1[:])
assertEqualIter([3, "one", "two"], list1[3:])
assertEqualIter([3, "one", "two"], list1[3:100])
assertEqualIter(["one", "two"], list1[-2:])
assertEqualIter([0, 1], list1[:-4])
assertEqualIter([], list1[6:])
assertEqualIter([], list1[4:2])
assertEqualIter([0, 2, "one"], list1[0:5:2])
assertEqualIter([0, 2], list1[0:-3:2])
assertEqualIter([0, 1, 2, 3, "one", "two"], list1[::])
assertEqualIter([2, 3, "one", "two"], list1[2::])
assertEqualIter([0, 1, 2, 3], list1[:4:])
assertEqualIter([2, 3], list1[2:4:])
assertEqualIter([0, 2, 4, 6, 8], list2[::2])
assertEqualIter([2, 5, 8], list2[2::3])
assertEqualIter([0, 3], list2[:6:3])
assertEqualIter([2, 5, 8], list2[-8:9:3])
assertEqualIter([], list2[100000:1000:-100])

list1[3] = 100
self.assertEqual(100, list1[3])
list1[-3] = 101
self.assertEqual([0, 1, 2, 101, "one", "two"], list1)
assertEqualIter([0, 1, 2, 101, "one", "two"], list1)
list1[5:] = [6, 7, 8]
self.assertEqual([6, 7, 8], list1[5:])
self.assertEqual([0, 1, 2, 101, "one", 6, 7, 8], list1)
assertEqualIter([6, 7, 8], list1[5:])
assertEqualIter([0, 1, 2, 101, "one", 6, 7, 8], list1)
list1[2:4] = [-1, -2, -3, -4, -5]
self.assertEqual([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)
assertEqualIter([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)
list1[0:-3] = [99]
self.assertEqual([99, 6, 7, 8], list1)
assertEqualIter([99, 6, 7, 8], list1)
list2[0:6:2] = [100, 102, 104]
self.assertEqual([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)
assertEqualIter([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)
list2[::3] = [200, 203, 206, 209]
self.assertEqual([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)
assertEqualIter([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)
list2[::] = range(7)
self.assertEqual([0, 1, 2, 3, 4, 5, 6], list2)
assertEqualIter([0, 1, 2, 3, 4, 5, 6], list2)
self.assertRaises(ValueError, assign, list2, 0, 5, 2,
[100, 102, 104, 106])
with self.assertRaises(IndexError):
@@ -91,35 +94,35 @@ class TestSmartList(unittest.TestCase):
list2[-8] = "foo"

del list2[2]
self.assertEqual([0, 1, 3, 4, 5, 6], list2)
assertEqualIter([0, 1, 3, 4, 5, 6], list2)
del list2[-3]
self.assertEqual([0, 1, 3, 5, 6], list2)
assertEqualIter([0, 1, 3, 5, 6], list2)
self.assertRaises(IndexError, delete, list2, 100)
self.assertRaises(IndexError, delete, list2, -6)
list2[:] = range(10)
del list2[3:6]
self.assertEqual([0, 1, 2, 6, 7, 8, 9], list2)
assertEqualIter([0, 1, 2, 6, 7, 8, 9], list2)
del list2[-2:]
self.assertEqual([0, 1, 2, 6, 7], list2)
assertEqualIter([0, 1, 2, 6, 7], list2)
del list2[:2]
self.assertEqual([2, 6, 7], list2)
assertEqualIter([2, 6, 7], list2)
list2[:] = range(10)
del list2[2:8:2]
self.assertEqual([0, 1, 3, 5, 7, 8, 9], list2)
assertEqualIter([0, 1, 3, 5, 7, 8, 9], list2)

def _test_add_radd_iadd(self, builder):
def _test_add_radd_iadd(self, builder, assertEqualIter):
"""Run tests on __r/i/add__ of a list built with *builder*."""
list1 = builder(range(5))
list2 = builder(range(5, 10))
self.assertEqual([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])
self.assertEqual([0, 1, 2, 3, 4], list1)
assertEqualIter([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])
assertEqualIter([0, 1, 2, 3, 4], list1)
self.assertEqual(list(range(10)), list1 + list2)
self.assertEqual([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)
self.assertEqual([0, 1, 2, 3, 4], list1)
assertEqualIter([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)
assertEqualIter([0, 1, 2, 3, 4], list1)
list1 += ["foo", "bar", "baz"]
self.assertEqual([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)
assertEqualIter([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)

def _test_other_magic_methods(self, builder):
def _test_other_magic_methods(self, builder, assertEqualIter):
"""Run tests on other magic methods of a list built with *builder*."""
list1 = builder([0, 1, 2, 3, "one", "two"])
list2 = builder([])
@@ -161,8 +164,8 @@ class TestSmartList(unittest.TestCase):
other3 = [0, 1, 2, 3, "one", "two"]
self.assertGreaterEqual(list1, other3)
self.assertLessEqual(list1, other3)
self.assertEqual(list1, other3)
self.assertEqual(list1, other3)
assertEqualIter(list1, other3)
assertEqualIter(list1, other3)
self.assertLessEqual(list1, other3)
self.assertGreaterEqual(list1, other3)

@@ -175,38 +178,39 @@ class TestSmartList(unittest.TestCase):
out = []
for obj in list1:
out.append(obj)
self.assertEqual([0, 1, 2, 3, "one", "two"], out)
assertEqualIter([0, 1, 2, 3, "one", "two"], out)

out = []
for ch in list2:
out.append(ch)
self.assertEqual([], out)
assertEqualIter([], out)

gen1 = iter(list1)
out = []
for i in range(len(list1)):
out.append(next(gen1))
self.assertRaises(StopIteration, next, gen1)
self.assertEqual([0, 1, 2, 3, "one", "two"], out)
assertEqualIter([0, 1, 2, 3, "one", "two"], out)
gen2 = iter(list2)
self.assertRaises(StopIteration, next, gen2)

self.assertEqual(["two", "one", 3, 2, 1, 0], list(reversed(list1)))
self.assertEqual([], list(reversed(list2)))
# TODO: might need to test an iterator rather than list
assertEqualIter(["two", "one", 3, 2, 1, 0], list(reversed(list1)))
assertEqualIter([], list(reversed(list2)))

self.assertIn("one", list1)
self.assertIn(3, list1)
self.assertNotIn(10, list1)
self.assertNotIn(0, list2)

self.assertEqual([], list2 * 5)
self.assertEqual([], 5 * list2)
self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)
self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)
assertEqualIter([], list2 * 5)
assertEqualIter([], 5 * list2)
assertEqualIter([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)
assertEqualIter([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)
list4 *= 2
self.assertEqual([0, 1, 2, 0, 1, 2], list4)
assertEqualIter([0, 1, 2, 0, 1, 2], list4)

def _test_list_methods(self, builder):
def _test_list_methods(self, builder, assertEqualIter):
"""Run tests on the public methods of a list built with *builder*."""
list1 = builder(range(5))
list2 = builder(["foo"])
@@ -215,13 +219,13 @@ class TestSmartList(unittest.TestCase):
list1.append(5)
list1.append(1)
list1.append(2)
self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2], list1)
assertEqualIter([0, 1, 2, 3, 4, 5, 1, 2], list1)

self.assertEqual(0, list1.count(6))
self.assertEqual(2, list1.count(1))

list1.extend(range(5, 8))
self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
assertEqualIter([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)

self.assertEqual(1, list1.index(1))
self.assertEqual(6, list1.index(1, 3))
@@ -229,55 +233,56 @@ class TestSmartList(unittest.TestCase):
self.assertRaises(ValueError, list1.index, 1, 3, 5)

list1.insert(0, -1)
self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
list1.insert(-1, 6.5)
self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)
assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)
list1.insert(13, 8)
self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7, 8], list1)
assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7, 8], list1)

self.assertEqual(8, list1.pop())
self.assertEqual(7, list1.pop())
self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5], list1)
assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5], list1)
self.assertEqual(-1, list1.pop(0))
self.assertEqual(5, list1.pop(5))
self.assertEqual(6.5, list1.pop(-1))
self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)
assertEqualIter([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)
self.assertEqual("foo", list2.pop())
self.assertRaises(IndexError, list2.pop)
self.assertEqual([], list2)
assertEqualIter([], list2)

list1.remove(6)
self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5], list1)
assertEqualIter([0, 1, 2, 3, 4, 1, 2, 5], list1)
list1.remove(1)
self.assertEqual([0, 2, 3, 4, 1, 2, 5], list1)
assertEqualIter([0, 2, 3, 4, 1, 2, 5], list1)
list1.remove(1)
self.assertEqual([0, 2, 3, 4, 2, 5], list1)
assertEqualIter([0, 2, 3, 4, 2, 5], list1)
self.assertRaises(ValueError, list1.remove, 1)

list1.reverse()
self.assertEqual([5, 2, 4, 3, 2, 0], list1)
assertEqualIter([5, 2, 4, 3, 2, 0], list1)

list1.sort()
self.assertEqual([0, 2, 2, 3, 4, 5], list1)
assertEqualIter([0, 2, 2, 3, 4, 5], list1)
list1.sort(reverse=True)
self.assertEqual([5, 4, 3, 2, 2, 0], list1)
assertEqualIter([5, 4, 3, 2, 2, 0], list1)
if not py3k:
func = lambda x, y: abs(3 - x) - abs(3 - y) # Distance from 3
list1.sort(cmp=func)
self.assertEqual([3, 4, 2, 2, 5, 0], list1)
assertEqualIter([3, 4, 2, 2, 5, 0], list1)
list1.sort(cmp=func, reverse=True)
self.assertEqual([0, 5, 4, 2, 2, 3], list1)
assertEqualIter([0, 5, 4, 2, 2, 3], list1)
list3.sort(key=lambda i: i[1])
self.assertEqual([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)
assertEqualIter([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)
list3.sort(key=lambda i: i[1], reverse=True)
self.assertEqual([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)
assertEqualIter([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)

def _dispatch_test_for_children(self, meth):
@staticmethod
def _dispatch_test_for_children(meth, assertEqualIter):
"""Run a test method on various different types of children."""
meth(lambda L: SmartList(list(L))[:])
meth(lambda L: SmartList([999] + list(L))[1:])
meth(lambda L: SmartList(list(L) + [999])[:-1])
meth(lambda L: SmartList([101, 102] + list(L) + [201, 202])[2:-2])
meth(lambda L: SmartList(list(L))[:], assertEqualIter)
meth(lambda L: SmartList([999] + list(L))[1:], assertEqualIter)
meth(lambda L: SmartList(list(L) + [999])[:-1], assertEqualIter)
meth(lambda L: SmartList([101, 102] + list(L) + [201, 202])[2:-2], assertEqualIter)

def test_docs(self):
"""make sure the methods of SmartList/_ListProxy have docstrings"""
@@ -302,120 +307,212 @@ class TestSmartList(unittest.TestCase):

def test_parent_get_set_del(self):
"""make sure SmartList's getitem/setitem/delitem work"""
self._test_get_set_del_item(SmartList)
self._test_get_set_del_item(SmartList, self.assertEqual)
self._test_get_set_del_item(SmartList, self.assertEqualIterator)

def test_parent_add(self):
"""make sure SmartList's add/radd/iadd work"""
self._test_add_radd_iadd(SmartList)
self._test_add_radd_iadd(SmartList, self.assertEqual)
self._test_add_radd_iadd(SmartList, self.assertEqualIterator)

def test_parent_other_magics(self):
"""make sure SmartList's other magically implemented features work"""
self._test_other_magic_methods(SmartList)
self._test_other_magic_methods(SmartList, self.assertEqual)
self._test_other_magic_methods(SmartList, self.assertEqualIterator)

def test_parent_methods(self):
"""make sure SmartList's non-magic methods work, like append()"""
self._test_list_methods(SmartList)
self._test_list_methods(SmartList, self.assertEqual)
self._test_list_methods(SmartList, self.assertEqualIterator)

def test_child_get_set_del(self):
"""make sure _ListProxy's getitem/setitem/delitem work"""
self._dispatch_test_for_children(self._test_get_set_del_item)
self._dispatch_test_for_children(self._test_get_set_del_item, self.assertEqual)
self._dispatch_test_for_children(self._test_get_set_del_item, self.assertEqualIterator)

def test_child_add(self):
"""make sure _ListProxy's add/radd/iadd work"""
self._dispatch_test_for_children(self._test_add_radd_iadd)
self._dispatch_test_for_children(self._test_add_radd_iadd, self.assertEqual)
self._dispatch_test_for_children(self._test_add_radd_iadd, self.assertEqualIterator)

def test_child_other_magics(self):
"""make sure _ListProxy's other magically implemented features work"""
self._dispatch_test_for_children(self._test_other_magic_methods)
self._dispatch_test_for_children(self._test_other_magic_methods, self.assertEqual)
self._dispatch_test_for_children(self._test_other_magic_methods, self.assertEqualIterator)

def test_child_methods(self):
"""make sure _ListProxy's non-magic methods work, like append()"""
self._dispatch_test_for_children(self._test_list_methods)
self._dispatch_test_for_children(self._test_list_methods, self.assertEqual)
self._dispatch_test_for_children(self._test_list_methods, self.assertEqualIterator)

def test_influence(self):
def _test_influence(self, assertEqualIter):
"""make sure changes are propagated from parents to children"""
parent = SmartList([0, 1, 2, 3, 4, 5])
child1 = parent[2:]
child2 = parent[2:5]
self.assertEqual([0, 1, 2, 3, 4, 5], parent)
self.assertEqual([2, 3, 4, 5], child1)
self.assertEqual([2, 3, 4], child2)
assertEqualIter([0, 1, 2, 3, 4, 5], parent)
assertEqualIter([2, 3, 4, 5], child1)
assertEqualIter([2, 3, 4], child2)
self.assertEqual(2, len(parent._children))

parent.append(6)
child1.append(7)
child2.append(4.5)
self.assertEqual([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)
self.assertEqual([2, 3, 4, 4.5, 5, 6, 7], child1)
self.assertEqual([2, 3, 4, 4.5], child2)
assertEqualIter([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)
assertEqualIter([2, 3, 4, 4.5, 5, 6, 7], child1)
assertEqualIter([2, 3, 4, 4.5], child2)

parent.insert(0, -1)
parent.insert(4, 2.5)
parent.insert(10, 6.5)
self.assertEqual([-1, 0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], parent)
self.assertEqual([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)
self.assertEqual([2, 2.5, 3, 4, 4.5], child2)
assertEqualIter([-1, 0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], parent)
assertEqualIter([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)
assertEqualIter([2, 2.5, 3, 4, 4.5], child2)

self.assertEqual(7, parent.pop())
self.assertEqual(6.5, child1.pop())
self.assertEqual(4.5, child2.pop())
self.assertEqual([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)
self.assertEqual([2, 2.5, 3, 4, 5, 6], child1)
self.assertEqual([2, 2.5, 3, 4], child2)
assertEqualIter([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)
assertEqualIter([2, 2.5, 3, 4, 5, 6], child1)
assertEqualIter([2, 2.5, 3, 4], child2)

parent.remove(-1)
child1.remove(2.5)
self.assertEqual([0, 1, 2, 3, 4, 5, 6], parent)
self.assertEqual([2, 3, 4, 5, 6], child1)
self.assertEqual([2, 3, 4], child2)
assertEqualIter([0, 1, 2, 3, 4, 5, 6], parent)
assertEqualIter([2, 3, 4, 5, 6], child1)
assertEqualIter([2, 3, 4], child2)

self.assertEqual(0, parent.pop(0))
self.assertEqual([1, 2, 3, 4, 5, 6], parent)
self.assertEqual([2, 3, 4, 5, 6], child1)
self.assertEqual([2, 3, 4], child2)
assertEqualIter([1, 2, 3, 4, 5, 6], parent)
assertEqualIter([2, 3, 4, 5, 6], child1)
assertEqualIter([2, 3, 4], child2)

child2.reverse()
self.assertEqual([1, 4, 3, 2, 5, 6], parent)
self.assertEqual([4, 3, 2, 5, 6], child1)
self.assertEqual([4, 3, 2], child2)
assertEqualIter([1, 4, 3, 2, 5, 6], parent)
assertEqualIter([4, 3, 2, 5, 6], child1)
assertEqualIter([4, 3, 2], child2)

parent.extend([7, 8])
child1.extend([8.1, 8.2])
child2.extend([1.9, 1.8])
self.assertEqual([1, 4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], parent)
self.assertEqual([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)
self.assertEqual([4, 3, 2, 1.9, 1.8], child2)
assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], parent)
assertEqualIter([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)
assertEqualIter([4, 3, 2, 1.9, 1.8], child2)

child3 = parent[9:]
self.assertEqual([8, 8.1, 8.2], child3)
assertEqualIter([8, 8.1, 8.2], child3)

del parent[8:]
self.assertEqual([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
self.assertEqual([4, 3, 2, 1.9, 1.8, 5, 6], child1)
self.assertEqual([4, 3, 2, 1.9, 1.8], child2)
self.assertEqual([], child3)
assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
assertEqualIter([4, 3, 2, 1.9, 1.8, 5, 6], child1)
assertEqualIter([4, 3, 2, 1.9, 1.8], child2)
assertEqualIter([], child3)
self.assertEqual(0, len(child3))

del child1
self.assertEqual([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
self.assertEqual([4, 3, 2, 1.9, 1.8], child2)
self.assertEqual([], child3)
assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
assertEqualIter([4, 3, 2, 1.9, 1.8], child2)
assertEqualIter([], child3)
self.assertEqual(2, len(parent._children))

del child3
self.assertEqual([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
self.assertEqual([4, 3, 2, 1.9, 1.8], child2)
assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)
assertEqualIter([4, 3, 2, 1.9, 1.8], child2)
self.assertEqual(1, len(parent._children))

parent.remove(1.9)
parent.remove(1.8)
self.assertEqual([1, 4, 3, 2, 5, 6], parent)
self.assertEqual([4, 3, 2], child2)
assertEqualIter([1, 4, 3, 2, 5, 6], parent)
assertEqualIter([4, 3, 2], child2)

parent.reverse()
self.assertEqual([6, 5, 2, 3, 4, 1], parent)
self.assertEqual([4, 3, 2], child2)
assertEqualIter([6, 5, 2, 3, 4, 1], parent)
assertEqualIter([4, 3, 2], child2)
self.assertEqual(0, len(parent._children))

def test_influence(self):
self._test_influence(self.assertEqual)
self._test_influence(self.assertEqualIterator)

@staticmethod
def _test_get_slice(builder, assertEqualIter):
lst = builder([0, 1, 2])
assertEqualIter(lst, [0, 1, 2])
assertEqualIter(lst[:], [0, 1, 2])
assertEqualIter(lst[0:0], [])
assertEqualIter(lst[0:1], [0])
assertEqualIter(lst[0:2], [0, 1])
assertEqualIter(lst[0:3], [0, 1, 2])
assertEqualIter(lst[0:4], [0, 1, 2]) # bug in iteration
assertEqualIter(lst[0:], [0, 1, 2])
assertEqualIter(lst[1:1], [])
assertEqualIter(lst[1:2], [1])
assertEqualIter(lst[1:3], [1, 2])
assertEqualIter(lst[1:4], [1, 2]) # bug in iteration
assertEqualIter(lst[1:], [1, 2])
assertEqualIter(lst[2:], [2])
assertEqualIter(lst[3:], [])
assertEqualIter(lst[4:], [])
assertEqualIter(lst[-1:], [2])
assertEqualIter(lst[-2:], [1, 2])
assertEqualIter(lst[-3:], [0, 1, 2])
assertEqualIter(lst[-4:], [0, 1, 2]) # bug in list and iteration
assertEqualIter(lst[:-1], [0, 1])
assertEqualIter(lst[:-2], [0])
assertEqualIter(lst[:-3], [])
assertEqualIter(lst[:-4], []) # bug in list
assertEqualIter(lst[1:-1], [1])
assertEqualIter(lst[1:-2], [])
assertEqualIter(lst[1:-3], [])
assertEqualIter(lst[1:-4], []) # bug in list
assertEqualIter(lst[-1:-1], [])
assertEqualIter(lst[-2:-1], [1])
assertEqualIter(lst[-3:-1], [0, 1])
assertEqualIter(lst[-4:-1], [0, 1]) # bug in list and iteration
assertEqualIter(lst[-3:-1], [0, 1])
assertEqualIter(lst[-3:-2], [0])
assertEqualIter(lst[-3:-3], [])
assertEqualIter(lst[-3:-4], []) # bug in list

# step == 2
assertEqualIter(lst[::2], [0, 2])
assertEqualIter(lst[0::2], [0, 2])
assertEqualIter(lst[1::2], [1])
assertEqualIter(lst[2::2], [2])
assertEqualIter(lst[3::2], [])
assertEqualIter(lst[4::2], [])

# step < 0 -- all of these are not working correctly
assertEqualIter(lst[::-1], [2, 1, 0])
assertEqualIter(lst[0::-1], [0])
assertEqualIter(lst[1::-1], [1, 0])
assertEqualIter(lst[2::-1], [2, 1, 0])
assertEqualIter(lst[3::-1], [2, 1, 0])
assertEqualIter(lst[4::-1], [2, 1, 0])
assertEqualIter(lst[::-2], [2, 0])
assertEqualIter(lst[0::-2], [0])
assertEqualIter(lst[1::-2], [1])
assertEqualIter(lst[2::-2], [2, 0])
assertEqualIter(lst[3::-2], [2, 0])
assertEqualIter(lst[4::-2], [2, 0])

def test_get_slice(self):
self._test_get_slice(list, self.assertEqual) # test against built-in list
self._test_get_slice(SmartList, self.assertEqual)

def test_get_slice_iterator(self):
self._test_get_slice(list, self.assertEqualIterator) # test against built-in list
self._test_get_slice(SmartList, self.assertEqualIterator)

def assertEqualIterator(self, iter1, iter2):
if py3k:
from itertools import zip_longest
else:
from itertools import izip_longest as zip_longest

for a, b in zip_longest(iter1, iter2, fillvalue='__END_OF_LIST__'):
self.assertEqual(a, b)


if __name__ == "__main__":
unittest.main(verbosity=2)

Write Preview
Loading…
Cancel
Save