Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_pyexpat.py

    r2 r391  
    55import unittest
    66
    7 import pyexpat
    87from xml.parsers import expat
    98
     9from test import test_support
    1010from test.test_support import sortdict, run_unittest
    1111
    … …  
    2424        for x, y in self.set_get_pairs:
    2525            self.parser.returns_unicode = x
    26             self.assertEquals(self.parser.returns_unicode, y)
     26            self.assertEqual(self.parser.returns_unicode, y)
    2727
    2828    def test_ordered_attributes(self):
    2929        for x, y in self.set_get_pairs:
    3030            self.parser.ordered_attributes = x
    31             self.assertEquals(self.parser.ordered_attributes, y)
     31            self.assertEqual(self.parser.ordered_attributes, y)
    3232
    3333    def test_specified_attributes(self):
    3434        for x, y in self.set_get_pairs:
    3535            self.parser.specified_attributes = x
    36             self.assertEquals(self.parser.specified_attributes, y)
     36            self.assertEqual(self.parser.specified_attributes, y)
    3737
    3838
    … …  
    142142        # Verify output
    143143        op = out.out
    144         self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
    145         self.assertEquals(op[1], "Comment: ' comment data '")
    146         self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
    147         self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
    148         self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}")
    149         self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
    150         self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
    151         self.assertEquals(op[7], "Character data: 'Contents of subelements'")
    152         self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'")
    153         self.assertEquals(op[9], "End of NS decl: 'myns'")
    154         self.assertEquals(op[10], "Start element: 'sub2' {}")
    155         self.assertEquals(op[11], 'Start of CDATA section')
    156         self.assertEquals(op[12], "Character data: 'contents of CDATA section'")
    157         self.assertEquals(op[13], 'End of CDATA section')
    158         self.assertEquals(op[14], "End element: 'sub2'")
    159         self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)")
    160         self.assertEquals(op[16], "End element: 'root'")
     144        self.assertEqual(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
     145        self.assertEqual(op[1], "Comment: ' comment data '")
     146        self.assertEqual(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
     147        self.assertEqual(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
     148        self.assertEqual(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}")
     149        self.assertEqual(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
     150        self.assertEqual(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
     151        self.assertEqual(op[7], "Character data: 'Contents of subelements'")
     152        self.assertEqual(op[8], "End element: 'http://www.python.org/namespace!subelement'")
     153        self.assertEqual(op[9], "End of NS decl: 'myns'")
     154        self.assertEqual(op[10], "Start element: 'sub2' {}")
     155        self.assertEqual(op[11], 'Start of CDATA section')
     156        self.assertEqual(op[12], "Character data: 'contents of CDATA section'")
     157        self.assertEqual(op[13], 'End of CDATA section')
     158        self.assertEqual(op[14], "End element: 'sub2'")
     159        self.assertEqual(op[15], "External entity ref: (None, 'entity.file', None)")
     160        self.assertEqual(op[16], "End element: 'root'")
    161161
    162162    def test_unicode(self):
    … …  
    171171
    172172        op = out.out
    173         self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
    174         self.assertEquals(op[1], "Comment: u' comment data '")
    175         self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
    176         self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
    177         self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
    178         self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
    179         self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
    180         self.assertEquals(op[7], "Character data: u'Contents of subelements'")
    181         self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
    182         self.assertEquals(op[9], "End of NS decl: u'myns'")
    183         self.assertEquals(op[10], "Start element: u'sub2' {}")
    184         self.assertEquals(op[11], 'Start of CDATA section')
    185         self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
    186         self.assertEquals(op[13], 'End of CDATA section')
    187         self.assertEquals(op[14], "End element: u'sub2'")
    188         self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
    189         self.assertEquals(op[16], "End element: u'root'")
     173        self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
     174        self.assertEqual(op[1], "Comment: u' comment data '")
     175        self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
     176        self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
     177        self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
     178        self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
     179        self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
     180        self.assertEqual(op[7], "Character data: u'Contents of subelements'")
     181        self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'")
     182        self.assertEqual(op[9], "End of NS decl: u'myns'")
     183        self.assertEqual(op[10], "Start element: u'sub2' {}")
     184        self.assertEqual(op[11], 'Start of CDATA section')
     185        self.assertEqual(op[12], "Character data: u'contents of CDATA section'")
     186        self.assertEqual(op[13], 'End of CDATA section')
     187        self.assertEqual(op[14], "End element: u'sub2'")
     188        self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)")
     189        self.assertEqual(op[16], "End element: u'root'")
    190190
    191191    def test_parse_file(self):
    … …  
    201201
    202202        op = out.out
    203         self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
    204         self.assertEquals(op[1], "Comment: u' comment data '")
    205         self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
    206         self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
    207         self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
    208         self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
    209         self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
    210         self.assertEquals(op[7], "Character data: u'Contents of subelements'")
    211         self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
    212         self.assertEquals(op[9], "End of NS decl: u'myns'")
    213         self.assertEquals(op[10], "Start element: u'sub2' {}")
    214         self.assertEquals(op[11], 'Start of CDATA section')
    215         self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
    216         self.assertEquals(op[13], 'End of CDATA section')
    217         self.assertEquals(op[14], "End element: u'sub2'")
    218         self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
    219         self.assertEquals(op[16], "End element: u'root'")
     203        self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
     204        self.assertEqual(op[1], "Comment: u' comment data '")
     205        self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
     206        self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
     207        self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
     208        self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
     209        self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
     210        self.assertEqual(op[7], "Character data: u'Contents of subelements'")
     211        self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'")
     212        self.assertEqual(op[9], "End of NS decl: u'myns'")
     213        self.assertEqual(op[10], "Start element: u'sub2' {}")
     214        self.assertEqual(op[11], 'Start of CDATA section')
     215        self.assertEqual(op[12], "Character data: u'contents of CDATA section'")
     216        self.assertEqual(op[13], 'End of CDATA section')
     217        self.assertEqual(op[14], "End element: u'sub2'")
     218        self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)")
     219        self.assertEqual(op[16], "End element: u'root'")
     220
     221        # Issue 4877: expat.ParseFile causes segfault on a closed file.
     222        fp = open(test_support.TESTFN, 'wb')
     223        try:
     224            fp.close()
     225            parser = expat.ParserCreate()
     226            with self.assertRaises(ValueError):
     227                parser.ParseFile(fp)
     228        finally:
     229            test_support.unlink(test_support.TESTFN)
    220230
    221231
    … …  
    233243            self.fail()
    234244        except TypeError, e:
    235             self.assertEquals(str(e),
     245            self.assertEqual(str(e),
    236246                'ParserCreate() argument 2 must be string or None, not int')
    237247
    … …  
    240250            self.fail()
    241251        except ValueError, e:
    242             self.assertEquals(str(e),
     252            self.assertEqual(str(e),
    243253                'namespace_separator must be at most one character, omitted, or None')
    244254
    … …  
    266276        p.Parse("<e> <e/> <e></e> </e>", 1)
    267277        tag = L[0]
    268         self.assertEquals(len(L), 6)
     278        self.assertEqual(len(L), 6)
    269279        for entry in L:
    270280            # L should have the same string repeated over and over.
    … …  
    280290
    281291    def check(self, expected, label):
    282         self.assertEquals(self.stuff, expected,
     292        self.assertEqual(self.stuff, expected,
    283293                "%s\nstuff    = %r\nexpected = %r"
    284294                % (label, self.stuff, map(unicode, expected)))
    … …  
    313323        self.assertTrue(self.parser.buffer_text)
    314324        self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
    315         self.assertEquals(self.stuff, ['123'],
    316                           "buffered text not properly collapsed")
     325        self.assertEqual(self.stuff, ['123'],
     326                         "buffered text not properly collapsed")
    317327
    318328    def test1(self):
    … …  
    321331        self.setHandlers(["StartElementHandler"])
    322332        self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
    323         self.assertEquals(self.stuff,
    324                           ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
    325                           "buffering control not reacting as expected")
     333        self.assertEqual(self.stuff,
     334                         ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
     335                         "buffering control not reacting as expected")
    326336
    327337    def test2(self):
    328338        self.parser.Parse("<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", 1)
    329         self.assertEquals(self.stuff, ["1<2> \n 3"],
    330                           "buffered text not properly collapsed")
     339        self.assertEqual(self.stuff, ["1<2> \n 3"],
     340                         "buffered text not properly collapsed")
    331341
    332342    def test3(self):
    333343        self.setHandlers(["StartElementHandler"])
    334344        self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
    335         self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
     345        self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
    336346                          "buffered text not properly split")
    337347
    … …  
    340350        self.parser.CharacterDataHandler = None
    341351        self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
    342         self.assertEquals(self.stuff,
    343                           ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
     352        self.assertEqual(self.stuff,
     353                         ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
    344354
    345355    def test5(self):
    346356        self.setHandlers(["StartElementHandler", "EndElementHandler"])
    347357        self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
    348         self.assertEquals(self.stuff,
     358        self.assertEqual(self.stuff,
    349359            ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
    350360
    … …  
    353363                    "StartElementHandler"])
    354364        self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
    355         self.assertEquals(self.stuff,
     365        self.assertEqual(self.stuff,
    356366            ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
    357367            "buffered text not properly split")
    … …  
    361371                    "StartElementHandler"])
    362372        self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1)
    363         self.assertEquals(self.stuff,
    364                           ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
    365                            "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
    366                           "buffered text not properly split")
     373        self.assertEqual(self.stuff,
     374                         ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
     375                          "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
     376                         "buffered text not properly split")
    367377
    368378
    … …  
    379389            self.fail()
    380390        except RuntimeError, e:
    381             self.assertEquals(e.args[0], 'a',
    382                               "Expected RuntimeError for element 'a', but" + \
    383                               " found %r" % e.args[0])
     391            self.assertEqual(e.args[0], 'a',
     392                             "Expected RuntimeError for element 'a', but" + \
     393                             " found %r" % e.args[0])
    384394
    385395
    … …  
    400410                        'too many parser events')
    401411        expected = self.expected_list[self.upto]
    402         self.assertEquals(pos, expected,
     412        self.assertEqual(pos, expected,
    403413                'Expected position %s, got position %s' %(pos, expected))
    404414        self.upto += 1
    … …  
    441451
    442452    def test_1025_bytes(self):
    443         self.assertEquals(self.small_buffer_test(1025), 2)
     453        self.assertEqual(self.small_buffer_test(1025), 2)
    444454
    445455    def test_1000_bytes(self):
    446         self.assertEquals(self.small_buffer_test(1000), 1)
     456        self.assertEqual(self.small_buffer_test(1000), 1)
    447457
    448458    def test_wrong_size(self):
    … …  
    468478        self.n = 0
    469479        parser.Parse(xml1)
    470         self.assertEquals(self.n, 1)
     480        self.assertEqual(self.n, 1)
    471481
    472482        # Reassign to buffer_size, but assign the same size.
    473483        parser.buffer_size = parser.buffer_size
    474         self.assertEquals(self.n, 1)
     484        self.assertEqual(self.n, 1)
    475485
    476486        # Try parsing rest of the document
    477487        parser.Parse(xml2)
    478         self.assertEquals(self.n, 2)
     488        self.assertEqual(self.n, 2)
    479489
    480490
    … …  
    487497        parser.buffer_text = 1
    488498        parser.buffer_size = 1024
    489         self.assertEquals(parser.buffer_size, 1024)
     499        self.assertEqual(parser.buffer_size, 1024)
    490500
    491501        # Parse one chunk of XML
    492502        self.n = 0
    493503        parser.Parse(xml1, 0)
    494         self.assertEquals(parser.buffer_size, 1024)
    495         self.assertEquals(self.n, 1)
     504        self.assertEqual(parser.buffer_size, 1024)
     505        self.assertEqual(self.n, 1)
    496506
    497507        # Turn off buffering and parse the next chunk.
    498508        parser.buffer_text = 0
    499509        self.assertFalse(parser.buffer_text)
    500         self.assertEquals(parser.buffer_size, 1024)
     510        self.assertEqual(parser.buffer_size, 1024)
    501511        for i in range(10):
    502512            parser.Parse(xml2, 0)
    503         self.assertEquals(self.n, 11)
     513        self.assertEqual(self.n, 11)
    504514
    505515        parser.buffer_text = 1
    506516        self.assertTrue(parser.buffer_text)
    507         self.assertEquals(parser.buffer_size, 1024)
     517        self.assertEqual(parser.buffer_size, 1024)
    508518        parser.Parse(xml3, 1)
    509         self.assertEquals(self.n, 12)
     519        self.assertEqual(self.n, 12)
    510520
    511521
    … …  
    535545        parser.buffer_text = 1
    536546        parser.buffer_size = 1024
    537         self.assertEquals(parser.buffer_size, 1024)
     547        self.assertEqual(parser.buffer_size, 1024)
    538548
    539549        self.n = 0
    540550        parser.Parse(xml1, 0)
    541551        parser.buffer_size *= 2
    542         self.assertEquals(parser.buffer_size, 2048)
     552        self.assertEqual(parser.buffer_size, 2048)
    543553        parser.Parse(xml2, 1)
    544         self.assertEquals(self.n, 2)
     554        self.assertEqual(self.n, 2)
    545555
    546556    def test_change_size_2(self):
    … …  
    551561        parser.buffer_text = 1
    552562        parser.buffer_size = 2048
    553         self.assertEquals(parser.buffer_size, 2048)
     563        self.assertEqual(parser.buffer_size, 2048)
    554564
    555565        self.n=0
    556566        parser.Parse(xml1, 0)
    557         parser.buffer_size /= 2
    558         self.assertEquals(parser.buffer_size, 1024)
     567        parser.buffer_size //= 2
     568        self.assertEqual(parser.buffer_size, 1024)
    559569        parser.Parse(xml2, 1)
    560         self.assertEquals(self.n, 4)
     570        self.assertEqual(self.n, 4)
    561571
    562572class MalformedInputText(unittest.TestCase):
    … …  
    568578            self.fail()
    569579        except expat.ExpatError as e:
    570             self.assertEquals(str(e), 'unclosed token: line 2, column 0')
     580            self.assertEqual(str(e), 'unclosed token: line 2, column 0')
    571581
    572582    def test2(self):
    … …  
    577587            self.fail()
    578588        except expat.ExpatError as e:
    579             self.assertEquals(str(e), 'XML declaration not well-formed: line 1, column 14')
     589            self.assertEqual(str(e), 'XML declaration not well-formed: line 1, column 14')
     590
     591class ForeignDTDTests(unittest.TestCase):
     592    """
     593    Tests for the UseForeignDTD method of expat parser objects.
     594    """
     595    def test_use_foreign_dtd(self):
     596        """
     597        If UseForeignDTD is passed True and a document without an external
     598        entity reference is parsed, ExternalEntityRefHandler is first called
     599        with None for the public and system ids.
     600        """
     601        handler_call_args = []
     602        def resolve_entity(context, base, system_id, public_id):
     603            handler_call_args.append((public_id, system_id))
     604            return 1
     605
     606        parser = expat.ParserCreate()
     607        parser.UseForeignDTD(True)
     608        parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_ALWAYS)
     609        parser.ExternalEntityRefHandler = resolve_entity
     610        parser.Parse("<?xml version='1.0'?><element/>")
     611        self.assertEqual(handler_call_args, [(None, None)])
     612
     613        # test UseForeignDTD() is equal to UseForeignDTD(True)
     614        handler_call_args[:] = []
     615
     616        parser = expat.ParserCreate()
     617        parser.UseForeignDTD()
     618        parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_ALWAYS)
     619        parser.ExternalEntityRefHandler = resolve_entity
     620        parser.Parse("<?xml version='1.0'?><element/>")
     621        self.assertEqual(handler_call_args, [(None, None)])
     622
     623    def test_ignore_use_foreign_dtd(self):
     624        """
     625        If UseForeignDTD is passed True and a document with an external
     626        entity reference is parsed, ExternalEntityRefHandler is called with
     627        the public and system ids from the document.
     628        """
     629        handler_call_args = []
     630        def resolve_entity(context, base, system_id, public_id):
     631            handler_call_args.append((public_id, system_id))
     632            return 1
     633
     634        parser = expat.ParserCreate()
     635        parser.UseForeignDTD(True)
     636        parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_ALWAYS)
     637        parser.ExternalEntityRefHandler = resolve_entity
     638        parser.Parse(
     639            "<?xml version='1.0'?><!DOCTYPE foo PUBLIC 'bar' 'baz'><element/>")
     640        self.assertEqual(handler_call_args, [("bar", "baz")])
     641
    580642
    581643def test_main():
    … …  
    589651                 sf1296433Test,
    590652                 ChardataBufferTest,
    591                  MalformedInputText)
     653                 MalformedInputText,
     654                 ForeignDTDTests)
    592655
    593656if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.