ben
/
mwparserfromhell
espelho de https://github.com/earwig/mwparserfromhell
1
1
Derivar 0
Código Lançamentos 24 Trabalho
A Python parser for MediaWiki wikicode https://mwparserfromhell.readthedocs.io/
Não pode escolher mais do que 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
823 Cometimentos
1 Ramo
5.8 MiB
 
 
 
 
Árvore: e457b39f32
Ramos Etiquetas
${ item.name }
Criar ramo ${ searchTerm }
de 'e457b39f32'
${ noResults }
mwparserfromhell/tests/test_smart_list.py

422 linhas
16 KiB
Em bruto Responsabilidade Histórico 

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

  32.     def _test_get_set_del_item(self, builder):

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

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

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

  36.         def delete(L, s1):

  37.             del L[s1]

  38. 

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

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

  41. 

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

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

  44.         self.assertEqual([2, 3], list1[2:4])

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

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

  47. 

  48.         self.assertEqual([0, 1, 2], list1[:3])

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

  50.         self.assertEqual([3, "one", "two"], list1[3:])

  51.         self.assertEqual([3, "one", "two"], list1[3:100])

  52.         self.assertEqual(["one", "two"], list1[-2:])

  53.         self.assertEqual([0, 1], list1[:-4])

  54.         self.assertEqual([], list1[6:])

  55.         self.assertEqual([], list1[4:2])

  56. 

  57.         self.assertEqual([0, 2, "one"], list1[0:5:2])

  58.         self.assertEqual([0, 2], list1[0:-3:2])

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

  60.         self.assertEqual([2, 3, "one", "two"], list1[2::])

  61.         self.assertEqual([0, 1, 2, 3], list1[:4:])

  62.         self.assertEqual([2, 3], list1[2:4:])

  63.         self.assertEqual([0, 2, 4, 6, 8], list2[::2])

  64.         self.assertEqual([2, 5, 8], list2[2::3])

  65.         self.assertEqual([0, 3], list2[:6:3])

  66.         self.assertEqual([2, 5, 8], list2[-8:9:3])

  67.         self.assertEqual([], list2[100000:1000:-100])

  68. 

  69.         list1[3] = 100

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

  71.         list1[-3] = 101

  72.         self.assertEqual([0, 1, 2, 101, "one", "two"], list1)

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

  74.         self.assertEqual([6, 7, 8], list1[5:])

  75.         self.assertEqual([0, 1, 2, 101, "one", 6, 7, 8], list1)

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

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

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

  79.         self.assertEqual([99, 6, 7, 8], list1)

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

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

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

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

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

  85.         self.assertEqual([0, 1, 2, 3, 4, 5, 6], list2)

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

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

  88.         with self.assertRaises(IndexError):

  89.             list2[7] = "foo"

  90.         with self.assertRaises(IndexError):

  91.             list2[-8] = "foo"

  92. 

  93.         del list2[2]

  94.         self.assertEqual([0, 1, 3, 4, 5, 6], list2)

  95.         del list2[-3]

  96.         self.assertEqual([0, 1, 3, 5, 6], list2)

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

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

  99.         list2[:] = range(10)

  100.         del list2[3:6]

  101.         self.assertEqual([0, 1, 2, 6, 7, 8, 9], list2)

  102.         del list2[-2:]

  103.         self.assertEqual([0, 1, 2, 6, 7], list2)

  104.         del list2[:2]

  105.         self.assertEqual([2, 6, 7], list2)

  106.         list2[:] = range(10)

  107.         del list2[2:8:2]

  108.         self.assertEqual([0, 1, 3, 5, 7, 8, 9], list2)

  109. 

  110.     def _test_add_radd_iadd(self, builder):

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

  112.         list1 = builder(range(5))

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

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

  115.         self.assertEqual([0, 1, 2, 3, 4], list1)

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

  117.         self.assertEqual([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)

  118.         self.assertEqual([0, 1, 2, 3, 4], list1)

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

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

  121. 

  122.     def _test_other_magic_methods(self, builder):

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

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

  125.         list2 = builder([])

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

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

  128. 

  129.         if py3k:

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

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

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

  133.         else:

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

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

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

  137. 

  138.         self.assertTrue(list1 < list3)

  139.         self.assertTrue(list1 <= list3)

  140.         self.assertFalse(list1 == list3)

  141.         self.assertTrue(list1 != list3)

  142.         self.assertFalse(list1 > list3)

  143.         self.assertFalse(list1 >= list3)

  144. 

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

  146.         self.assertTrue(list1 < other1)

  147.         self.assertTrue(list1 <= other1)

  148.         self.assertFalse(list1 == other1)

  149.         self.assertTrue(list1 != other1)

  150.         self.assertFalse(list1 > other1)

  151.         self.assertFalse(list1 >= other1)

  152. 

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

  154.         self.assertFalse(list1 < other2)

  155.         self.assertFalse(list1 <= other2)

  156.         self.assertFalse(list1 == other2)

  157.         self.assertTrue(list1 != other2)

  158.         self.assertTrue(list1 > other2)

  159.         self.assertTrue(list1 >= other2)

  160. 

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

  162.         self.assertFalse(list1 < other3)

  163.         self.assertTrue(list1 <= other3)

  164.         self.assertTrue(list1 == other3)

  165.         self.assertFalse(list1 != other3)

  166.         self.assertFalse(list1 > other3)

  167.         self.assertTrue(list1 >= other3)

  168. 

  169.         self.assertTrue(bool(list1))

  170.         self.assertFalse(bool(list2))

  171. 

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

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

  174. 

  175.         out = []

  176.         for obj in list1:

  177.             out.append(obj)

  178.         self.assertEqual([0, 1, 2, 3, "one", "two"], out)

  179. 

  180.         out = []

  181.         for ch in list2:

  182.             out.append(ch)

  183.         self.assertEqual([], out)

  184. 

  185.         gen1 = iter(list1)

  186.         out = []

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

  188.             out.append(next(gen1))

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

  190.         self.assertEqual([0, 1, 2, 3, "one", "two"], out)

  191.         gen2 = iter(list2)

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

  193. 

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

  195.         self.assertEqual([], list(reversed(list2)))

  196. 

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

  198.         self.assertTrue(3 in list1)

  199.         self.assertFalse(10 in list1)

  200.         self.assertFalse(0 in list2)

  201. 

  202.         self.assertEqual([], list2 * 5)

  203.         self.assertEqual([], 5 * list2)

  204.         self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)

  205.         self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)

  206.         list4 *= 2

  207.         self.assertEqual([0, 1, 2, 0, 1, 2], list4)

  208. 

  209.     def _test_list_methods(self, builder):

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

  211.         list1 = builder(range(5))

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

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

  214. 

  215.         list1.append(5)

  216.         list1.append(1)

  217.         list1.append(2)

  218.         self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2], list1)

  219. 

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

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

  222. 

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

  224.         self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)

  225. 

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

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

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

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

  230. 

  231.         list1.insert(0, -1)

  232.         self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)

  233.         list1.insert(-1, 6.5)

  234.         self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)

  235.         list1.insert(13, 8)

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

  237. 

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

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

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

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

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

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

  244.         self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)

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

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

  247.         self.assertEqual([], list2)

  248. 

  249.         list1.remove(6)

  250.         self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5], list1)

  251.         list1.remove(1)

  252.         self.assertEqual([0, 2, 3, 4, 1, 2, 5], list1)

  253.         list1.remove(1)

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

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

  256. 

  257.         list1.reverse()

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

  259. 

  260.         list1.sort()

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

  262.         list1.sort(reverse=True)

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

  264.         if not py3k:

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

  266.             list1.sort(cmp=func)

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

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

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

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

  271.         self.assertEqual([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)

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

  273.         self.assertEqual([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)

  274. 

  275.     def _dispatch_test_for_children(self, meth):

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

  277.         meth(lambda L: SmartList(list(L))[:])

  278.         meth(lambda L: SmartList([999] + list(L))[1:])

  279.         meth(lambda L: SmartList(list(L) + [999])[:-1])

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

  281. 

  282.     def test_docs(self):

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

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

  285.                    "remove", "reverse", "sort"]

  286.         for meth in methods:

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

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

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

  290.             self.assertEqual(expected, smartlist_doc)

  291.             self.assertEqual(expected, listproxy_doc)

  292. 

  293.     def test_doctest(self):

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

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

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

  297.         child = parent[2:]

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

  299.         child.append(4)

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

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

  302. 

  303.     def test_parent_get_set_del(self):

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

  305.         self._test_get_set_del_item(SmartList)

  306. 

  307.     def test_parent_add(self):

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

  309.         self._test_add_radd_iadd(SmartList)

  310. 

  311.     def test_parent_other_magics(self):

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

  313.         self._test_other_magic_methods(SmartList)

  314. 

  315.     def test_parent_methods(self):

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

  317.         self._test_list_methods(SmartList)

  318. 

  319.     def test_child_get_set_del(self):

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

  321.         self._dispatch_test_for_children(self._test_get_set_del_item)

  322. 

  323.     def test_child_add(self):

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

  325.         self._dispatch_test_for_children(self._test_add_radd_iadd)

  326. 

  327.     def test_child_other_magics(self):

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

  329.         self._dispatch_test_for_children(self._test_other_magic_methods)

  330. 

  331.     def test_child_methods(self):

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

  333.         self._dispatch_test_for_children(self._test_list_methods)

  334. 

  335.     def test_influence(self):

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

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

  338.         child1 = parent[2:]

  339.         child2 = parent[2:5]

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

  341.         self.assertEqual([2, 3, 4, 5], child1)

  342.         self.assertEqual([2, 3, 4], child2)

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

  344. 

  345.         parent.append(6)

  346.         child1.append(7)

  347.         child2.append(4.5)

  348.         self.assertEqual([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)

  349.         self.assertEqual([2, 3, 4, 4.5, 5, 6, 7], child1)

  350.         self.assertEqual([2, 3, 4, 4.5], child2)

  351. 

  352.         parent.insert(0, -1)

  353.         parent.insert(4, 2.5)

  354.         parent.insert(10, 6.5)

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

  356.         self.assertEqual([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)

  357.         self.assertEqual([2, 2.5, 3, 4, 4.5], child2)

  358. 

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

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

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

  362.         self.assertEqual([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)

  363.         self.assertEqual([2, 2.5, 3, 4, 5, 6], child1)

  364.         self.assertEqual([2, 2.5, 3, 4], child2)

  365. 

  366.         parent.remove(-1)

  367.         child1.remove(2.5)

  368.         self.assertEqual([0, 1, 2, 3, 4, 5, 6], parent)

  369.         self.assertEqual([2, 3, 4, 5, 6], child1)

  370.         self.assertEqual([2, 3, 4], child2)

  371. 

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

  373.         self.assertEqual([1, 2, 3, 4, 5, 6], parent)

  374.         self.assertEqual([2, 3, 4, 5, 6], child1)

  375.         self.assertEqual([2, 3, 4], child2)

  376. 

  377.         child2.reverse()

  378.         self.assertEqual([1, 4, 3, 2, 5, 6], parent)

  379.         self.assertEqual([4, 3, 2, 5, 6], child1)

  380.         self.assertEqual([4, 3, 2], child2)

  381. 

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

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

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

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

  386.         self.assertEqual([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)

  387.         self.assertEqual([4, 3, 2, 1.9, 1.8], child2)

  388. 

  389.         child3 = parent[9:]

  390.         self.assertEqual([8, 8.1, 8.2], child3)

  391. 

  392.         del parent[8:]

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

  394.         self.assertEqual([4, 3, 2, 1.9, 1.8, 5, 6], child1)

  395.         self.assertEqual([4, 3, 2, 1.9, 1.8], child2)

  396.         self.assertEqual([], child3)

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

  398. 

  399.         del child1

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

  401.         self.assertEqual([4, 3, 2, 1.9, 1.8], child2)

  402.         self.assertEqual([], child3)

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

  404. 

  405.         del child3

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

  407.         self.assertEqual([4, 3, 2, 1.9, 1.8], child2)

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

  409. 

  410.         parent.remove(1.9)

  411.         parent.remove(1.8)

  412.         self.assertEqual([1, 4, 3, 2, 5, 6], parent)

  413.         self.assertEqual([4, 3, 2], child2)

  414. 

  415.         parent.reverse()

  416.         self.assertEqual([6, 5, 2, 3, 4, 1], parent)

  417.         self.assertEqual([4, 3, 2], child2)

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

  419. 

  420. if __name__ == "__main__":

  421.     unittest.main(verbosity=2)