From 6bf8cfd2adcf536113f3a9ace3901b08540d7ff9 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 20 Apr 2013 18:09:34 -0400 Subject: [PATCH] Fix tests for Python 3. --- mwparserfromhell/nodes/html_entity.py | 55 ++++++++++++++++++----------------- tests/test_html_entity.py | 28 +++++++++--------- 2 files changed, 43 insertions(+), 40 deletions(-) diff --git a/mwparserfromhell/nodes/html_entity.py b/mwparserfromhell/nodes/html_entity.py index 1bf1c78..b51bd92 100644 --- a/mwparserfromhell/nodes/html_entity.py +++ b/mwparserfromhell/nodes/html_entity.py @@ -23,7 +23,7 @@ from __future__ import unicode_literals from . import Node -from ..compat import htmlentities, str +from ..compat import htmlentities, py3k, str __all__ = ["HTMLEntity"] @@ -63,29 +63,31 @@ class HTMLEntity(Node): return self.normalize() return self - @staticmethod - def _unichr(value): - """Implement the builtin unichr() with support for non-BMP code points. + if not py3k: + @staticmethod + def _unichr(value): + """Implement builtin unichr() with support for non-BMP code points. - On wide Python builds, this functions like the normal unichr(). On - narrow builds, this returns the value's corresponding surrogate pair. - """ - try: - return unichr(value) - except ValueError: - # Test whether we're on the wide or narrow Python build. Check the - # length of a non-BMP code point (U+1F64A, SPEAK-NO-EVIL MONKEY): - if len("\U0001F64A") == 2: - # Ensure this is within the range we can encode: - if value > 0x10FFFF: - raise ValueError("unichr() arg not in range(0x110000)") - code = value - 0x10000 - if value < 0: # Invalid code point - raise - lead = 0xD800 + (code >> 10) - trail = 0xDC00 + (code % (1 << 10)) - return unichr(lead) + unichr(trail) - raise + On wide Python builds, this functions like the normal unichr(). On + narrow builds, this returns the value's encoded surrogate pair. + """ + try: + return unichr(value) + except ValueError: + # Test whether we're on the wide or narrow Python build. Check + # the length of a non-BMP code point + # (U+1F64A, SPEAK-NO-EVIL MONKEY): + if len("\U0001F64A") == 2: + # Ensure this is within the range we can encode: + if value > 0x10FFFF: + raise ValueError("unichr() arg not in range(0x110000)") + code = value - 0x10000 + if value < 0: # Invalid code point + raise + lead = 0xD800 + (code >> 10) + trail = 0xDC00 + (code % (1 << 10)) + return unichr(lead) + unichr(trail) + raise @property def value(self): @@ -171,8 +173,9 @@ class HTMLEntity(Node): def normalize(self): """Return the unicode character represented by the HTML entity.""" + chrfunc = chr if py3k else HTMLEntity._unichr if self.named: - return unichr(htmlentities.name2codepoint[self.value]) + return chrfunc(htmlentities.name2codepoint[self.value]) if self.hexadecimal: - return HTMLEntity._unichr(int(self.value, 16)) - return HTMLEntity._unichr(int(self.value)) + return chrfunc(int(self.value, 16)) + return chrfunc(int(self.value)) diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index 20c8fc0..4bf32e8 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -82,20 +82,20 @@ class TestHTMLEntity(TreeEqualityTestCase): node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") - self.assertEquals("nbsp", node1.value) - self.assertEquals("107", node2.value) - self.assertEquals("e9", node3.value) + self.assertEqual("nbsp", node1.value) + self.assertEqual("107", node2.value) + self.assertEqual("e9", node3.value) node1.value = "ffa4" node2.value = 72 node3.value = "Sigma" - self.assertEquals("ffa4", node1.value) + self.assertEqual("ffa4", node1.value) self.assertFalse(node1.named) self.assertTrue(node1.hexadecimal) - self.assertEquals("72", node2.value) + self.assertEqual("72", node2.value) self.assertFalse(node2.named) self.assertFalse(node2.hexadecimal) - self.assertEquals("Sigma", node3.value) + self.assertEqual("Sigma", node3.value) self.assertTrue(node3.named) self.assertFalse(node3.hexadecimal) @@ -147,12 +147,12 @@ class TestHTMLEntity(TreeEqualityTestCase): """test HTMLEntity.hex_char()""" node1 = HTMLEntity("e9") node2 = HTMLEntity("e9", hex_char="X") - self.assertEquals("x", node1.hex_char) - self.assertEquals("X", node2.hex_char) + self.assertEqual("x", node1.hex_char) + self.assertEqual("X", node2.hex_char) node1.hex_char = "X" node2.hex_char = "x" - self.assertEquals("X", node1.hex_char) - self.assertEquals("x", node2.hex_char) + self.assertEqual("X", node1.hex_char) + self.assertEqual("x", node2.hex_char) self.assertRaises(ValueError, setattr, node1, "hex_char", 123) self.assertRaises(ValueError, setattr, node1, "hex_char", "foobar") self.assertRaises(ValueError, setattr, node1, "hex_char", True) @@ -163,10 +163,10 @@ class TestHTMLEntity(TreeEqualityTestCase): node2 = HTMLEntity("107") node3 = HTMLEntity("e9") node4 = HTMLEntity("1f648") - self.assertEquals("\xa0", node1.normalize()) - self.assertEquals("k", node2.normalize()) - self.assertEquals("é", node3.normalize()) - self.assertEquals("\U0001F648", node4.normalize()) + self.assertEqual("\xa0", node1.normalize()) + self.assertEqual("k", node2.normalize()) + self.assertEqual("é", node3.normalize()) + self.assertEqual("\U0001F648", node4.normalize()) if __name__ == "__main__": unittest.main(verbosity=2)