mirror of
https://github.com/python/cpython.git
synced 2025-07-19 09:15:34 +00:00
34d1928766
Completely get rid of StringIO.py and cStringIO.c. I had to fix a few tests and modules beyond what Christian did, and invent a few conventions. E.g. in elementtree, I chose to write/return Unicode strings whe no encoding is given, but bytes when an explicit encoding is given. Also mimetools was made to always assume binary files.
696 lines
24 KiB
Python
696 lines
24 KiB
Python
# regression test for SAX 2.0 -*- coding: iso-8859-1 -*-
|
||
# $Id$
|
||
|
||
from xml.sax import make_parser, ContentHandler, \
|
||
SAXException, SAXReaderNotAvailable, SAXParseException
|
||
try:
|
||
make_parser()
|
||
except SAXReaderNotAvailable:
|
||
# don't try to test this module if we cannot create a parser
|
||
raise ImportError("no XML parsers available")
|
||
from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
|
||
XMLFilterBase
|
||
from xml.sax.expatreader import create_parser
|
||
from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
|
||
from io import StringIO
|
||
from test.test_support import findfile, run_unittest
|
||
import unittest
|
||
import os
|
||
|
||
ns_uri = "http://www.python.org/xml-ns/saxtest/"
|
||
|
||
class XmlTestBase(unittest.TestCase):
|
||
def verify_empty_attrs(self, attrs):
|
||
self.assertRaises(KeyError, attrs.getValue, "attr")
|
||
self.assertRaises(KeyError, attrs.getValueByQName, "attr")
|
||
self.assertRaises(KeyError, attrs.getNameByQName, "attr")
|
||
self.assertRaises(KeyError, attrs.getQNameByName, "attr")
|
||
self.assertRaises(KeyError, attrs.__getitem__, "attr")
|
||
self.assertEquals(attrs.getLength(), 0)
|
||
self.assertEquals(attrs.getNames(), [])
|
||
self.assertEquals(attrs.getQNames(), [])
|
||
self.assertEquals(len(attrs), 0)
|
||
self.assertFalse("attr" in attrs)
|
||
self.assertEquals(list(attrs.keys()), [])
|
||
self.assertEquals(attrs.get("attrs"), None)
|
||
self.assertEquals(attrs.get("attrs", 25), 25)
|
||
self.assertEquals(list(attrs.items()), [])
|
||
self.assertEquals(list(attrs.values()), [])
|
||
|
||
def verify_empty_nsattrs(self, attrs):
|
||
self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
|
||
self.assertRaises(KeyError, attrs.getValueByQName, "ns:attr")
|
||
self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
|
||
self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
|
||
self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
|
||
self.assertEquals(attrs.getLength(), 0)
|
||
self.assertEquals(attrs.getNames(), [])
|
||
self.assertEquals(attrs.getQNames(), [])
|
||
self.assertEquals(len(attrs), 0)
|
||
self.assertFalse((ns_uri, "attr") in attrs)
|
||
self.assertEquals(list(attrs.keys()), [])
|
||
self.assertEquals(attrs.get((ns_uri, "attr")), None)
|
||
self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
|
||
self.assertEquals(list(attrs.items()), [])
|
||
self.assertEquals(list(attrs.values()), [])
|
||
|
||
def verify_attrs_wattr(self, attrs):
|
||
self.assertEquals(attrs.getLength(), 1)
|
||
self.assertEquals(attrs.getNames(), ["attr"])
|
||
self.assertEquals(attrs.getQNames(), ["attr"])
|
||
self.assertEquals(len(attrs), 1)
|
||
self.assertTrue("attr" in attrs)
|
||
self.assertEquals(list(attrs.keys()), ["attr"])
|
||
self.assertEquals(attrs.get("attr"), "val")
|
||
self.assertEquals(attrs.get("attr", 25), "val")
|
||
self.assertEquals(list(attrs.items()), [("attr", "val")])
|
||
self.assertEquals(list(attrs.values()), ["val"])
|
||
self.assertEquals(attrs.getValue("attr"), "val")
|
||
self.assertEquals(attrs.getValueByQName("attr"), "val")
|
||
self.assertEquals(attrs.getNameByQName("attr"), "attr")
|
||
self.assertEquals(attrs["attr"], "val")
|
||
self.assertEquals(attrs.getQNameByName("attr"), "attr")
|
||
|
||
class MakeParserTest(unittest.TestCase):
|
||
def test_make_parser2(self):
|
||
# Creating parsers several times in a row should succeed.
|
||
# Testing this because there have been failures of this kind
|
||
# before.
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
from xml.sax import make_parser
|
||
p = make_parser()
|
||
|
||
|
||
# ===========================================================================
|
||
#
|
||
# saxutils tests
|
||
#
|
||
# ===========================================================================
|
||
|
||
class SaxutilsTest(unittest.TestCase):
|
||
# ===== escape
|
||
def test_escape_basic(self):
|
||
self.assertEquals(escape("Donald Duck & Co"), "Donald Duck & Co")
|
||
|
||
def test_escape_all(self):
|
||
self.assertEquals(escape("<Donald Duck & Co>"),
|
||
"<Donald Duck & Co>")
|
||
|
||
def test_escape_extra(self):
|
||
self.assertEquals(escape("Hei p<> deg", {"<EFBFBD>" : "å"}),
|
||
"Hei på deg")
|
||
|
||
# ===== unescape
|
||
def test_unescape_basic(self):
|
||
self.assertEquals(unescape("Donald Duck & Co"), "Donald Duck & Co")
|
||
|
||
def test_unescape_all(self):
|
||
self.assertEquals(unescape("<Donald Duck & Co>"),
|
||
"<Donald Duck & Co>")
|
||
|
||
def test_unescape_extra(self):
|
||
self.assertEquals(unescape("Hei p<> deg", {"<EFBFBD>" : "å"}),
|
||
"Hei på deg")
|
||
|
||
def test_unescape_amp_extra(self):
|
||
self.assertEquals(unescape("&foo;", {"&foo;": "splat"}), "&foo;")
|
||
|
||
# ===== quoteattr
|
||
def test_quoteattr_basic(self):
|
||
self.assertEquals(quoteattr("Donald Duck & Co"),
|
||
'"Donald Duck & Co"')
|
||
|
||
def test_single_quoteattr(self):
|
||
self.assertEquals(quoteattr('Includes "double" quotes'),
|
||
'\'Includes "double" quotes\'')
|
||
|
||
def test_double_quoteattr(self):
|
||
self.assertEquals(quoteattr("Includes 'single' quotes"),
|
||
"\"Includes 'single' quotes\"")
|
||
|
||
def test_single_double_quoteattr(self):
|
||
self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"),
|
||
"\"Includes 'single' and "double" quotes\"")
|
||
|
||
# ===== make_parser
|
||
def test_make_parser(self):
|
||
# Creating a parser should succeed - it should fall back
|
||
# to the expatreader
|
||
p = make_parser(['xml.parsers.no_such_parser'])
|
||
|
||
|
||
# ===== XMLGenerator
|
||
|
||
start = '<?xml version="1.0" encoding="iso-8859-1"?>\n'
|
||
|
||
class XmlgenTest(unittest.TestCase):
|
||
def test_xmlgen_basic(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
gen.startDocument()
|
||
gen.startElement("doc", {})
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc></doc>")
|
||
|
||
def test_xmlgen_content(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startElement("doc", {})
|
||
gen.characters("huhei")
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>")
|
||
|
||
def test_xmlgen_pi(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.processingInstruction("test", "data")
|
||
gen.startElement("doc", {})
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>")
|
||
|
||
def test_xmlgen_content_escape(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startElement("doc", {})
|
||
gen.characters("<huhei&")
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(),
|
||
start + "<doc><huhei&</doc>")
|
||
|
||
def test_xmlgen_attr_escape(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startElement("doc", {"a": '"'})
|
||
gen.startElement("e", {"a": "'"})
|
||
gen.endElement("e")
|
||
gen.startElement("e", {"a": "'\""})
|
||
gen.endElement("e")
|
||
gen.startElement("e", {"a": "\n\r\t"})
|
||
gen.endElement("e")
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start +
|
||
("<doc a='\"'><e a=\"'\"></e>"
|
||
"<e a=\"'"\"></e>"
|
||
"<e a=\" 	\"></e></doc>"))
|
||
|
||
def test_xmlgen_ignorable(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startElement("doc", {})
|
||
gen.ignorableWhitespace(" ")
|
||
gen.endElement("doc")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc> </doc>")
|
||
|
||
def test_xmlgen_ns(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startPrefixMapping("ns1", ns_uri)
|
||
gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
|
||
# add an unqualified name
|
||
gen.startElementNS((None, "udoc"), None, {})
|
||
gen.endElementNS((None, "udoc"), None)
|
||
gen.endElementNS((ns_uri, "doc"), "ns1:doc")
|
||
gen.endPrefixMapping("ns1")
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + \
|
||
('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
|
||
ns_uri))
|
||
|
||
def test_1463026_1(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
|
||
gen.endElementNS((None, 'a'), 'a')
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start+'<a b="c"></a>')
|
||
|
||
def test_1463026_2(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startPrefixMapping(None, 'qux')
|
||
gen.startElementNS(('qux', 'a'), 'a', {})
|
||
gen.endElementNS(('qux', 'a'), 'a')
|
||
gen.endPrefixMapping(None)
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>')
|
||
|
||
def test_1463026_3(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
|
||
gen.startDocument()
|
||
gen.startPrefixMapping('my', 'qux')
|
||
gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
|
||
gen.endElementNS(('qux', 'a'), 'a')
|
||
gen.endPrefixMapping('my')
|
||
gen.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(),
|
||
start+'<my:a xmlns:my="qux" b="c"></my:a>')
|
||
|
||
|
||
class XMLFilterBaseTest(unittest.TestCase):
|
||
def test_filter_basic(self):
|
||
result = StringIO()
|
||
gen = XMLGenerator(result)
|
||
filter = XMLFilterBase()
|
||
filter.setContentHandler(gen)
|
||
|
||
filter.startDocument()
|
||
filter.startElement("doc", {})
|
||
filter.characters("content")
|
||
filter.ignorableWhitespace(" ")
|
||
filter.endElement("doc")
|
||
filter.endDocument()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc>content </doc>")
|
||
|
||
# ===========================================================================
|
||
#
|
||
# expatreader tests
|
||
#
|
||
# ===========================================================================
|
||
|
||
xml_test_out = open(findfile("test"+os.extsep+"xml"+os.extsep+"out")).read()
|
||
|
||
class ExpatReaderTest(XmlTestBase):
|
||
|
||
# ===== XMLReader support
|
||
|
||
def test_expat_file(self):
|
||
parser = create_parser()
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
|
||
parser.setContentHandler(xmlgen)
|
||
parser.parse(open(findfile("test"+os.extsep+"xml")))
|
||
|
||
self.assertEquals(result.getvalue(), xml_test_out)
|
||
|
||
# ===== DTDHandler support
|
||
|
||
class TestDTDHandler:
|
||
|
||
def __init__(self):
|
||
self._notations = []
|
||
self._entities = []
|
||
|
||
def notationDecl(self, name, publicId, systemId):
|
||
self._notations.append((name, publicId, systemId))
|
||
|
||
def unparsedEntityDecl(self, name, publicId, systemId, ndata):
|
||
self._entities.append((name, publicId, systemId, ndata))
|
||
|
||
def test_expat_dtdhandler(self):
|
||
parser = create_parser()
|
||
handler = self.TestDTDHandler()
|
||
parser.setDTDHandler(handler)
|
||
|
||
parser.feed('<!DOCTYPE doc [\n')
|
||
parser.feed(' <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
|
||
parser.feed(' <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
|
||
parser.feed(']>\n')
|
||
parser.feed('<doc></doc>')
|
||
parser.close()
|
||
|
||
self.assertEquals(handler._notations,
|
||
[("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
|
||
self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")])
|
||
|
||
# ===== EntityResolver support
|
||
|
||
class TestEntityResolver:
|
||
|
||
def resolveEntity(self, publicId, systemId):
|
||
inpsrc = InputSource()
|
||
inpsrc.setByteStream(StringIO("<entity/>"))
|
||
return inpsrc
|
||
|
||
def test_expat_entityresolver(self):
|
||
parser = create_parser()
|
||
parser.setEntityResolver(self.TestEntityResolver())
|
||
result = StringIO()
|
||
parser.setContentHandler(XMLGenerator(result))
|
||
|
||
parser.feed('<!DOCTYPE doc [\n')
|
||
parser.feed(' <!ENTITY test SYSTEM "whatever">\n')
|
||
parser.feed(']>\n')
|
||
parser.feed('<doc>&test;</doc>')
|
||
parser.close()
|
||
|
||
self.assertEquals(result.getvalue(), start +
|
||
"<doc><entity></entity></doc>")
|
||
|
||
# ===== Attributes support
|
||
|
||
class AttrGatherer(ContentHandler):
|
||
|
||
def startElement(self, name, attrs):
|
||
self._attrs = attrs
|
||
|
||
def startElementNS(self, name, qname, attrs):
|
||
self._attrs = attrs
|
||
|
||
def test_expat_attrs_empty(self):
|
||
parser = create_parser()
|
||
gather = self.AttrGatherer()
|
||
parser.setContentHandler(gather)
|
||
|
||
parser.feed("<doc/>")
|
||
parser.close()
|
||
|
||
self.verify_empty_attrs(gather._attrs)
|
||
|
||
def test_expat_attrs_wattr(self):
|
||
parser = create_parser()
|
||
gather = self.AttrGatherer()
|
||
parser.setContentHandler(gather)
|
||
|
||
parser.feed("<doc attr='val'/>")
|
||
parser.close()
|
||
|
||
self.verify_attrs_wattr(gather._attrs)
|
||
|
||
def test_expat_nsattrs_empty(self):
|
||
parser = create_parser(1)
|
||
gather = self.AttrGatherer()
|
||
parser.setContentHandler(gather)
|
||
|
||
parser.feed("<doc/>")
|
||
parser.close()
|
||
|
||
self.verify_empty_nsattrs(gather._attrs)
|
||
|
||
def test_expat_nsattrs_wattr(self):
|
||
parser = create_parser(1)
|
||
gather = self.AttrGatherer()
|
||
parser.setContentHandler(gather)
|
||
|
||
parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
|
||
parser.close()
|
||
|
||
attrs = gather._attrs
|
||
|
||
self.assertEquals(attrs.getLength(), 1)
|
||
self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
|
||
self.assertTrue((attrs.getQNames() == [] or
|
||
attrs.getQNames() == ["ns:attr"]))
|
||
self.assertEquals(len(attrs), 1)
|
||
self.assertTrue((ns_uri, "attr") in attrs)
|
||
self.assertEquals(attrs.get((ns_uri, "attr")), "val")
|
||
self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
|
||
self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")])
|
||
self.assertEquals(list(attrs.values()), ["val"])
|
||
self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
|
||
self.assertEquals(attrs[(ns_uri, "attr")], "val")
|
||
|
||
# ===== InputSource support
|
||
|
||
def test_expat_inpsource_filename(self):
|
||
parser = create_parser()
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
|
||
parser.setContentHandler(xmlgen)
|
||
parser.parse(findfile("test"+os.extsep+"xml"))
|
||
|
||
self.assertEquals(result.getvalue(), xml_test_out)
|
||
|
||
def test_expat_inpsource_sysid(self):
|
||
parser = create_parser()
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
|
||
parser.setContentHandler(xmlgen)
|
||
parser.parse(InputSource(findfile("test"+os.extsep+"xml")))
|
||
|
||
self.assertEquals(result.getvalue(), xml_test_out)
|
||
|
||
def test_expat_inpsource_stream(self):
|
||
parser = create_parser()
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
|
||
parser.setContentHandler(xmlgen)
|
||
inpsrc = InputSource()
|
||
inpsrc.setByteStream(open(findfile("test"+os.extsep+"xml")))
|
||
parser.parse(inpsrc)
|
||
|
||
self.assertEquals(result.getvalue(), xml_test_out)
|
||
|
||
# ===== IncrementalParser support
|
||
|
||
def test_expat_incremental(self):
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
parser = create_parser()
|
||
parser.setContentHandler(xmlgen)
|
||
|
||
parser.feed("<doc>")
|
||
parser.feed("</doc>")
|
||
parser.close()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc></doc>")
|
||
|
||
def test_expat_incremental_reset(self):
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
parser = create_parser()
|
||
parser.setContentHandler(xmlgen)
|
||
|
||
parser.feed("<doc>")
|
||
parser.feed("text")
|
||
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
parser.setContentHandler(xmlgen)
|
||
parser.reset()
|
||
|
||
parser.feed("<doc>")
|
||
parser.feed("text")
|
||
parser.feed("</doc>")
|
||
parser.close()
|
||
|
||
self.assertEquals(result.getvalue(), start + "<doc>text</doc>")
|
||
|
||
# ===== Locator support
|
||
|
||
def test_expat_locator_noinfo(self):
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
parser = create_parser()
|
||
parser.setContentHandler(xmlgen)
|
||
|
||
parser.feed("<doc>")
|
||
parser.feed("</doc>")
|
||
parser.close()
|
||
|
||
self.assertEquals(parser.getSystemId(), None)
|
||
self.assertEquals(parser.getPublicId(), None)
|
||
self.assertEquals(parser.getLineNumber(), 1)
|
||
|
||
def test_expat_locator_withinfo(self):
|
||
result = StringIO()
|
||
xmlgen = XMLGenerator(result)
|
||
parser = create_parser()
|
||
parser.setContentHandler(xmlgen)
|
||
parser.parse(findfile("test.xml"))
|
||
|
||
self.assertEquals(parser.getSystemId(), findfile("test.xml"))
|
||
self.assertEquals(parser.getPublicId(), None)
|
||
|
||
|
||
# ===========================================================================
|
||
#
|
||
# error reporting
|
||
#
|
||
# ===========================================================================
|
||
|
||
class ErrorReportingTest(unittest.TestCase):
|
||
def test_expat_inpsource_location(self):
|
||
parser = create_parser()
|
||
parser.setContentHandler(ContentHandler()) # do nothing
|
||
source = InputSource()
|
||
source.setByteStream(StringIO("<foo bar foobar>")) #ill-formed
|
||
name = "a file name"
|
||
source.setSystemId(name)
|
||
try:
|
||
parser.parse(source)
|
||
self.fail()
|
||
except SAXException as e:
|
||
self.assertEquals(e.getSystemId(), name)
|
||
|
||
def test_expat_incomplete(self):
|
||
parser = create_parser()
|
||
parser.setContentHandler(ContentHandler()) # do nothing
|
||
self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
|
||
|
||
def test_sax_parse_exception_str(self):
|
||
# pass various values from a locator to the SAXParseException to
|
||
# make sure that the __str__() doesn't fall apart when None is
|
||
# passed instead of an integer line and column number
|
||
#
|
||
# use "normal" values for the locator:
|
||
str(SAXParseException("message", None,
|
||
self.DummyLocator(1, 1)))
|
||
# use None for the line number:
|
||
str(SAXParseException("message", None,
|
||
self.DummyLocator(None, 1)))
|
||
# use None for the column number:
|
||
str(SAXParseException("message", None,
|
||
self.DummyLocator(1, None)))
|
||
# use None for both:
|
||
str(SAXParseException("message", None,
|
||
self.DummyLocator(None, None)))
|
||
|
||
class DummyLocator:
|
||
def __init__(self, lineno, colno):
|
||
self._lineno = lineno
|
||
self._colno = colno
|
||
|
||
def getPublicId(self):
|
||
return "pubid"
|
||
|
||
def getSystemId(self):
|
||
return "sysid"
|
||
|
||
def getLineNumber(self):
|
||
return self._lineno
|
||
|
||
def getColumnNumber(self):
|
||
return self._colno
|
||
|
||
# ===========================================================================
|
||
#
|
||
# xmlreader tests
|
||
#
|
||
# ===========================================================================
|
||
|
||
class XmlReaderTest(XmlTestBase):
|
||
|
||
# ===== AttributesImpl
|
||
def test_attrs_empty(self):
|
||
self.verify_empty_attrs(AttributesImpl({}))
|
||
|
||
def test_attrs_wattr(self):
|
||
self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
|
||
|
||
def test_nsattrs_empty(self):
|
||
self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
|
||
|
||
def test_nsattrs_wattr(self):
|
||
attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
|
||
{(ns_uri, "attr") : "ns:attr"})
|
||
|
||
self.assertEquals(attrs.getLength(), 1)
|
||
self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
|
||
self.assertEquals(attrs.getQNames(), ["ns:attr"])
|
||
self.assertEquals(len(attrs), 1)
|
||
self.assertTrue((ns_uri, "attr") in attrs)
|
||
self.assertEquals(list(attrs.keys()), [(ns_uri, "attr")])
|
||
self.assertEquals(attrs.get((ns_uri, "attr")), "val")
|
||
self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
|
||
self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")])
|
||
self.assertEquals(list(attrs.values()), ["val"])
|
||
self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
|
||
self.assertEquals(attrs.getValueByQName("ns:attr"), "val")
|
||
self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
|
||
self.assertEquals(attrs[(ns_uri, "attr")], "val")
|
||
self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
|
||
|
||
|
||
# During the development of Python 2.5, an attempt to move the "xml"
|
||
# package implementation to a new package ("xmlcore") proved painful.
|
||
# The goal of this change was to allow applications to be able to
|
||
# obtain and rely on behavior in the standard library implementation
|
||
# of the XML support without needing to be concerned about the
|
||
# availability of the PyXML implementation.
|
||
#
|
||
# While the existing import hackery in Lib/xml/__init__.py can cause
|
||
# PyXML's _xmlpus package to supplant the "xml" package, that only
|
||
# works because either implementation uses the "xml" package name for
|
||
# imports.
|
||
#
|
||
# The move resulted in a number of problems related to the fact that
|
||
# the import machinery's "package context" is based on the name that's
|
||
# being imported rather than the __name__ of the actual package
|
||
# containment; it wasn't possible for the "xml" package to be replaced
|
||
# by a simple module that indirected imports to the "xmlcore" package.
|
||
#
|
||
# The following two tests exercised bugs that were introduced in that
|
||
# attempt. Keeping these tests around will help detect problems with
|
||
# other attempts to provide reliable access to the standard library's
|
||
# implementation of the XML support.
|
||
|
||
def test_sf_1511497(self):
|
||
# Bug report: http://www.python.org/sf/1511497
|
||
import sys
|
||
old_modules = sys.modules.copy()
|
||
for modname in list(sys.modules.keys()):
|
||
if modname.startswith("xml."):
|
||
del sys.modules[modname]
|
||
try:
|
||
import xml.sax.expatreader
|
||
module = xml.sax.expatreader
|
||
self.assertEquals(module.__name__, "xml.sax.expatreader")
|
||
finally:
|
||
sys.modules.update(old_modules)
|
||
|
||
def test_sf_1513611(self):
|
||
# Bug report: http://www.python.org/sf/1513611
|
||
sio = StringIO("invalid")
|
||
parser = make_parser()
|
||
from xml.sax import SAXParseException
|
||
self.assertRaises(SAXParseException, parser.parse, sio)
|
||
|
||
|
||
def unittest_main():
|
||
run_unittest(MakeParserTest,
|
||
SaxutilsTest,
|
||
XmlgenTest,
|
||
ExpatReaderTest,
|
||
ErrorReportingTest,
|
||
XmlReaderTest)
|
||
|
||
if __name__ == "__main__":
|
||
unittest_main()
|