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

    r2 r391  
    1 # regression test for SAX 2.0            -*- coding: iso-8859-1 -*-
    2 # $Id: test_sax.py 61997 2008-03-28 07:36:31Z neal.norwitz $
     1# regression test for SAX 2.0            -*- coding: utf-8 -*-
     2# $Id$
    33
    44from xml.sax import make_parser, ContentHandler, \
    … …  
    1212                             XMLFilterBase
    1313from xml.sax.expatreader import create_parser
     14from xml.sax.handler import feature_namespaces
    1415from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
    1516from cStringIO import StringIO
     17import io
     18import os.path
     19import shutil
     20import test.test_support as support
    1621from test.test_support import findfile, run_unittest
    1722import unittest
    18 import os
     23
     24TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
     25TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")
     26
     27supports_unicode_filenames = True
     28if not os.path.supports_unicode_filenames:
     29    try:
     30        support.TESTFN_UNICODE.encode(support.TESTFN_ENCODING)
     31    except (AttributeError, UnicodeError, TypeError):
     32        # Either the file system encoding is None, or the file name
     33        # cannot be encoded in the file system encoding.
     34        supports_unicode_filenames = False
     35requires_unicode_filenames = unittest.skipUnless(
     36        supports_unicode_filenames,
     37        'Requires unicode filenames support')
    1938
    2039ns_uri = "http://www.python.org/xml-ns/saxtest/"
    … …  
    2746        self.assertRaises(KeyError, attrs.getQNameByName, "attr")
    2847        self.assertRaises(KeyError, attrs.__getitem__, "attr")
    29         self.assertEquals(attrs.getLength(), 0)
    30         self.assertEquals(attrs.getNames(), [])
    31         self.assertEquals(attrs.getQNames(), [])
    32         self.assertEquals(len(attrs), 0)
     48        self.assertEqual(attrs.getLength(), 0)
     49        self.assertEqual(attrs.getNames(), [])
     50        self.assertEqual(attrs.getQNames(), [])
     51        self.assertEqual(len(attrs), 0)
    3352        self.assertFalse(attrs.has_key("attr"))
    34         self.assertEquals(attrs.keys(), [])
    35         self.assertEquals(attrs.get("attrs"), None)
    36         self.assertEquals(attrs.get("attrs", 25), 25)
    37         self.assertEquals(attrs.items(), [])
    38         self.assertEquals(attrs.values(), [])
     53        self.assertEqual(attrs.keys(), [])
     54        self.assertEqual(attrs.get("attrs"), None)
     55        self.assertEqual(attrs.get("attrs", 25), 25)
     56        self.assertEqual(attrs.items(), [])
     57        self.assertEqual(attrs.values(), [])
    3958
    4059    def verify_empty_nsattrs(self, attrs):
    … …  
    4463        self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
    4564        self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
    46         self.assertEquals(attrs.getLength(), 0)
    47         self.assertEquals(attrs.getNames(), [])
    48         self.assertEquals(attrs.getQNames(), [])
    49         self.assertEquals(len(attrs), 0)
     65        self.assertEqual(attrs.getLength(), 0)
     66        self.assertEqual(attrs.getNames(), [])
     67        self.assertEqual(attrs.getQNames(), [])
     68        self.assertEqual(len(attrs), 0)
    5069        self.assertFalse(attrs.has_key((ns_uri, "attr")))
    51         self.assertEquals(attrs.keys(), [])
    52         self.assertEquals(attrs.get((ns_uri, "attr")), None)
    53         self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
    54         self.assertEquals(attrs.items(), [])
    55         self.assertEquals(attrs.values(), [])
     70        self.assertEqual(attrs.keys(), [])
     71        self.assertEqual(attrs.get((ns_uri, "attr")), None)
     72        self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25)
     73        self.assertEqual(attrs.items(), [])
     74        self.assertEqual(attrs.values(), [])
    5675
    5776    def verify_attrs_wattr(self, attrs):
    58         self.assertEquals(attrs.getLength(), 1)
    59         self.assertEquals(attrs.getNames(), ["attr"])
    60         self.assertEquals(attrs.getQNames(), ["attr"])
    61         self.assertEquals(len(attrs), 1)
     77        self.assertEqual(attrs.getLength(), 1)
     78        self.assertEqual(attrs.getNames(), ["attr"])
     79        self.assertEqual(attrs.getQNames(), ["attr"])
     80        self.assertEqual(len(attrs), 1)
    6281        self.assertTrue(attrs.has_key("attr"))
    63         self.assertEquals(attrs.keys(), ["attr"])
    64         self.assertEquals(attrs.get("attr"), "val")
    65         self.assertEquals(attrs.get("attr", 25), "val")
    66         self.assertEquals(attrs.items(), [("attr", "val")])
    67         self.assertEquals(attrs.values(), ["val"])
    68         self.assertEquals(attrs.getValue("attr"), "val")
    69         self.assertEquals(attrs.getValueByQName("attr"), "val")
    70         self.assertEquals(attrs.getNameByQName("attr"), "attr")
    71         self.assertEquals(attrs["attr"], "val")
    72         self.assertEquals(attrs.getQNameByName("attr"), "attr")
     82        self.assertEqual(attrs.keys(), ["attr"])
     83        self.assertEqual(attrs.get("attr"), "val")
     84        self.assertEqual(attrs.get("attr", 25), "val")
     85        self.assertEqual(attrs.items(), [("attr", "val")])
     86        self.assertEqual(attrs.values(), ["val"])
     87        self.assertEqual(attrs.getValue("attr"), "val")
     88        self.assertEqual(attrs.getValueByQName("attr"), "val")
     89        self.assertEqual(attrs.getNameByQName("attr"), "attr")
     90        self.assertEqual(attrs["attr"], "val")
     91        self.assertEqual(attrs.getQNameByName("attr"), "attr")
    7392
    7493class MakeParserTest(unittest.TestCase):
    … …  
    100119    # ===== escape
    101120    def test_escape_basic(self):
    102         self.assertEquals(escape("Donald Duck & Co"), "Donald Duck & Co")
     121        self.assertEqual(escape("Donald Duck & Co"), "Donald Duck & Co")
    103122
    104123    def test_escape_all(self):
    105         self.assertEquals(escape("<Donald Duck & Co>"),
    106                           "&lt;Donald Duck &amp; Co&gt;")
     124        self.assertEqual(escape("<Donald Duck & Co>"),
     125                         "&lt;Donald Duck &amp; Co&gt;")
    107126
    108127    def test_escape_extra(self):
    109         self.assertEquals(escape("Hei på deg", {"å" : "&aring;"}),
    110                           "Hei p&aring; deg")
     128        self.assertEqual(escape("Hei pÃ¥ deg", {"Ã¥" : "&aring;"}),
     129                         "Hei p&aring; deg")
    111130
    112131    # ===== unescape
    113132    def test_unescape_basic(self):
    114         self.assertEquals(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
     133        self.assertEqual(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
    115134
    116135    def test_unescape_all(self):
    117         self.assertEquals(unescape("&lt;Donald Duck &amp; Co&gt;"),
    118                           "<Donald Duck & Co>")
     136        self.assertEqual(unescape("&lt;Donald Duck &amp; Co&gt;"),
     137                         "<Donald Duck & Co>")
    119138
    120139    def test_unescape_extra(self):
    121         self.assertEquals(unescape("Hei på deg", {"å" : "&aring;"}),
    122                           "Hei p&aring; deg")
     140        self.assertEqual(unescape("Hei pÃ¥ deg", {"Ã¥" : "&aring;"}),
     141                         "Hei p&aring; deg")
    123142
    124143    def test_unescape_amp_extra(self):
    125         self.assertEquals(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
     144        self.assertEqual(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
    126145
    127146    # ===== quoteattr
    128147    def test_quoteattr_basic(self):
    129         self.assertEquals(quoteattr("Donald Duck & Co"),
    130                           '"Donald Duck &amp; Co"')
     148        self.assertEqual(quoteattr("Donald Duck & Co"),
     149                         '"Donald Duck &amp; Co"')
    131150
    132151    def test_single_quoteattr(self):
    133         self.assertEquals(quoteattr('Includes "double" quotes'),
    134                           '\'Includes "double" quotes\'')
     152        self.assertEqual(quoteattr('Includes "double" quotes'),
     153                         '\'Includes "double" quotes\'')
    135154
    136155    def test_double_quoteattr(self):
    137         self.assertEquals(quoteattr("Includes 'single' quotes"),
    138                           "\"Includes 'single' quotes\"")
     156        self.assertEqual(quoteattr("Includes 'single' quotes"),
     157                         "\"Includes 'single' quotes\"")
    139158
    140159    def test_single_double_quoteattr(self):
    141         self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"),
    142                     "\"Includes 'single' and &quot;double&quot; quotes\"")
     160        self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"),
     161                         "\"Includes 'single' and &quot;double&quot; quotes\"")
    143162
    144163    # ===== make_parser
    … …  
    153172start = '<?xml version="1.0" encoding="iso-8859-1"?>\n'
    154173
    155 class XmlgenTest(unittest.TestCase):
     174class XmlgenTest:
    156175    def test_xmlgen_basic(self):
    157         result = StringIO()
     176        result = self.ioclass()
    158177        gen = XMLGenerator(result)
    159178        gen.startDocument()
    … …  
    162181        gen.endDocument()
    163182
    164         self.assertEquals(result.getvalue(), start + "<doc></doc>")
     183        self.assertEqual(result.getvalue(), start + "<doc></doc>")
    165184
    166185    def test_xmlgen_content(self):
    167         result = StringIO()
     186        result = self.ioclass()
    168187        gen = XMLGenerator(result)
    169188
    … …  
    174193        gen.endDocument()
    175194
    176         self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>")
     195        self.assertEqual(result.getvalue(), start + "<doc>huhei</doc>")
    177196
    178197    def test_xmlgen_pi(self):
    179         result = StringIO()
     198        result = self.ioclass()
    180199        gen = XMLGenerator(result)
    181200
    … …  
    186205        gen.endDocument()
    187206
    188         self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>")
     207        self.assertEqual(result.getvalue(), start + "<?test data?><doc></doc>")
    189208
    190209    def test_xmlgen_content_escape(self):
    191         result = StringIO()
     210        result = self.ioclass()
    192211        gen = XMLGenerator(result)
    193212
    … …  
    198217        gen.endDocument()
    199218
    200         self.assertEquals(result.getvalue(),
     219        self.assertEqual(result.getvalue(),
    201220            start + "<doc>&lt;huhei&amp;</doc>")
    202221
    203222    def test_xmlgen_attr_escape(self):
    204         result = StringIO()
     223        result = self.ioclass()
    205224        gen = XMLGenerator(result)
    206225
    … …  
    216235        gen.endDocument()
    217236
    218         self.assertEquals(result.getvalue(), start +
     237        self.assertEqual(result.getvalue(), start +
    219238            ("<doc a='\"'><e a=\"'\"></e>"
    220239             "<e a=\"'&quot;\"></e>"
    221240             "<e a=\"&#10;&#13;&#9;\"></e></doc>"))
    222241
     242    def test_xmlgen_encoding(self):
     243        encodings = ('iso-8859-15', 'utf-8',
     244                     'utf-16be', 'utf-16le',
     245                     'utf-32be', 'utf-32le')
     246        for encoding in encodings:
     247            result = self.ioclass()
     248            gen = XMLGenerator(result, encoding=encoding)
     249
     250            gen.startDocument()
     251            gen.startElement("doc", {"a": u'\u20ac'})
     252            gen.characters(u"\u20ac")
     253            gen.endElement("doc")
     254            gen.endDocument()
     255
     256            self.assertEqual(result.getvalue(), (
     257                u'<?xml version="1.0" encoding="%s"?>\n'
     258                u'<doc a="\u20ac">\u20ac</doc>' % encoding
     259                ).encode(encoding, 'xmlcharrefreplace'))
     260
     261    def test_xmlgen_unencodable(self):
     262        result = self.ioclass()
     263        gen = XMLGenerator(result, encoding='ascii')
     264
     265        gen.startDocument()
     266        gen.startElement("doc", {"a": u'\u20ac'})
     267        gen.characters(u"\u20ac")
     268        gen.endElement("doc")
     269        gen.endDocument()
     270
     271        self.assertEqual(result.getvalue(),
     272                '<?xml version="1.0" encoding="ascii"?>\n'
     273                '<doc a="&#8364;">&#8364;</doc>')
     274
    223275    def test_xmlgen_ignorable(self):
    224         result = StringIO()
     276        result = self.ioclass()
    225277        gen = XMLGenerator(result)
    226278
    … …  
    231283        gen.endDocument()
    232284
    233         self.assertEquals(result.getvalue(), start + "<doc> </doc>")
     285        self.assertEqual(result.getvalue(), start + "<doc> </doc>")
     286
     287    def test_xmlgen_encoding_bytes(self):
     288        encodings = ('iso-8859-15', 'utf-8',
     289                     'utf-16be', 'utf-16le',
     290                     'utf-32be', 'utf-32le')
     291        for encoding in encodings:
     292            result = self.ioclass()
     293            gen = XMLGenerator(result, encoding=encoding)
     294
     295            gen.startDocument()
     296            gen.startElement("doc", {"a": u'\u20ac'})
     297            gen.characters(u"\u20ac".encode(encoding))
     298            gen.ignorableWhitespace(" ".encode(encoding))
     299            gen.endElement("doc")
     300            gen.endDocument()
     301
     302            self.assertEqual(result.getvalue(), (
     303                u'<?xml version="1.0" encoding="%s"?>\n'
     304                u'<doc a="\u20ac">\u20ac </doc>' % encoding
     305                ).encode(encoding, 'xmlcharrefreplace'))
    234306
    235307    def test_xmlgen_ns(self):
    236         result = StringIO()
     308        result = self.ioclass()
    237309        gen = XMLGenerator(result)
    238310
    … …  
    247319        gen.endDocument()
    248320
    249         self.assertEquals(result.getvalue(), start + \
     321        self.assertEqual(result.getvalue(), start + \
    250322           ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
    251323                                         ns_uri))
    252324
    253325    def test_1463026_1(self):
    254         result = StringIO()
     326        result = self.ioclass()
    255327        gen = XMLGenerator(result)
    256328
    … …  
    260332        gen.endDocument()
    261333
    262         self.assertEquals(result.getvalue(), start+'<a b="c"></a>')
     334        self.assertEqual(result.getvalue(), start+'<a b="c"></a>')
    263335
    264336    def test_1463026_2(self):
    265         result = StringIO()
     337        result = self.ioclass()
    266338        gen = XMLGenerator(result)
    267339
    … …  
    273345        gen.endDocument()
    274346
    275         self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>')
     347        self.assertEqual(result.getvalue(), start+'<a xmlns="qux"></a>')
    276348
    277349    def test_1463026_3(self):
    278         result = StringIO()
     350        result = self.ioclass()
    279351        gen = XMLGenerator(result)
    280352
    … …  
    286358        gen.endDocument()
    287359
    288         self.assertEquals(result.getvalue(),
     360        self.assertEqual(result.getvalue(),
    289361            start+'<my:a xmlns:my="qux" b="c"></my:a>')
     362
     363    def test_5027_1(self):
     364        # The xml prefix (as in xml:lang below) is reserved and bound by
     365        # definition to http://www.w3.org/XML/1998/namespace.  XMLGenerator had
     366        # a bug whereby a KeyError is raised because this namespace is missing
     367        # from a dictionary.
     368        #
     369        # This test demonstrates the bug by parsing a document.
     370        test_xml = StringIO(
     371            '<?xml version="1.0"?>'
     372            '<a:g1 xmlns:a="http://example.com/ns">'
     373             '<a:g2 xml:lang="en">Hello</a:g2>'
     374            '</a:g1>')
     375
     376        parser = make_parser()
     377        parser.setFeature(feature_namespaces, True)
     378        result = self.ioclass()
     379        gen = XMLGenerator(result)
     380        parser.setContentHandler(gen)
     381        parser.parse(test_xml)
     382
     383        self.assertEqual(result.getvalue(),
     384                         start + (
     385                         '<a:g1 xmlns:a="http://example.com/ns">'
     386                          '<a:g2 xml:lang="en">Hello</a:g2>'
     387                         '</a:g1>'))
     388
     389    def test_5027_2(self):
     390        # The xml prefix (as in xml:lang below) is reserved and bound by
     391        # definition to http://www.w3.org/XML/1998/namespace.  XMLGenerator had
     392        # a bug whereby a KeyError is raised because this namespace is missing
     393        # from a dictionary.
     394        #
     395        # This test demonstrates the bug by direct manipulation of the
     396        # XMLGenerator.
     397        result = self.ioclass()
     398        gen = XMLGenerator(result)
     399
     400        gen.startDocument()
     401        gen.startPrefixMapping('a', 'http://example.com/ns')
     402        gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {})
     403        lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'}
     404        gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr)
     405        gen.characters('Hello')
     406        gen.endElementNS(('http://example.com/ns', 'g2'), 'g2')
     407        gen.endElementNS(('http://example.com/ns', 'g1'), 'g1')
     408        gen.endPrefixMapping('a')
     409        gen.endDocument()
     410
     411        self.assertEqual(result.getvalue(),
     412                         start + (
     413                         '<a:g1 xmlns:a="http://example.com/ns">'
     414                          '<a:g2 xml:lang="en">Hello</a:g2>'
     415                         '</a:g1>'))
     416
     417    def test_no_close_file(self):
     418        result = self.ioclass()
     419        def func(out):
     420            gen = XMLGenerator(out)
     421            gen.startDocument()
     422            gen.startElement("doc", {})
     423        func(result)
     424        self.assertFalse(result.closed)
     425
     426    def test_xmlgen_fragment(self):
     427        result = self.ioclass()
     428        gen = XMLGenerator(result)
     429
     430        # Don't call gen.startDocument()
     431        gen.startElement("foo", {"a": "1.0"})
     432        gen.characters("Hello")
     433        gen.endElement("foo")
     434        gen.startElement("bar", {"b": "2.0"})
     435        gen.endElement("bar")
     436        # Don't call gen.endDocument()
     437
     438        self.assertEqual(result.getvalue(),
     439                         '<foo a="1.0">Hello</foo><bar b="2.0"></bar>')
     440
     441class StringXmlgenTest(XmlgenTest, unittest.TestCase):
     442    ioclass = StringIO
     443
     444class BytesIOXmlgenTest(XmlgenTest, unittest.TestCase):
     445    ioclass = io.BytesIO
     446
     447class WriterXmlgenTest(XmlgenTest, unittest.TestCase):
     448    class ioclass(list):
     449        write = list.append
     450        closed = False
     451
     452        def getvalue(self):
     453            return b''.join(self)
    290454
    291455
    … …  
    304468        filter.endDocument()
    305469
    306         self.assertEquals(result.getvalue(), start + "<doc>content </doc>")
     470        self.assertEqual(result.getvalue(), start + "<doc>content </doc>")
    307471
    308472# ===========================================================================
    … …  
    312476# ===========================================================================
    313477
    314 xml_test_out = open(findfile("test"+os.extsep+"xml"+os.extsep+"out")).read()
     478xml_test_out = open(TEST_XMLFILE_OUT).read()
    315479
    316480class ExpatReaderTest(XmlTestBase):
    … …  
    324488
    325489        parser.setContentHandler(xmlgen)
    326         parser.parse(open(findfile("test"+os.extsep+"xml")))
    327 
    328         self.assertEquals(result.getvalue(), xml_test_out)
     490        parser.parse(open(TEST_XMLFILE))
     491
     492        self.assertEqual(result.getvalue(), xml_test_out)
     493
     494    @requires_unicode_filenames
     495    def test_expat_file_unicode(self):
     496        fname = support.TESTFN_UNICODE
     497        shutil.copyfile(TEST_XMLFILE, fname)
     498        self.addCleanup(support.unlink, fname)
     499
     500        parser = create_parser()
     501        result = StringIO()
     502        xmlgen = XMLGenerator(result)
     503
     504        parser.setContentHandler(xmlgen)
     505        parser.parse(open(fname))
     506
     507        self.assertEqual(result.getvalue(), xml_test_out)
    329508
    330509    # ===== DTDHandler support
    … …  
    354533        parser.close()
    355534
    356         self.assertEquals(handler._notations,
     535        self.assertEqual(handler._notations,
    357536            [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
    358         self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")])
     537        self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")])
    359538
    360539    # ===== EntityResolver support
    … …  
    379558        parser.close()
    380559
    381         self.assertEquals(result.getvalue(), start +
    382                           "<doc><entity></entity></doc>")
     560        self.assertEqual(result.getvalue(), start +
     561                         "<doc><entity></entity></doc>")
    383562
    384563    # ===== Attributes support
    … …  
    432611        attrs = gather._attrs
    433612
    434         self.assertEquals(attrs.getLength(), 1)
    435         self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
     613        self.assertEqual(attrs.getLength(), 1)
     614        self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
    436615        self.assertTrue((attrs.getQNames() == [] or
    437616                         attrs.getQNames() == ["ns:attr"]))
    438         self.assertEquals(len(attrs), 1)
     617        self.assertEqual(len(attrs), 1)
    439618        self.assertTrue(attrs.has_key((ns_uri, "attr")))
    440         self.assertEquals(attrs.get((ns_uri, "attr")), "val")
    441         self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
    442         self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
    443         self.assertEquals(attrs.values(), ["val"])
    444         self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
    445         self.assertEquals(attrs[(ns_uri, "attr")], "val")
     619        self.assertEqual(attrs.get((ns_uri, "attr")), "val")
     620        self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
     621        self.assertEqual(attrs.items(), [((ns_uri, "attr"), "val")])
     622        self.assertEqual(attrs.values(), ["val"])
     623        self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
     624        self.assertEqual(attrs[(ns_uri, "attr")], "val")
    446625
    447626    # ===== InputSource support
    … …  
    453632
    454633        parser.setContentHandler(xmlgen)
    455         parser.parse(findfile("test"+os.extsep+"xml"))
    456 
    457         self.assertEquals(result.getvalue(), xml_test_out)
     634        parser.parse(TEST_XMLFILE)
     635
     636        self.assertEqual(result.getvalue(), xml_test_out)
    458637
    459638    def test_expat_inpsource_sysid(self):
    … …  
    463642
    464643        parser.setContentHandler(xmlgen)
    465         parser.parse(InputSource(findfile("test"+os.extsep+"xml")))
    466 
    467         self.assertEquals(result.getvalue(), xml_test_out)
     644        parser.parse(InputSource(TEST_XMLFILE))
     645
     646        self.assertEqual(result.getvalue(), xml_test_out)
     647
     648    @requires_unicode_filenames
     649    def test_expat_inpsource_sysid_unicode(self):
     650        fname = support.TESTFN_UNICODE
     651        shutil.copyfile(TEST_XMLFILE, fname)
     652        self.addCleanup(support.unlink, fname)
     653
     654        parser = create_parser()
     655        result = StringIO()
     656        xmlgen = XMLGenerator(result)
     657
     658        parser.setContentHandler(xmlgen)
     659        parser.parse(InputSource(fname))
     660
     661        self.assertEqual(result.getvalue(), xml_test_out)
    468662
    469663    def test_expat_inpsource_stream(self):
    … …  
    474668        parser.setContentHandler(xmlgen)
    475669        inpsrc = InputSource()
    476         inpsrc.setByteStream(open(findfile("test"+os.extsep+"xml")))
     670        inpsrc.setByteStream(open(TEST_XMLFILE))
    477671        parser.parse(inpsrc)
    478672
    479         self.assertEquals(result.getvalue(), xml_test_out)
     673        self.assertEqual(result.getvalue(), xml_test_out)
    480674
    481675    # ===== IncrementalParser support
    … …  
    491685        parser.close()
    492686
    493         self.assertEquals(result.getvalue(), start + "<doc></doc>")
     687        self.assertEqual(result.getvalue(), start + "<doc></doc>")
    494688
    495689    def test_expat_incremental_reset(self):
    … …  
    512706        parser.close()
    513707
    514         self.assertEquals(result.getvalue(), start + "<doc>text</doc>")
     708        self.assertEqual(result.getvalue(), start + "<doc>text</doc>")
    515709
    516710    # ===== Locator support
    … …  
    526720        parser.close()
    527721
    528         self.assertEquals(parser.getSystemId(), None)
    529         self.assertEquals(parser.getPublicId(), None)
    530         self.assertEquals(parser.getLineNumber(), 1)
     722        self.assertEqual(parser.getSystemId(), None)
     723        self.assertEqual(parser.getPublicId(), None)
     724        self.assertEqual(parser.getLineNumber(), 1)
    531725
    532726    def test_expat_locator_withinfo(self):
    … …  
    535729        parser = create_parser()
    536730        parser.setContentHandler(xmlgen)
    537         parser.parse(findfile("test.xml"))
    538 
    539         self.assertEquals(parser.getSystemId(), findfile("test.xml"))
    540         self.assertEquals(parser.getPublicId(), None)
     731        parser.parse(TEST_XMLFILE)
     732
     733        self.assertEqual(parser.getSystemId(), TEST_XMLFILE)
     734        self.assertEqual(parser.getPublicId(), None)
     735
     736    @requires_unicode_filenames
     737    def test_expat_locator_withinfo_unicode(self):
     738        fname = support.TESTFN_UNICODE
     739        shutil.copyfile(TEST_XMLFILE, fname)
     740        self.addCleanup(support.unlink, fname)
     741
     742        result = StringIO()
     743        xmlgen = XMLGenerator(result)
     744        parser = create_parser()
     745        parser.setContentHandler(xmlgen)
     746        parser.parse(fname)
     747
     748        self.assertEqual(parser.getSystemId(), fname)
     749        self.assertEqual(parser.getPublicId(), None)
    541750
    542751
    … …  
    559768            self.fail()
    560769        except SAXException, e:
    561             self.assertEquals(e.getSystemId(), name)
     770            self.assertEqual(e.getSystemId(), name)
    562771
    563772    def test_expat_incomplete(self):
    … …  
    623832                                 {(ns_uri, "attr") : "ns:attr"})
    624833
    625         self.assertEquals(attrs.getLength(), 1)
    626         self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
    627         self.assertEquals(attrs.getQNames(), ["ns:attr"])
    628         self.assertEquals(len(attrs), 1)
     834        self.assertEqual(attrs.getLength(), 1)
     835        self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
     836        self.assertEqual(attrs.getQNames(), ["ns:attr"])
     837        self.assertEqual(len(attrs), 1)
    629838        self.assertTrue(attrs.has_key((ns_uri, "attr")))
    630         self.assertEquals(attrs.keys(), [(ns_uri, "attr")])
    631         self.assertEquals(attrs.get((ns_uri, "attr")), "val")
    632         self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
    633         self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
    634         self.assertEquals(attrs.values(), ["val"])
    635         self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
    636         self.assertEquals(attrs.getValueByQName("ns:attr"), "val")
    637         self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
    638         self.assertEquals(attrs[(ns_uri, "attr")], "val")
    639         self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
     839        self.assertEqual(attrs.keys(), [(ns_uri, "attr")])
     840        self.assertEqual(attrs.get((ns_uri, "attr")), "val")
     841        self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
     842        self.assertEqual(attrs.items(), [((ns_uri, "attr"), "val")])
     843        self.assertEqual(attrs.values(), ["val"])
     844        self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
     845        self.assertEqual(attrs.getValueByQName("ns:attr"), "val")
     846        self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
     847        self.assertEqual(attrs[(ns_uri, "attr")], "val")
     848        self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
    640849
    641850
    … …  
    673882            import xml.sax.expatreader
    674883            module = xml.sax.expatreader
    675             self.assertEquals(module.__name__, "xml.sax.expatreader")
     884            self.assertEqual(module.__name__, "xml.sax.expatreader")
    676885        finally:
    677886            sys.modules.update(old_modules)
    … …  
    688897    run_unittest(MakeParserTest,
    689898                 SaxutilsTest,
    690                  XmlgenTest,
     899                 StringXmlgenTest,
     900                 BytesIOXmlgenTest,
     901                 WriterXmlgenTest,
    691902                 ExpatReaderTest,
    692903                 ErrorReportingTest,
Note: See TracChangeset for help on using the changeset viewer.