ben
/
mwparserfromhell
mirror of https://github.com/earwig/mwparserfromhell
1
1
Fork 0
Code Releases 24 Activity
A Python parser for MediaWiki wikicode https://mwparserfromhell.readthedocs.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
865 Commits
1 Branch
5.8 MiB
 
 
 
 
Tree: ff3e746ad6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ff3e746ad6'
${ noResults }
mwparserfromhell/tests/test_smart_list.py

521 lines
21 KiB
Raw Blame History 

  1. # -*- coding: utf-8  -*-

  2. #

  3. # Copyright (C) 2012-2016 Ben Kurtovic <ben.kurtovic@gmail.com>

  4. #

  5. # Permission is hereby granted, free of charge, to any person obtaining a copy

  6. # of this software and associated documentation files (the "Software"), to deal

  7. # in the Software without restriction, including without limitation the rights

  8. # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9. # copies of the Software, and to permit persons to whom the Software is

  10. # furnished to do so, subject to the following conditions:

  11. #

  12. # The above copyright notice and this permission notice shall be included in

  13. # all copies or substantial portions of the Software.

  14. #

  15. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16. # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17. # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18. # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19. # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20. # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  21. # SOFTWARE.

  22. 

  23. from __future__ import unicode_literals

  24. 

  25. import unittest

  26. 

  27. from mwparserfromhell.compat import py3k, range

  28. from mwparserfromhell.smart_list import SmartList

  29. from mwparserfromhell.smart_list.ListProxy import _ListProxy

  30. 

  31. 

  32. 

  33. class TestSmartList(unittest.TestCase):

  34.     """Test cases for the SmartList class and its child, _ListProxy."""

  35. 

  36.     def _test_get_set_del_item(self, builder, assertEqualIter):

  37.         """Run tests on __get/set/delitem__ of a list built with *builder*."""

  38.         def assign(L, s1, s2, s3, val):

  39.             L[s1:s2:s3] = val

  40. 

  41.         def delete(L, s1):

  42.             del L[s1]

  43. 

  44.         list1 = builder([0, 1, 2, 3, "one", "two"])

  45.         list2 = builder(list(range(10)))

  46. 

  47.         self.assertEqual(1, list1[1])

  48.         self.assertEqual("one", list1[-2])

  49.         assertEqualIter([2, 3], list1[2:4])

  50.         self.assertRaises(IndexError, lambda: list1[6])

  51.         self.assertRaises(IndexError, lambda: list1[-7])

  52. 

  53.         assertEqualIter([0, 1, 2], list1[:3])

  54.         assertEqualIter([0, 1, 2, 3, "one", "two"], list1[:])

  55.         assertEqualIter([3, "one", "two"], list1[3:])

  56.         assertEqualIter([3, "one", "two"], list1[3:100])

  57.         assertEqualIter(["one", "two"], list1[-2:])

  58.         assertEqualIter([0, 1], list1[:-4])

  59.         assertEqualIter([], list1[6:])

  60.         assertEqualIter([], list1[4:2])

  61. 

  62.         assertEqualIter([0, 2, "one"], list1[0:5:2])

  63.         assertEqualIter([0, 2], list1[0:-3:2])

  64.         assertEqualIter([0, 1, 2, 3, "one", "two"], list1[::])

  65.         assertEqualIter([2, 3, "one", "two"], list1[2::])

  66.         assertEqualIter([0, 1, 2, 3], list1[:4:])

  67.         assertEqualIter([2, 3], list1[2:4:])

  68.         assertEqualIter([0, 2, 4, 6, 8], list2[::2])

  69.         assertEqualIter([2, 5, 8], list2[2::3])

  70.         assertEqualIter([0, 3], list2[:6:3])

  71.         assertEqualIter([2, 5, 8], list2[-8:9:3])

  72.         assertEqualIter([], list2[100000:1000:-100])

  73. 

  74.         list1[3] = 100

  75.         self.assertEqual(100, list1[3])

  76.         list1[-3] = 101

  77.         assertEqualIter([0, 1, 2, 101, "one", "two"], list1)

  78.         list1[5:] = [6, 7, 8]

  79.         assertEqualIter([6, 7, 8], list1[5:])

  80.         assertEqualIter([0, 1, 2, 101, "one", 6, 7, 8], list1)

  81.         list1[2:4] = [-1, -2, -3, -4, -5]

  82.         assertEqualIter([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)

  83.         list1[0:-3] = [99]

  84.         assertEqualIter([99, 6, 7, 8], list1)

  85.         list2[0:6:2] = [100, 102, 104]

  86.         assertEqualIter([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)

  87.         list2[::3] = [200, 203, 206, 209]

  88.         assertEqualIter([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)

  89.         list2[::] = range(7)

  90.         assertEqualIter([0, 1, 2, 3, 4, 5, 6], list2)

  91.         self.assertRaises(ValueError, assign, list2, 0, 5, 2,

  92.                           [100, 102, 104, 106])

  93.         with self.assertRaises(IndexError):

  94.             list2[7] = "foo"

  95.         with self.assertRaises(IndexError):

  96.             list2[-8] = "foo"

  97. 

  98.         del list2[2]

  99.         assertEqualIter([0, 1, 3, 4, 5, 6], list2)

  100.         del list2[-3]

  101.         assertEqualIter([0, 1, 3, 5, 6], list2)

  102.         self.assertRaises(IndexError, delete, list2, 100)

  103.         self.assertRaises(IndexError, delete, list2, -6)

  104.         list2[:] = range(10)

  105.         del list2[3:6]

  106.         assertEqualIter([0, 1, 2, 6, 7, 8, 9], list2)

  107.         del list2[-2:]

  108.         assertEqualIter([0, 1, 2, 6, 7], list2)

  109.         del list2[:2]

  110.         assertEqualIter([2, 6, 7], list2)

  111.         list2[:] = range(10)

  112.         del list2[2:8:2]

  113.         assertEqualIter([0, 1, 3, 5, 7, 8, 9], list2)

  114. 

  115.     def _test_add_radd_iadd(self, builder, assertEqualIter):

  116.         """Run tests on __r/i/add__ of a list built with *builder*."""

  117.         list1 = builder(range(5))

  118.         list2 = builder(range(5, 10))

  119.         assertEqualIter([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])

  120.         assertEqualIter([0, 1, 2, 3, 4], list1)

  121.         self.assertEqual(list(range(10)), list1 + list2)

  122.         assertEqualIter([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)

  123.         assertEqualIter([0, 1, 2, 3, 4], list1)

  124.         list1 += ["foo", "bar", "baz"]

  125.         assertEqualIter([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)

  126. 

  127.     def _test_other_magic_methods(self, builder, assertEqualIter):

  128.         """Run tests on other magic methods of a list built with *builder*."""

  129.         list1 = builder([0, 1, 2, 3, "one", "two"])

  130.         list2 = builder([])

  131.         list3 = builder([0, 2, 3, 4])

  132.         list4 = builder([0, 1, 2])

  133. 

  134.         if py3k:

  135.             self.assertEqual("[0, 1, 2, 3, 'one', 'two']", str(list1))

  136.             self.assertEqual(b"\x00\x01\x02", bytes(list4))

  137.             self.assertEqual("[0, 1, 2, 3, 'one', 'two']", repr(list1))

  138.         else:

  139.             self.assertEqual("[0, 1, 2, 3, u'one', u'two']", unicode(list1))

  140.             self.assertEqual(b"[0, 1, 2, 3, u'one', u'two']", str(list1))

  141.             self.assertEqual(b"[0, 1, 2, 3, u'one', u'two']", repr(list1))

  142. 

  143.         self.assertLess(list1, list3)

  144.         self.assertLessEqual(list1, list3)

  145.         self.assertNotEqual(list1, list3)

  146.         self.assertNotEqual(list1, list3)

  147.         self.assertLessEqual(list1, list3)

  148.         self.assertLess(list1, list3)

  149. 

  150.         other1 = [0, 2, 3, 4]

  151.         self.assertLess(list1, other1)

  152.         self.assertLessEqual(list1, other1)

  153.         self.assertNotEqual(list1, other1)

  154.         self.assertNotEqual(list1, other1)

  155.         self.assertLessEqual(list1, other1)

  156.         self.assertLess(list1, other1)

  157. 

  158.         other2 = [0, 0, 1, 2]

  159.         self.assertGreaterEqual(list1, other2)

  160.         self.assertGreater(list1, other2)

  161.         self.assertNotEqual(list1, other2)

  162.         self.assertNotEqual(list1, other2)

  163.         self.assertGreater(list1, other2)

  164.         self.assertGreaterEqual(list1, other2)

  165. 

  166.         other3 = [0, 1, 2, 3, "one", "two"]

  167.         self.assertGreaterEqual(list1, other3)

  168.         self.assertLessEqual(list1, other3)

  169.         assertEqualIter(list1, other3)

  170.         assertEqualIter(list1, other3)

  171.         self.assertLessEqual(list1, other3)

  172.         self.assertGreaterEqual(list1, other3)

  173. 

  174.         self.assertTrue(bool(list1))

  175.         self.assertFalse(bool(list2))

  176. 

  177.         self.assertEqual(6, len(list1))

  178.         self.assertEqual(0, len(list2))

  179. 

  180.         out = []

  181.         for obj in list1:

  182.             out.append(obj)

  183.         assertEqualIter([0, 1, 2, 3, "one", "two"], out)

  184. 

  185.         out = []

  186.         for ch in list2:

  187.             out.append(ch)

  188.         assertEqualIter([], out)

  189. 

  190.         gen1 = iter(list1)

  191.         out = []

  192.         for i in range(len(list1)):

  193.             out.append(next(gen1))

  194.         self.assertRaises(StopIteration, next, gen1)

  195.         assertEqualIter([0, 1, 2, 3, "one", "two"], out)

  196.         gen2 = iter(list2)

  197.         self.assertRaises(StopIteration, next, gen2)

  198. 

  199.         # TODO: might need to test an iterator rather than list

  200.         assertEqualIter(["two", "one", 3, 2, 1, 0], list(reversed(list1)))

  201.         assertEqualIter([], list(reversed(list2)))

  202. 

  203.         self.assertIn("one", list1)

  204.         self.assertIn(3, list1)

  205.         self.assertNotIn(10, list1)

  206.         self.assertNotIn(0, list2)

  207. 

  208.         assertEqualIter([], list2 * 5)

  209.         assertEqualIter([], 5 * list2)

  210.         assertEqualIter([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)

  211.         assertEqualIter([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)

  212.         list4 *= 2

  213.         assertEqualIter([0, 1, 2, 0, 1, 2], list4)

  214. 

  215.     def _test_list_methods(self, builder, assertEqualIter):

  216.         """Run tests on the public methods of a list built with *builder*."""

  217.         list1 = builder(range(5))

  218.         list2 = builder(["foo"])

  219.         list3 = builder([("a", 5), ("d", 2), ("b", 8), ("c", 3)])

  220. 

  221.         list1.append(5)

  222.         list1.append(1)

  223.         list1.append(2)

  224.         assertEqualIter([0, 1, 2, 3, 4, 5, 1, 2], list1)

  225. 

  226.         self.assertEqual(0, list1.count(6))

  227.         self.assertEqual(2, list1.count(1))

  228. 

  229.         list1.extend(range(5, 8))

  230.         assertEqualIter([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)

  231. 

  232.         self.assertEqual(1, list1.index(1))

  233.         self.assertEqual(6, list1.index(1, 3))

  234.         self.assertEqual(6, list1.index(1, 3, 7))

  235.         self.assertRaises(ValueError, list1.index, 1, 3, 5)

  236. 

  237.         list1.insert(0, -1)

  238.         assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)

  239.         list1.insert(-1, 6.5)

  240.         assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)

  241.         list1.insert(13, 8)

  242.         assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7, 8], list1)

  243. 

  244.         self.assertEqual(8, list1.pop())

  245.         self.assertEqual(7, list1.pop())

  246.         assertEqualIter([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5], list1)

  247.         self.assertEqual(-1, list1.pop(0))

  248.         self.assertEqual(5, list1.pop(5))

  249.         self.assertEqual(6.5, list1.pop(-1))

  250.         assertEqualIter([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)

  251.         self.assertEqual("foo", list2.pop())

  252.         self.assertRaises(IndexError, list2.pop)

  253.         assertEqualIter([], list2)

  254. 

  255.         list1.remove(6)

  256.         assertEqualIter([0, 1, 2, 3, 4, 1, 2, 5], list1)

  257.         list1.remove(1)

  258.         assertEqualIter([0, 2, 3, 4, 1, 2, 5], list1)

  259.         list1.remove(1)

  260.         assertEqualIter([0, 2, 3, 4, 2, 5], list1)

  261.         self.assertRaises(ValueError, list1.remove, 1)

  262. 

  263.         list1.reverse()

  264.         assertEqualIter([5, 2, 4, 3, 2, 0], list1)

  265. 

  266.         list1.sort()

  267.         assertEqualIter([0, 2, 2, 3, 4, 5], list1)

  268.         list1.sort(reverse=True)

  269.         assertEqualIter([5, 4, 3, 2, 2, 0], list1)

  270.         if not py3k:

  271.             func = lambda x, y: abs(3 - x) - abs(3 - y)  # Distance from 3

  272.             list1.sort(cmp=func)

  273.             assertEqualIter([3, 4, 2, 2, 5, 0], list1)

  274.             list1.sort(cmp=func, reverse=True)

  275.             assertEqualIter([0, 5, 4, 2, 2, 3], list1)

  276.         list3.sort(key=lambda i: i[1])

  277.         assertEqualIter([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)

  278.         list3.sort(key=lambda i: i[1], reverse=True)

  279.         assertEqualIter([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)

  280. 

  281.     @staticmethod

  282.     def _dispatch_test_for_children(meth, assertEqualIter):

  283.         """Run a test method on various different types of children."""

  284.         meth(lambda L: SmartList(list(L))[:], assertEqualIter)

  285.         meth(lambda L: SmartList([999] + list(L))[1:], assertEqualIter)

  286.         meth(lambda L: SmartList(list(L) + [999])[:-1], assertEqualIter)

  287.         meth(lambda L: SmartList([101, 102] + list(L) + [201, 202])[2:-2], assertEqualIter)

  288. 

  289.     def test_docs(self):

  290.         """make sure the methods of SmartList/_ListProxy have docstrings"""

  291.         methods = ["append", "count", "extend", "index", "insert", "pop",

  292.                    "remove", "reverse", "sort"]

  293.         for meth in methods:

  294.             expected = getattr(list, meth).__doc__

  295.             smartlist_doc = getattr(SmartList, meth).__doc__

  296.             listproxy_doc = getattr(_ListProxy, meth).__doc__

  297.             self.assertEqual(expected, smartlist_doc)

  298.             self.assertEqual(expected, listproxy_doc)

  299. 

  300.     def test_doctest(self):

  301.         """make sure the test embedded in SmartList's docstring passes"""

  302.         parent = SmartList([0, 1, 2, 3])

  303.         self.assertEqual([0, 1, 2, 3], parent)

  304.         child = parent[2:]

  305.         self.assertEqual([2, 3], child)

  306.         child.append(4)

  307.         self.assertEqual([2, 3, 4], child)

  308.         self.assertEqual([0, 1, 2, 3, 4], parent)

  309. 

  310.     def test_parent_get_set_del(self):

  311.         """make sure SmartList's getitem/setitem/delitem work"""

  312.         self._test_get_set_del_item(SmartList, self.assertEqual)

  313.         self._test_get_set_del_item(SmartList, self.assertEqualIterator)

  314. 

  315.     def test_parent_add(self):

  316.         """make sure SmartList's add/radd/iadd work"""

  317.         self._test_add_radd_iadd(SmartList, self.assertEqual)

  318.         self._test_add_radd_iadd(SmartList, self.assertEqualIterator)

  319. 

  320.     def test_parent_other_magics(self):

  321.         """make sure SmartList's other magically implemented features work"""

  322.         self._test_other_magic_methods(SmartList, self.assertEqual)

  323.         self._test_other_magic_methods(SmartList, self.assertEqualIterator)

  324. 

  325.     def test_parent_methods(self):

  326.         """make sure SmartList's non-magic methods work, like append()"""

  327.         self._test_list_methods(SmartList, self.assertEqual)

  328.         self._test_list_methods(SmartList, self.assertEqualIterator)

  329. 

  330.     def test_child_get_set_del(self):

  331.         """make sure _ListProxy's getitem/setitem/delitem work"""

  332.         self._dispatch_test_for_children(self._test_get_set_del_item, self.assertEqual)

  333.         self._dispatch_test_for_children(self._test_get_set_del_item, self.assertEqualIterator)

  334. 

  335.     def test_child_add(self):

  336.         """make sure _ListProxy's add/radd/iadd work"""

  337.         self._dispatch_test_for_children(self._test_add_radd_iadd, self.assertEqual)

  338.         self._dispatch_test_for_children(self._test_add_radd_iadd, self.assertEqualIterator)

  339. 

  340.     def test_child_other_magics(self):

  341.         """make sure _ListProxy's other magically implemented features work"""

  342.         self._dispatch_test_for_children(self._test_other_magic_methods, self.assertEqual)

  343.         self._dispatch_test_for_children(self._test_other_magic_methods, self.assertEqualIterator)

  344. 

  345.     def test_child_methods(self):

  346.         """make sure _ListProxy's non-magic methods work, like append()"""

  347.         self._dispatch_test_for_children(self._test_list_methods, self.assertEqual)

  348.         self._dispatch_test_for_children(self._test_list_methods, self.assertEqualIterator)

  349. 

  350.     def _test_influence(self, assertEqualIter):

  351.         """make sure changes are propagated from parents to children"""

  352.         parent = SmartList([0, 1, 2, 3, 4, 5])

  353.         child1 = parent[2:]

  354.         child2 = parent[2:5]

  355.         assertEqualIter([0, 1, 2, 3, 4, 5], parent)

  356.         assertEqualIter([2, 3, 4, 5], child1)

  357.         assertEqualIter([2, 3, 4], child2)

  358.         self.assertEqual(2, len(parent._children))

  359. 

  360.         parent.append(6)

  361.         child1.append(7)

  362.         child2.append(4.5)

  363.         assertEqualIter([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)

  364.         assertEqualIter([2, 3, 4, 4.5, 5, 6, 7], child1)

  365.         assertEqualIter([2, 3, 4, 4.5], child2)

  366. 

  367.         parent.insert(0, -1)

  368.         parent.insert(4, 2.5)

  369.         parent.insert(10, 6.5)

  370.         assertEqualIter([-1, 0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], parent)

  371.         assertEqualIter([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)

  372.         assertEqualIter([2, 2.5, 3, 4, 4.5], child2)

  373. 

  374.         self.assertEqual(7, parent.pop())

  375.         self.assertEqual(6.5, child1.pop())

  376.         self.assertEqual(4.5, child2.pop())

  377.         assertEqualIter([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)

  378.         assertEqualIter([2, 2.5, 3, 4, 5, 6], child1)

  379.         assertEqualIter([2, 2.5, 3, 4], child2)

  380. 

  381.         parent.remove(-1)

  382.         child1.remove(2.5)

  383.         assertEqualIter([0, 1, 2, 3, 4, 5, 6], parent)

  384.         assertEqualIter([2, 3, 4, 5, 6], child1)

  385.         assertEqualIter([2, 3, 4], child2)

  386. 

  387.         self.assertEqual(0, parent.pop(0))

  388.         assertEqualIter([1, 2, 3, 4, 5, 6], parent)

  389.         assertEqualIter([2, 3, 4, 5, 6], child1)

  390.         assertEqualIter([2, 3, 4], child2)

  391. 

  392.         child2.reverse()

  393.         assertEqualIter([1, 4, 3, 2, 5, 6], parent)

  394.         assertEqualIter([4, 3, 2, 5, 6], child1)

  395.         assertEqualIter([4, 3, 2], child2)

  396. 

  397.         parent.extend([7, 8])

  398.         child1.extend([8.1, 8.2])

  399.         child2.extend([1.9, 1.8])

  400.         assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], parent)

  401.         assertEqualIter([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)

  402.         assertEqualIter([4, 3, 2, 1.9, 1.8], child2)

  403. 

  404.         child3 = parent[9:]

  405.         assertEqualIter([8, 8.1, 8.2], child3)

  406. 

  407.         del parent[8:]

  408.         assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)

  409.         assertEqualIter([4, 3, 2, 1.9, 1.8, 5, 6], child1)

  410.         assertEqualIter([4, 3, 2, 1.9, 1.8], child2)

  411.         assertEqualIter([], child3)

  412.         self.assertEqual(0, len(child3))

  413. 

  414.         del child1

  415.         assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)

  416.         assertEqualIter([4, 3, 2, 1.9, 1.8], child2)

  417.         assertEqualIter([], child3)

  418.         self.assertEqual(2, len(parent._children))

  419. 

  420.         del child3

  421.         assertEqualIter([1, 4, 3, 2, 1.9, 1.8, 5, 6], parent)

  422.         assertEqualIter([4, 3, 2, 1.9, 1.8], child2)

  423.         self.assertEqual(1, len(parent._children))

  424. 

  425.         parent.remove(1.9)

  426.         parent.remove(1.8)

  427.         assertEqualIter([1, 4, 3, 2, 5, 6], parent)

  428.         assertEqualIter([4, 3, 2], child2)

  429. 

  430.         parent.reverse()

  431.         assertEqualIter([6, 5, 2, 3, 4, 1], parent)

  432.         assertEqualIter([4, 3, 2], child2)

  433.         self.assertEqual(0, len(parent._children))

  434. 

  435.     def test_influence(self):

  436.         self._test_influence(self.assertEqual)

  437.         self._test_influence(self.assertEqualIterator)

  438. 

  439.     @staticmethod

  440.     def _test_get_slice(builder, assertEqualIter):

  441.         lst = builder([0, 1, 2])

  442.         assertEqualIter(lst, [0, 1, 2])

  443.         assertEqualIter(lst[:], [0, 1, 2])

  444.         assertEqualIter(lst[0:0], [])

  445.         assertEqualIter(lst[0:1], [0])

  446.         assertEqualIter(lst[0:2], [0, 1])

  447.         assertEqualIter(lst[0:3], [0, 1, 2])

  448.         assertEqualIter(lst[0:4], [0, 1, 2])  # bug in iteration

  449.         assertEqualIter(lst[0:], [0, 1, 2])

  450.         assertEqualIter(lst[1:1], [])

  451.         assertEqualIter(lst[1:2], [1])

  452.         assertEqualIter(lst[1:3], [1, 2])

  453.         assertEqualIter(lst[1:4], [1, 2])  # bug in iteration

  454.         assertEqualIter(lst[1:], [1, 2])

  455.         assertEqualIter(lst[2:], [2])

  456.         assertEqualIter(lst[3:], [])

  457.         assertEqualIter(lst[4:], [])

  458.         assertEqualIter(lst[-1:], [2])

  459.         assertEqualIter(lst[-2:], [1, 2])

  460.         assertEqualIter(lst[-3:], [0, 1, 2])

  461.         assertEqualIter(lst[-4:], [0, 1, 2])  # bug in list and iteration

  462.         assertEqualIter(lst[:-1], [0, 1])

  463.         assertEqualIter(lst[:-2], [0])

  464.         assertEqualIter(lst[:-3], [])

  465.         assertEqualIter(lst[:-4], [])  # bug in list

  466.         assertEqualIter(lst[1:-1], [1])

  467.         assertEqualIter(lst[1:-2], [])

  468.         assertEqualIter(lst[1:-3], [])

  469.         assertEqualIter(lst[1:-4], [])  # bug in list

  470.         assertEqualIter(lst[-1:-1], [])

  471.         assertEqualIter(lst[-2:-1], [1])

  472.         assertEqualIter(lst[-3:-1], [0, 1])

  473.         assertEqualIter(lst[-4:-1], [0, 1])  # bug in list and iteration

  474.         assertEqualIter(lst[-3:-1], [0, 1])

  475.         assertEqualIter(lst[-3:-2], [0])

  476.         assertEqualIter(lst[-3:-3], [])

  477.         assertEqualIter(lst[-3:-4], [])  # bug in list

  478. 

  479.         # step == 2

  480.         assertEqualIter(lst[::2], [0, 2])

  481.         assertEqualIter(lst[0::2], [0, 2])

  482.         assertEqualIter(lst[1::2], [1])

  483.         assertEqualIter(lst[2::2], [2])

  484.         assertEqualIter(lst[3::2], [])

  485.         assertEqualIter(lst[4::2], [])

  486. 

  487.         # step < 0 -- all of these are not working correctly

  488.         assertEqualIter(lst[::-1], [2, 1, 0])

  489.         assertEqualIter(lst[0::-1], [0])

  490.         assertEqualIter(lst[1::-1], [1, 0])

  491.         assertEqualIter(lst[2::-1], [2, 1, 0])

  492.         assertEqualIter(lst[3::-1], [2, 1, 0])

  493.         assertEqualIter(lst[4::-1], [2, 1, 0])

  494.         assertEqualIter(lst[::-2], [2, 0])

  495.         assertEqualIter(lst[0::-2], [0])

  496.         assertEqualIter(lst[1::-2], [1])

  497.         assertEqualIter(lst[2::-2], [2, 0])

  498.         assertEqualIter(lst[3::-2], [2, 0])

  499.         assertEqualIter(lst[4::-2], [2, 0])

  500. 

  501.     def test_get_slice(self):

  502.         self._test_get_slice(list, self.assertEqual)  # test against built-in list

  503.         self._test_get_slice(SmartList, self.assertEqual)

  504. 

  505.     def test_get_slice_iterator(self):

  506.         self._test_get_slice(list, self.assertEqualIterator)  # test against built-in list

  507.         self._test_get_slice(SmartList, self.assertEqualIterator)

  508. 

  509.     def assertEqualIterator(self, iter1, iter2):

  510.         if py3k:

  511.             from itertools import zip_longest

  512.         else:

  513.             from itertools import izip_longest as zip_longest

  514. 

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

  516.             self.assertEqual(a, b)

  517. 

  518. 

  519. if __name__ == "__main__":

  520.     unittest.main(verbosity=2)