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.
228 Commits
1 Branch
26 MiB
 
 
 
 
Tree: 67611bfb5b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '67611bfb5b'
${ noResults }
mwparserfromhell/tests/test_smart_list.py

290 lines
10 KiB
Raw Blame History 

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

  2. #

  3. # Copyright (C) 2012-2013 Ben Kurtovic <ben.kurtovic@verizon.net>

  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. import unittest

  25. 

  26. from mwparserfromhell.compat import py3k, range

  27. from mwparserfromhell.smart_list import SmartList, _ListProxy

  28. 

  29. class TestSmartList(unittest.TestCase):

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

  31.     def test_docs(self):

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

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

  34.                    "remove", "reverse", "sort"]

  35.         for meth in methods:

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

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

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

  39.             self.assertEquals(expected, smartlist_doc)

  40.             self.assertEquals(expected, listproxy_doc)

  41. 

  42.     def test_doctest(self):

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

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

  45.         self.assertEquals([0, 1, 2, 3], parent)

  46.         child = parent[2:]

  47.         self.assertEquals([2, 3], child)

  48.         child.append(4)

  49.         self.assertEquals([2, 3, 4], child)

  50.         self.assertEquals([0, 1, 2, 3, 4], parent)

  51. 

  52.     def test_parent_get_set_del(self):

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

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

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

  56.         def delete(L, s1):

  57.             del L[s1]

  58. 

  59.         list1 = SmartList([0, 1, 2, 3, "one", "two"])

  60.         list2 = SmartList(list(range(10)))

  61. 

  62.         self.assertEquals(1, list1[1])

  63.         self.assertEquals("one", list1[-2])

  64.         self.assertEquals([2, 3], list1[2:4])

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

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

  67. 

  68.         self.assertEquals([0, 1, 2], list1[:3])

  69.         self.assertEquals([0, 1, 2, 3, "one", "two"], list1[:])

  70.         self.assertEquals([3, "one", "two"], list1[3:])

  71.         self.assertEquals(["one", "two"], list1[-2:])

  72.         self.assertEquals([0, 1], list1[:-4])

  73.         self.assertEquals([], list1[6:])

  74.         self.assertEquals([], list1[4:2])

  75. 

  76.         self.assertEquals([0, 2, "one"], list1[0:5:2])

  77.         self.assertEquals([0, 2], list1[0:-3:2])

  78.         self.assertEquals([0, 1, 2, 3, "one", "two"], list1[::])

  79.         self.assertEquals([2, 3, "one", "two"], list1[2::])

  80.         self.assertEquals([0, 1, 2, 3], list1[:4:])

  81.         self.assertEquals([2, 3], list1[2:4:])

  82.         self.assertEquals([0, 2, 4, 6, 8], list2[::2])

  83.         self.assertEquals([2, 5, 8], list2[2::3])

  84.         self.assertEquals([0, 3], list2[:6:3])

  85.         self.assertEquals([2, 5, 8], list2[-8:9:3])

  86.         self.assertEquals([], list2[100000:1000:-100])

  87. 

  88.         list1[3] = 100

  89.         self.assertEquals(100, list1[3])

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

  91.         self.assertEquals([6, 7, 8], list1[5:])

  92.         self.assertEquals([0, 1, 2, 100, "one", 6, 7, 8], list1)

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

  94.         self.assertEquals([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)

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

  96.         self.assertEquals([99, 6, 7, 8], list1)

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

  98.         self.assertEquals([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)

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

  100.         self.assertEquals([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)

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

  102.         self.assertEquals([0, 1, 2, 3, 4, 5, 6], list2)

  103.         self.assertRaises(ValueError,

  104.                           lambda: assign(list2, 0, 5, 2, [100, 102, 104, 106]))

  105. 

  106.         del list2[2]

  107.         self.assertEquals([0, 1, 3, 4, 5, 6], list2)

  108.         del list2[-3]

  109.         self.assertEquals([0, 1, 3, 5, 6], list2)

  110.         self.assertRaises(IndexError, lambda: delete(list2, 100))

  111.         self.assertRaises(IndexError, lambda: delete(list2, -6))

  112.         list2[:] = range(10)

  113.         del list2[3:6]

  114.         self.assertEquals([0, 1, 2, 6, 7, 8, 9], list2)

  115.         del list2[-2:]

  116.         self.assertEquals([0, 1, 2, 6, 7], list2)

  117.         del list2[:2]

  118.         self.assertEquals([2, 6, 7], list2)

  119.         list2[:] = range(10)

  120.         del list2[2:8:2]

  121.         self.assertEquals([0, 1, 3, 5, 7, 8, 9], list2)

  122. 

  123.     def test_parent_add(self):

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

  125.         list1 = SmartList(range(5))

  126.         list2 = SmartList(range(5, 10))

  127.         self.assertEquals([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])

  128.         self.assertEquals([0, 1, 2, 3, 4], list1)

  129.         self.assertEquals(list(range(10)), list1 + list2)

  130.         self.assertEquals([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)

  131.         self.assertEquals([0, 1, 2, 3, 4], list1)

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

  133.         self.assertEquals([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)

  134. 

  135.     def test_parent_unaffected_magics(self):

  136.         """sanity checks against SmartList features that were not modified"""

  137.         list1 = SmartList([0, 1, 2, 3, "one", "two"])

  138.         list2 = SmartList([])

  139.         list3 = SmartList([0, 2, 3, 4])

  140.         list4 = SmartList([0, 1, 2])

  141. 

  142.         if py3k:

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

  144.             self.assertEquals(b"[0, 1, 2, 3, 'one', 'two']", bytes(list1))

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

  146.         else:

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

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

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

  150. 

  151.         self.assertTrue(list1 < list3)

  152.         self.assertTrue(list1 <= list3)

  153.         self.assertFalse(list1 == list3)

  154.         self.assertTrue(list1 != list3)

  155.         self.assertFalse(list1 > list3)

  156.         self.assertFalse(list1 >= list3)

  157. 

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

  159.         self.assertTrue(list1 < other1)

  160.         self.assertTrue(list1 <= other1)

  161.         self.assertFalse(list1 == other1)

  162.         self.assertTrue(list1 != other1)

  163.         self.assertFalse(list1 > other1)

  164.         self.assertFalse(list1 >= other1)

  165. 

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

  167.         self.assertFalse(list1 < other2)

  168.         self.assertFalse(list1 <= other2)

  169.         self.assertFalse(list1 == other2)

  170.         self.assertTrue(list1 != other2)

  171.         self.assertTrue(list1 > other2)

  172.         self.assertTrue(list1 >= other2)

  173. 

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

  175.         self.assertFalse(list1 < other3)

  176.         self.assertTrue(list1 <= other3)

  177.         self.assertTrue(list1 == other3)

  178.         self.assertFalse(list1 != other3)

  179.         self.assertFalse(list1 > other3)

  180.         self.assertTrue(list1 >= other3)

  181. 

  182.         self.assertTrue(bool(list1))

  183.         self.assertFalse(bool(list2))

  184. 

  185.         self.assertEquals(6, len(list1))

  186.         self.assertEquals(0, len(list2))

  187. 

  188.         out = []

  189.         for obj in list1:

  190.             out.append(obj)

  191.         self.assertEquals([0, 1, 2, 3, "one", "two"], out)

  192. 

  193.         out = []

  194.         for ch in list2:

  195.             out.append(ch)

  196.         self.assertEquals([], out)

  197. 

  198.         gen1 = iter(list1)

  199.         out = []

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

  201.             out.append(gen1.next())

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

  203.         self.assertEquals([0, 1, 2, 3, "one", "two"], out)

  204.         gen2 = iter(list2)

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

  206. 

  207.         self.assertEquals(["two", "one", 3, 2, 1, 0], list(reversed(list1)))

  208.         self.assertEquals([], list(reversed(list2)))

  209. 

  210.         self.assertTrue("one" in list1)

  211.         self.assertTrue(3 in list1)

  212.         self.assertFalse(10 in list1)

  213.         self.assertFalse(0 in list2)

  214. 

  215.         self.assertEquals([], list2 * 5)

  216.         self.assertEquals([], 5 * list2)

  217.         self.assertEquals([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)

  218.         self.assertEquals([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)

  219.         list4 *= 2

  220.         self.assertEquals([0, 1, 2, 0, 1, 2], list4)

  221. 

  222.     def test_parent_methods(self):

  223.         pass

  224.         # append

  225.         # count

  226.         # extend

  227.         # index

  228.         # insert

  229.         # pop

  230.         # remove

  231.         # reverse

  232.         # sort

  233. 

  234.     def test_child_magics(self):

  235.         pass

  236.         # if py3k:

  237.         #     __str__

  238.         #     __bytes__

  239.         # else:

  240.         #     __unicode__

  241.         #     __str__

  242.         # __repr__

  243.         # __lt__

  244.         # __le__

  245.         # __eq__

  246.         # __ne__

  247.         # __gt__

  248.         # __ge__

  249.         # if py3k:

  250.         #     __bool__

  251.         # else:

  252.         #     __nonzero__

  253.         # __len__

  254.         # __getitem__

  255.         # __setitem__

  256.         # __delitem__

  257.         # __iter__

  258.         # __reversed__

  259.         # __contains__

  260.         # if not py3k:

  261.         #     __getslice__

  262.         #     __setslice__

  263.         #     __delslice__

  264.         # __add__

  265.         # __radd__

  266.         # __iadd__

  267.         # __mul__

  268.         # __rmul__

  269.         # __imul__

  270. 

  271.     def test_child_methods(self):

  272.         pass

  273.         # append

  274.         # count

  275.         # extend

  276.         # index

  277.         # insert

  278.         # pop

  279.         # remove

  280.         # reverse

  281.         # sort

  282. 

  283.     def test_influence(self):

  284.         pass

  285.         # test whether changes are propogated correctly

  286.         # also test whether children that exit scope are removed from parent's map

  287. 

  288. if __name__ == "__main__":

  289.     unittest.main(verbosity=2)