Skip to content

C
cpython
Kaydet (Commit) d28fcbc7 authored tarafından Collin Winter's avatar Collin Winter
Dosyalara gözat
Seçenekler

Consolidate patches #1690164, 1683397, and 1690169, all of which refactor… 

Consolidate patches #1690164, 1683397, and 1690169, all of which refactor XML-related test suites. The patches are applied together because they use a common output/xmltests file.
Thanks to Jerry Seutter for all three patches.
üst 366d6262
Hide whitespace changes
Inline Side-by-side
Showing with 973 additions and 1478 deletions
Lib/test/output/test_pyexpat deleted 100644 → 0
Dosyayı görüntüle @ 366d6262
test_pyexpat
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
PI:
'xml-stylesheet' 'href="stylesheet.css"'
Comment:
' comment data '
Notation declared: ('notation', None, 'notation.jpeg', None)
Unparsed entity decl:
('unparsed_entity', None, 'entity.file', None, 'notation')
Start element:
'root' {'attr1': 'value1', 'attr2': 'value2\xe1\xbd\x80'}
NS decl:
'myns' 'http://www.python.org/namespace'
Start element:
'http://www.python.org/namespace!subelement' {}
Character data:
'Contents of subelements'
End element:
'http://www.python.org/namespace!subelement'
End of NS decl:
'myns'
Start element:
'sub2' {}
Start of CDATA section
Character data:
'contents of CDATA section'
End of CDATA section
End element:
'sub2'
External entity ref: (None, 'entity.file', None)
End element:
'root'
PI:
u'xml-stylesheet' u'href="stylesheet.css"'
Comment:
u' comment data '
Notation declared: (u'notation', None, u'notation.jpeg', None)
Unparsed entity decl:
(u'unparsed_entity', None, u'entity.file', None, u'notation')
Start element:
u'root' {u'attr1': u'value1', u'attr2': u'value2\u1f40'}
NS decl:
u'myns' u'http://www.python.org/namespace'
Start element:
u'http://www.python.org/namespace!subelement' {}
Character data:
u'Contents of subelements'
End element:
u'http://www.python.org/namespace!subelement'
End of NS decl:
u'myns'
Start element:
u'sub2' {}
Start of CDATA section
Character data:
u'contents of CDATA section'
End of CDATA section
End element:
u'sub2'
External entity ref: (None, u'entity.file', None)
End element:
u'root'
PI:
u'xml-stylesheet' u'href="stylesheet.css"'
Comment:
u' comment data '
Notation declared: (u'notation', None, u'notation.jpeg', None)
Unparsed entity decl:
(u'unparsed_entity', None, u'entity.file', None, u'notation')
Start element:
u'root' {u'attr1': u'value1', u'attr2': u'value2\u1f40'}
NS decl:
u'myns' u'http://www.python.org/namespace'
Start element:
u'http://www.python.org/namespace!subelement' {}
Character data:
u'Contents of subelements'
End element:
u'http://www.python.org/namespace!subelement'
End of NS decl:
u'myns'
Start element:
u'sub2' {}
Start of CDATA section
Character data:
u'contents of CDATA section'
End of CDATA section
End element:
u'sub2'
External entity ref: (None, u'entity.file', None)
End element:
u'root'
Testing constructor for proper handling of namespace_separator values:
Legal values tested o.k.
Caught expected TypeError:
ParserCreate() argument 2 must be string or None, not int
Caught expected ValueError:
namespace_separator must be at most one character, omitted, or None
Lib/test/output/xmltests deleted 100644 → 0
Dosyayı görüntüle @ 366d6262
xmltests
Passed testAAA
Passed setAttribute() sets ownerDocument
Passed setAttribute() sets ownerElement
Test Succeeded testAAA
Passed assertion: len(Node.allnodes) == 0
Passed testAAB
Test Succeeded testAAB
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Passed Test
Passed Test
Passed Test
Passed Test
Passed Test
Passed Test
Test Succeeded testAddAttr
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testAppendChild
Passed assertion: len(Node.allnodes) == 0
Passed appendChild(<fragment>)
Test Succeeded testAppendChildFragment
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListItem
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListItemNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListItems
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListKeys
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListKeysNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListLength
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrListValues
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrList__getitem__
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testAttrList__setitem__
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testAttributeRepr
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Passed Test
Passed Test
Passed Test
Test Succeeded testChangeAttr
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testChildNodes
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCloneAttributeDeep
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCloneAttributeShallow
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCloneDocumentDeep
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCloneDocumentShallow
Passed assertion: len(Node.allnodes) == 0
Passed clone of element has same attribute keys
Passed clone of attribute node has proper attribute values
Passed clone of attribute node correctly owned
Passed testCloneElementDeep
Test Succeeded testCloneElementDeep
Passed assertion: len(Node.allnodes) == 0
Passed clone of element has same attribute keys
Passed clone of attribute node has proper attribute values
Passed clone of attribute node correctly owned
Passed testCloneElementShallow
Test Succeeded testCloneElementShallow
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testClonePIDeep
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testClonePIShallow
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testComment
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCreateAttributeNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testCreateElementNS
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Passed Test
Test Succeeded testDeleteAttr
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testDocumentElement
Passed assertion: len(Node.allnodes) == 0
Passed Test
Test Succeeded testElement
Passed assertion: len(Node.allnodes) == 0
Passed Test
Test Succeeded testElementReprAndStr
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testFirstChild
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttrLength
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttrList
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttrValues
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttribute
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttributeNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetAttributeNode
Passed assertion: len(Node.allnodes) == 0
Passed Test
Test Succeeded testGetElementsByTagName
Passed assertion: len(Node.allnodes) == 0
Passed Test
Test Succeeded testGetElementsByTagNameNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testGetEmptyNodeListFromElementsByTagNameNS
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testHasChildNodes
Passed assertion: len(Node.allnodes) == 0
Passed testInsertBefore -- node properly placed in tree
Passed testInsertBefore -- node properly placed in tree
Passed testInsertBefore -- node properly placed in tree
Test Succeeded testInsertBefore
Passed assertion: len(Node.allnodes) == 0
Passed insertBefore(<fragment>, None)
Passed insertBefore(<fragment>, orig)
Test Succeeded testInsertBeforeFragment
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testLegalChildren
Passed assertion: len(Node.allnodes) == 0
Passed NamedNodeMap.__setitem__() sets ownerDocument
Passed NamedNodeMap.__setitem__() sets ownerElement
Passed NamedNodeMap.__setitem__() sets value
Passed NamedNodeMap.__setitem__() sets nodeValue
Test Succeeded testNamedNodeMapSetItem
Passed assertion: len(Node.allnodes) == 0
Passed test NodeList.item()
Test Succeeded testNodeListItem
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testNonZero
Passed assertion: len(Node.allnodes) == 0
Passed testNormalize -- preparation
Passed testNormalize -- result
Passed testNormalize -- single empty node removed
Test Succeeded testNormalize
Passed assertion: len(Node.allnodes) == 0
Passed testParents
Test Succeeded testParents
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParse
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseAttributeNamespaces
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseAttributes
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseElement
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseElementNamespaces
Passed assertion: len(Node.allnodes) == 0
Passed Test
Test Succeeded testParseFromFile
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseProcessingInstructions
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testParseString
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testProcessingInstruction
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testProcessingInstructionRepr
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testRemoveAttr
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testRemoveAttrNS
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testRemoveAttributeNode
Passed assertion: len(Node.allnodes) == 0
Passed replaceChild(<fragment>)
Test Succeeded testReplaceChildFragment
Passed assertion: len(Node.allnodes) == 0
Passed testSAX2DOM - siblings
Passed testSAX2DOM - parents
Test Succeeded testSAX2DOM
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testSetAttrValueandNodeValue
Passed assertion: len(Node.allnodes) == 0
Passed testSiblings
Test Succeeded testSiblings
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testTextNodeRepr
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testTextRepr
Passed assertion: len(Node.allnodes) == 0
Caught expected exception when adding extra document element.
Test Succeeded testTooManyDocumentElements
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testUnlink
Passed assertion: len(Node.allnodes) == 0
Test Succeeded testWriteText
Passed assertion: len(Node.allnodes) == 0
Passed Test
Passed Test
Test Succeeded testWriteXML
Passed assertion: len(Node.allnodes) == 0
All tests succeeded
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
OK.
PI:
'xml-stylesheet' 'href="stylesheet.css"'
Comment:
' comment data '
Notation declared: ('notation', None, 'notation.jpeg', None)
Unparsed entity decl:
('unparsed_entity', None, 'entity.file', None, 'notation')
Start element:
'root' {'attr1': 'value1', 'attr2': 'value2\xe1\xbd\x80'}
NS decl:
'myns' 'http://www.python.org/namespace'
Start element:
'http://www.python.org/namespace!subelement' {}
Character data:
'Contents of subelements'
End element:
'http://www.python.org/namespace!subelement'
End of NS decl:
'myns'
Start element:
'sub2' {}
Start of CDATA section
Character data:
'contents of CDATA section'
End of CDATA section
End element:
'sub2'
External entity ref: (None, 'entity.file', None)
End element:
'root'
PI:
u'xml-stylesheet' u'href="stylesheet.css"'
Comment:
u' comment data '
Notation declared: (u'notation', None, u'notation.jpeg', None)
Unparsed entity decl:
(u'unparsed_entity', None, u'entity.file', None, u'notation')
Start element:
u'root' {u'attr1': u'value1', u'attr2': u'value2\u1f40'}
NS decl:
u'myns' u'http://www.python.org/namespace'
Start element:
u'http://www.python.org/namespace!subelement' {}
Character data:
u'Contents of subelements'
End element:
u'http://www.python.org/namespace!subelement'
End of NS decl:
u'myns'
Start element:
u'sub2' {}
Start of CDATA section
Character data:
u'contents of CDATA section'
End of CDATA section
End element:
u'sub2'
External entity ref: (None, u'entity.file', None)
End element:
u'root'
PI:
u'xml-stylesheet' u'href="stylesheet.css"'
Comment:
u' comment data '
Notation declared: (u'notation', None, u'notation.jpeg', None)
Unparsed entity decl:
(u'unparsed_entity', None, u'entity.file', None, u'notation')
Start element:
u'root' {u'attr1': u'value1', u'attr2': u'value2\u1f40'}
NS decl:
u'myns' u'http://www.python.org/namespace'
Start element:
u'http://www.python.org/namespace!subelement' {}
Character data:
u'Contents of subelements'
End element:
u'http://www.python.org/namespace!subelement'
End of NS decl:
u'myns'
Start element:
u'sub2' {}
Start of CDATA section
Character data:
u'contents of CDATA section'
End of CDATA section
End element:
u'sub2'
External entity ref: (None, u'entity.file', None)
End element:
u'root'
Testing constructor for proper handling of namespace_separator values:
Legal values tested o.k.
Caught expected TypeError:
ParserCreate() argument 2 must be string or None, not int
Caught expected ValueError:
namespace_separator must be at most one character, omitted, or None
Passed test_attrs_empty
Passed test_attrs_wattr
Passed test_double_quoteattr
Passed test_escape_all
Passed test_escape_basic
Passed test_escape_extra
Passed test_expat_attrs_empty
Passed test_expat_attrs_wattr
Passed test_expat_dtdhandler
Passed test_expat_entityresolver
Passed test_expat_file
Passed test_expat_incomplete
Passed test_expat_incremental
Passed test_expat_incremental_reset
Passed test_expat_inpsource_filename
Passed test_expat_inpsource_location
Passed test_expat_inpsource_stream
Passed test_expat_inpsource_sysid
Passed test_expat_locator_noinfo
Passed test_expat_locator_withinfo
Passed test_expat_nsattrs_empty
Passed test_expat_nsattrs_wattr
Passed test_filter_basic
Passed test_make_parser
Passed test_make_parser2
Passed test_nsattrs_empty
Passed test_nsattrs_wattr
Passed test_quoteattr_basic
Passed test_single_double_quoteattr
Passed test_single_quoteattr
Passed test_xmlgen_attr_escape
Passed test_xmlgen_basic
Passed test_xmlgen_content
Passed test_xmlgen_content_escape
Passed test_xmlgen_ignorable
Passed test_xmlgen_ns
Passed test_xmlgen_pi
37 tests, 0 failures
Lib/test/test_minidom.py
Dosyayı görüntüle @ d28fcbc7
This source diff could not be displayed because it is too large. You can view the blob instead.
Lib/test/test_pyexpat.py
Dosyayı görüntüle @ d28fcbc7
# Very simple test - Parse a file and print what happens
# XXX TypeErrors on calling handlers, or on bad return values from a # XXX TypeErrors on calling handlers, or on bad return values from a
# handler, are obscure and unhelpful. # handler, are obscure and unhelpful.
import StringIO
import unittest
import pyexpat import pyexpat
from xml.parsers import expat from xml.parsers import expat
from test.test_support import sortdict, TestFailed from test.test_support import sortdict, run_unittest
class SetAttributeTest(unittest.TestCase):
def setUp(self):
self.parser = expat.ParserCreate(namespace_separator='!')
self.set_get_pairs = [
[0, 0],
[1, 1],
[2, 1],
[0, 0],
]
def test_returns_unicode(self):
for x, y in self.set_get_pairs:
self.parser.returns_unicode = x
self.assertEquals(self.parser.returns_unicode, y)
def test_ordered_attributes(self):
for x, y in self.set_get_pairs:
self.parser.ordered_attributes = x
self.assertEquals(self.parser.ordered_attributes, y)
def test_specified_attributes(self):
for x, y in self.set_get_pairs:
self.parser.specified_attributes = x
self.assertEquals(self.parser.specified_attributes, y)
class Outputter:
def StartElementHandler(self, name, attrs):
print 'Start element:\n\t', repr(name), sortdict(attrs)
def EndElementHandler(self, name):
print 'End element:\n\t', repr(name)
def CharacterDataHandler(self, data):
data = data.strip()
if data:
print 'Character data:'
print '\t', repr(data)
def ProcessingInstructionHandler(self, target, data):
print 'PI:\n\t', repr(target), repr(data)
def StartNamespaceDeclHandler(self, prefix, uri):
print 'NS decl:\n\t', repr(prefix), repr(uri)
def EndNamespaceDeclHandler(self, prefix):
print 'End of NS decl:\n\t', repr(prefix)
def StartCdataSectionHandler(self):
print 'Start of CDATA section'
def EndCdataSectionHandler(self):
print 'End of CDATA section'
def CommentHandler(self, text):
print 'Comment:\n\t', repr(text)
def NotationDeclHandler(self, *args):
name, base, sysid, pubid = args
print 'Notation declared:', args
def UnparsedEntityDeclHandler(self, *args):
entityName, base, systemId, publicId, notationName = args
print 'Unparsed entity decl:\n\t', args
def NotStandaloneHandler(self, userData):
print 'Not standalone'
return 1
def ExternalEntityRefHandler(self, *args):
context, base, sysId, pubId = args
print 'External entity ref:', args[1:]
return 1
def DefaultHandler(self, userData):
pass
def DefaultHandlerExpand(self, userData):
pass
def confirm(ok):
if ok:
print "OK."
else:
print "Not OK."
out = Outputter()
parser = expat.ParserCreate(namespace_separator='!')
# Test getting/setting returns_unicode
parser.returns_unicode = 0; confirm(parser.returns_unicode == 0)
parser.returns_unicode = 1; confirm(parser.returns_unicode == 1)
parser.returns_unicode = 2; confirm(parser.returns_unicode == 1)
parser.returns_unicode = 0; confirm(parser.returns_unicode == 0)
# Test getting/setting ordered_attributes
parser.ordered_attributes = 0; confirm(parser.ordered_attributes == 0)
parser.ordered_attributes = 1; confirm(parser.ordered_attributes == 1)
parser.ordered_attributes = 2; confirm(parser.ordered_attributes == 1)
parser.ordered_attributes = 0; confirm(parser.ordered_attributes == 0)
# Test getting/setting specified_attributes
parser.specified_attributes = 0; confirm(parser.specified_attributes == 0)
parser.specified_attributes = 1; confirm(parser.specified_attributes == 1)
parser.specified_attributes = 2; confirm(parser.specified_attributes == 1)
parser.specified_attributes = 0; confirm(parser.specified_attributes == 0)
HANDLER_NAMES = [
'StartElementHandler', 'EndElementHandler',
'CharacterDataHandler', 'ProcessingInstructionHandler',
'UnparsedEntityDeclHandler', 'NotationDeclHandler',
'StartNamespaceDeclHandler', 'EndNamespaceDeclHandler',
'CommentHandler', 'StartCdataSectionHandler',
'EndCdataSectionHandler',
'DefaultHandler', 'DefaultHandlerExpand',
#'NotStandaloneHandler',
'ExternalEntityRefHandler'
]
for name in HANDLER_NAMES:
setattr(parser, name, getattr(out, name))
data = '''\ data = '''\
<?xml version="1.0" encoding="iso-8859-1" standalone="no"?> <?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
...@@ -126,108 +58,228 @@ data = '''\ ...@@ -126,108 +58,228 @@ data = '''\
</root> </root>
''' '''
# Produce UTF-8 output # Produce UTF-8 output
parser.returns_unicode = 0 class ParseTest(unittest.TestCase):
try: class Outputter:
parser.Parse(data, 1) def __init__(self):
except expat.error: self.out = []
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
print '** Line', parser.ErrorLineNumber def StartElementHandler(self, name, attrs):
print '** Column', parser.ErrorColumnNumber self.out.append('Start element: ' + repr(name) + ' ' +
print '** Byte', parser.ErrorByteIndex sortdict(attrs))
# Try the parse again, this time producing Unicode output def EndElementHandler(self, name):
parser = expat.ParserCreate(namespace_separator='!') self.out.append('End element: ' + repr(name))
parser.returns_unicode = 1
def CharacterDataHandler(self, data):
for name in HANDLER_NAMES: data = data.strip()
setattr(parser, name, getattr(out, name)) if data:
try: self.out.append('Character data: ' + repr(data))
parser.Parse(data, 1)
except expat.error: def ProcessingInstructionHandler(self, target, data):
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode) self.out.append('PI: ' + repr(target) + ' ' + repr(data))
print '** Line', parser.ErrorLineNumber
print '** Column', parser.ErrorColumnNumber def StartNamespaceDeclHandler(self, prefix, uri):
print '** Byte', parser.ErrorByteIndex self.out.append('NS decl: ' + repr(prefix) + ' ' + repr(uri))
# Try parsing a file def EndNamespaceDeclHandler(self, prefix):
parser = expat.ParserCreate(namespace_separator='!') self.out.append('End of NS decl: ' + repr(prefix))
parser.returns_unicode = 1
def StartCdataSectionHandler(self):
for name in HANDLER_NAMES: self.out.append('Start of CDATA section')
setattr(parser, name, getattr(out, name))
import StringIO def EndCdataSectionHandler(self):
file = StringIO.StringIO(data) self.out.append('End of CDATA section')
try:
parser.ParseFile(file) def CommentHandler(self, text):
except expat.error: self.out.append('Comment: ' + repr(text))
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
print '** Line', parser.ErrorLineNumber def NotationDeclHandler(self, *args):
print '** Column', parser.ErrorColumnNumber name, base, sysid, pubid = args
print '** Byte', parser.ErrorByteIndex self.out.append('Notation declared: %s' %(args,))
def UnparsedEntityDeclHandler(self, *args):
# Tests that make sure we get errors when the namespace_separator value entityName, base, systemId, publicId, notationName = args
# is illegal, and that we don't for good values: self.out.append('Unparsed entity decl: %s' %(args,))
print
print "Testing constructor for proper handling of namespace_separator values:" def NotStandaloneHandler(self, userData):
expat.ParserCreate() self.out.append('Not standalone')
expat.ParserCreate(namespace_separator=None) return 1
expat.ParserCreate(namespace_separator=' ')
print "Legal values tested o.k." def ExternalEntityRefHandler(self, *args):
try: context, base, sysId, pubId = args
expat.ParserCreate(namespace_separator=42) self.out.append('External entity ref: %s' %(args[1:],))
except TypeError, e: return 1
print "Caught expected TypeError:"
print e def DefaultHandler(self, userData):
else: pass
print "Failed to catch expected TypeError."
def DefaultHandlerExpand(self, userData):
try: pass
expat.ParserCreate(namespace_separator='too long')
except ValueError, e: handler_names = [
print "Caught expected ValueError:" 'StartElementHandler', 'EndElementHandler',
print e 'CharacterDataHandler', 'ProcessingInstructionHandler',
else: 'UnparsedEntityDeclHandler', 'NotationDeclHandler',
print "Failed to catch expected ValueError." 'StartNamespaceDeclHandler', 'EndNamespaceDeclHandler',
'CommentHandler', 'StartCdataSectionHandler',
# ParserCreate() needs to accept a namespace_separator of zero length 'EndCdataSectionHandler',
# to satisfy the requirements of RDF applications that are required 'DefaultHandler', 'DefaultHandlerExpand',
# to simply glue together the namespace URI and the localname. Though #'NotStandaloneHandler',
# considered a wart of the RDF specifications, it needs to be supported. 'ExternalEntityRefHandler'
# ]
# See XML-SIG mailing list thread starting with
# http://mail.python.org/pipermail/xml-sig/2001-April/005202.html def test_utf8(self):
#
expat.ParserCreate(namespace_separator='') # too short out = self.Outputter()
parser = expat.ParserCreate(namespace_separator='!')
# Test the interning machinery. for name in self.handler_names:
p = expat.ParserCreate() setattr(parser, name, getattr(out, name))
L = [] parser.returns_unicode = 0
def collector(name, *args): parser.Parse(data, 1)
L.append(name)
p.StartElementHandler = collector # Verify output
p.EndElementHandler = collector op = out.out
p.Parse("<e> <e/> <e></e> </e>", 1) self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
tag = L[0] self.assertEquals(op[1], "Comment: ' comment data '")
if len(L) != 6: self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
print "L should only contain 6 entries; found", len(L) self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
for entry in L: self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}")
if tag is not entry: self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
print "expected L to contain many references to the same string", self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
print "(it didn't)" self.assertEquals(op[7], "Character data: 'Contents of subelements'")
print "L =", repr(L) self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'")
break self.assertEquals(op[9], "End of NS decl: 'myns'")
self.assertEquals(op[10], "Start element: 'sub2' {}")
# Tests of the buffer_text attribute. self.assertEquals(op[11], 'Start of CDATA section')
import sys self.assertEquals(op[12], "Character data: 'contents of CDATA section'")
self.assertEquals(op[13], 'End of CDATA section')
class TextCollector: self.assertEquals(op[14], "End element: 'sub2'")
def __init__(self, parser): self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)")
self.assertEquals(op[16], "End element: 'root'")
def test_unicode(self):
# Try the parse again, this time producing Unicode output
out = self.Outputter()
parser = expat.ParserCreate(namespace_separator='!')
parser.returns_unicode = 1
for name in self.handler_names:
setattr(parser, name, getattr(out, name))
parser.Parse(data, 1)
op = out.out
self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
self.assertEquals(op[1], "Comment: u' comment data '")
self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
self.assertEquals(op[7], "Character data: u'Contents of subelements'")
self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
self.assertEquals(op[9], "End of NS decl: u'myns'")
self.assertEquals(op[10], "Start element: u'sub2' {}")
self.assertEquals(op[11], 'Start of CDATA section')
self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
self.assertEquals(op[13], 'End of CDATA section')
self.assertEquals(op[14], "End element: u'sub2'")
self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
self.assertEquals(op[16], "End element: u'root'")
def test_parse_file(self):
# Try parsing a file
out = self.Outputter()
parser = expat.ParserCreate(namespace_separator='!')
parser.returns_unicode = 1
for name in self.handler_names:
setattr(parser, name, getattr(out, name))
file = StringIO.StringIO(data)
parser.ParseFile(file)
op = out.out
self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
self.assertEquals(op[1], "Comment: u' comment data '")
self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
self.assertEquals(op[7], "Character data: u'Contents of subelements'")
self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
self.assertEquals(op[9], "End of NS decl: u'myns'")
self.assertEquals(op[10], "Start element: u'sub2' {}")
self.assertEquals(op[11], 'Start of CDATA section')
self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
self.assertEquals(op[13], 'End of CDATA section')
self.assertEquals(op[14], "End element: u'sub2'")
self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
self.assertEquals(op[16], "End element: u'root'")
class NamespaceSeparatorTest(unittest.TestCase):
def test_legal(self):
# Tests that make sure we get errors when the namespace_separator value
# is illegal, and that we don't for good values:
expat.ParserCreate()
expat.ParserCreate(namespace_separator=None)
expat.ParserCreate(namespace_separator=' ')
def test_illegal(self):
try:
expat.ParserCreate(namespace_separator=42)
self.fail()
except TypeError, e:
self.assertEquals(str(e),
'ParserCreate() argument 2 must be string or None, not int')
try:
expat.ParserCreate(namespace_separator='too long')
self.fail()
except ValueError, e:
self.assertEquals(str(e),
'namespace_separator must be at most one character, omitted, or None')
def test_zero_length(self):
# ParserCreate() needs to accept a namespace_separator of zero length
# to satisfy the requirements of RDF applications that are required
# to simply glue together the namespace URI and the localname. Though
# considered a wart of the RDF specifications, it needs to be supported.
#
# See XML-SIG mailing list thread starting with
# http://mail.python.org/pipermail/xml-sig/2001-April/005202.html
#
expat.ParserCreate(namespace_separator='') # too short
class InterningTest(unittest.TestCase):
def test(self):
# Test the interning machinery.
p = expat.ParserCreate()
L = []
def collector(name, *args):
L.append(name)
p.StartElementHandler = collector
p.EndElementHandler = collector
p.Parse("<e> <e/> <e></e> </e>", 1)
tag = L[0]
self.assertEquals(len(L), 6)
for entry in L:
# L should have the same string repeated over and over.
self.assertTrue(tag is entry)
class BufferTextTest(unittest.TestCase):
def setUp(self):
self.stuff = [] self.stuff = []
self.parser = expat.ParserCreate()
self.parser.buffer_text = 1
self.parser.CharacterDataHandler = self.CharacterDataHandler
def check(self, expected, label): def check(self, expected, label):
require(self.stuff == expected, self.assertEquals(self.stuff, expected,
"%s\nstuff = %r\nexpected = %r" "%s\nstuff = %r\nexpected = %r"
% (label, self.stuff, map(unicode, expected))) % (label, self.stuff, map(unicode, expected)))
...@@ -238,9 +290,9 @@ class TextCollector: ...@@ -238,9 +290,9 @@ class TextCollector:
self.stuff.append("<%s>" % name) self.stuff.append("<%s>" % name)
bt = attrs.get("buffer-text") bt = attrs.get("buffer-text")
if bt == "yes": if bt == "yes":
parser.buffer_text = 1 self.parser.buffer_text = 1
elif bt == "no": elif bt == "no":
parser.buffer_text = 0 self.parser.buffer_text = 0
def EndElementHandler(self, name): def EndElementHandler(self, name):
self.stuff.append("</%s>" % name) self.stuff.append("</%s>" % name)
...@@ -248,95 +300,91 @@ class TextCollector: ...@@ -248,95 +300,91 @@ class TextCollector:
def CommentHandler(self, data): def CommentHandler(self, data):
self.stuff.append("<!--%s-->" % data) self.stuff.append("<!--%s-->" % data)
def require(cond, label): def setHandlers(self, handlers=[]):
# similar to confirm(), but no extraneous output for name in handlers:
if not cond: setattr(self.parser, name, getattr(self, name))
raise TestFailed(label)
def test_default_to_disabled(self):
def setup(handlers=[]): parser = expat.ParserCreate()
parser = expat.ParserCreate() self.assertFalse(parser.buffer_text)
require(not parser.buffer_text,
"buffer_text not disabled by default") def test_buffering_enabled(self):
parser.buffer_text = 1 # Make sure buffering is turned on
handler = TextCollector(parser) self.assertTrue(self.parser.buffer_text)
parser.CharacterDataHandler = handler.CharacterDataHandler self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
for name in handlers: self.assertEquals(self.stuff, ['123'],
setattr(parser, name, getattr(handler, name)) "buffered text not properly collapsed")
return parser, handler
def test1(self):
parser, handler = setup() # XXX This test exposes more detail of Expat's text chunking than we
require(parser.buffer_text, # XXX like, but it tests what we need to concisely.
"text buffering either not acknowledged or not enabled") self.setHandlers(["StartElementHandler"])
parser.Parse("<a>1<b/>2<c/>3</a>", 1) self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
handler.check(["123"], self.assertEquals(self.stuff,
"buffered text not properly collapsed") ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
"buffering control not reacting as expected")
# XXX This test exposes more detail of Expat's text chunking than we
# XXX like, but it tests what we need to concisely. def test2(self):
parser, handler = setup(["StartElementHandler"]) self.parser.Parse("<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", 1)
parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1) self.assertEquals(self.stuff, ["1<2> \n 3"],
handler.check(["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"], "buffered text not properly collapsed")
"buffering control not reacting as expected")
def test3(self):
parser, handler = setup() self.setHandlers(["StartElementHandler"])
parser.Parse("<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", 1) self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
handler.check(["1<2> \n 3"], self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
"buffered text not properly collapsed") "buffered text not properly split")
parser, handler = setup(["StartElementHandler"]) def test4(self):
parser.Parse("<a>1<b/>2<c/>3</a>", 1) self.setHandlers(["StartElementHandler", "EndElementHandler"])
handler.check(["<a>", "1", "<b>", "2", "<c>", "3"], self.parser.CharacterDataHandler = None
"buffered text not properly split") self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
self.assertEquals(self.stuff,
parser, handler = setup(["StartElementHandler", "EndElementHandler"]) ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
parser.CharacterDataHandler = None
parser.Parse("<a>1<b/>2<c/>3</a>", 1) def test5(self):
handler.check(["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"], self.setHandlers(["StartElementHandler", "EndElementHandler"])
"huh?") self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
self.assertEquals(self.stuff,
parser, handler = setup(["StartElementHandler", "EndElementHandler"]) ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
handler.check(["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"], def test6(self):
"huh?") self.setHandlers(["CommentHandler", "EndElementHandler",
"StartElementHandler"])
parser, handler = setup(["CommentHandler", "EndElementHandler", self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
"StartElementHandler"]) self.assertEquals(self.stuff,
parser.Parse("<a>1<b/>2<c></c>345</a> ", 1) ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
handler.check(["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"], "buffered text not properly split")
"buffered text not properly split")
def test7(self):
parser, handler = setup(["CommentHandler", "EndElementHandler", self.setHandlers(["CommentHandler", "EndElementHandler",
"StartElementHandler"]) "StartElementHandler"])
parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1) self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1)
handler.check(["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", self.assertEquals(self.stuff,
"<!--abc-->", "4", "<!--def-->", "5", "</a>"], ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
"buffered text not properly split") "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
"buffered text not properly split")
# Test handling of exception from callback: # Test handling of exception from callback:
def StartElementHandler(name, attrs): class HandlerExceptionTest(unittest.TestCase):
raise RuntimeError(name) def StartElementHandler(self, name, attrs):
raise RuntimeError(name)
parser = expat.ParserCreate() def test(self):
parser.StartElementHandler = StartElementHandler parser = expat.ParserCreate()
parser.StartElementHandler = self.StartElementHandler
try:
parser.Parse("<a><b><c/></b></a>", 1)
self.fail()
except RuntimeError, e:
self.assertEquals(e.args[0], 'a',
"Expected RuntimeError for element 'a', but" + \
" found %r" % e.args[0])
try:
parser.Parse("<a><b><c/></b></a>", 1)
except RuntimeError, e:
if e.args[0] != "a":
print "Expected RuntimeError for element 'a'; found %r" % e.args[0]
else:
print "Expected RuntimeError for 'a'"
# Test Current* members: # Test Current* members:
class PositionTest: class PositionTest(unittest.TestCase):
def __init__(self, expected_list, parser):
self.parser = parser
self.parser.StartElementHandler = self.StartElementHandler
self.parser.EndElementHandler = self.EndElementHandler
self.expected_list = expected_list
self.upto = 0
def StartElementHandler(self, name, attrs): def StartElementHandler(self, name, attrs):
self.check_pos('s') self.check_pos('s')
...@@ -348,41 +396,54 @@ class PositionTest: ...@@ -348,41 +396,54 @@ class PositionTest:
self.parser.CurrentByteIndex, self.parser.CurrentByteIndex,
self.parser.CurrentLineNumber, self.parser.CurrentLineNumber,
self.parser.CurrentColumnNumber) self.parser.CurrentColumnNumber)
require(self.upto < len(self.expected_list), self.assertTrue(self.upto < len(self.expected_list),
'too many parser events') 'too many parser events')
expected = self.expected_list[self.upto] expected = self.expected_list[self.upto]
require(pos == expected, self.assertEquals(pos, expected,
'expected position %s, got %s' % (expected, pos)) 'Expected position %s, got position %s' %(pos, expected))
self.upto += 1 self.upto += 1
def test(self):
parser = expat.ParserCreate() self.parser = expat.ParserCreate()
handler = PositionTest([('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2), self.parser.StartElementHandler = self.StartElementHandler
('e', 15, 3, 6), ('e', 17, 4, 1), ('e', 22, 5, 0)], self.parser.EndElementHandler = self.EndElementHandler
parser) self.upto = 0
parser.Parse('''<a> self.expected_list = [('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2),
<b> ('e', 15, 3, 6), ('e', 17, 4, 1), ('e', 22, 5, 0)]
<c/>
</b> xml = '<a>\n <b>\n <c/>\n </b>\n</a>'
</a>''', 1) self.parser.Parse(xml, 1)
def test_parse_only_xml_data(): class sf1296433Test(unittest.TestCase):
# http://python.org/sf/1296433 def test_parse_only_xml_data(self):
# # http://python.org/sf/1296433
xml = "<?xml version='1.0' encoding='iso8859'?><s>%s</s>" % ('a' * 1025) #
# this one doesn't crash xml = "<?xml version='1.0' encoding='iso8859'?><s>%s</s>" % ('a' * 1025)
#xml = "<?xml version='1.0'?><s>%s</s>" % ('a' * 10000) # this one doesn't crash
#xml = "<?xml version='1.0'?><s>%s</s>" % ('a' * 10000)
def handler(text):
raise Exception class SpecificException(Exception):
pass
parser = expat.ParserCreate()
parser.CharacterDataHandler = handler def handler(text):
raise SpecificException
try:
parser.Parse(xml) parser = expat.ParserCreate()
except: parser.CharacterDataHandler = handler
pass
self.assertRaises(Exception, parser.Parse, xml)
test_parse_only_xml_data()
def test_main():
run_unittest(SetAttributeTest,
ParseTest,
NamespaceSeparatorTest,
InterningTest,
BufferTextTest,
HandlerExceptionTest,
PositionTest,
sf1296433Test)
if __name__ == "__main__":
test_main()
Lib/test/test_sax.py
Dosyayı görüntüle @ d28fcbc7
...@@ -13,26 +13,66 @@ from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \ ...@@ -13,26 +13,66 @@ from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
from xml.sax.expatreader import create_parser from xml.sax.expatreader import create_parser
from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
from cStringIO import StringIO from cStringIO import StringIO
from test.test_support import verify, verbose, TestFailed, findfile from test.test_support import findfile, run_unittest
import unittest
import os import os
# ===== Utilities ns_uri = "http://www.python.org/xml-ns/saxtest/"
tests = 0
failures = []
def confirm(outcome, name):
global tests
tests = tests + 1
if outcome:
if verbose:
print "Passed", name
else:
failures.append(name)
def test_make_parser2(): class XmlTestBase(unittest.TestCase):
try: 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(attrs.has_key("attr"))
self.assertEquals(attrs.keys(), [])
self.assertEquals(attrs.get("attrs"), None)
self.assertEquals(attrs.get("attrs", 25), 25)
self.assertEquals(attrs.items(), [])
self.assertEquals(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(attrs.has_key((ns_uri, "attr")))
self.assertEquals(attrs.keys(), [])
self.assertEquals(attrs.get((ns_uri, "attr")), None)
self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
self.assertEquals(attrs.items(), [])
self.assertEquals(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(attrs.has_key("attr"))
self.assertEquals(attrs.keys(), ["attr"])
self.assertEquals(attrs.get("attr"), "val")
self.assertEquals(attrs.get("attr", 25), "val")
self.assertEquals(attrs.items(), [("attr", "val")])
self.assertEquals(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. # Creating parsers several times in a row should succeed.
# Testing this because there have been failures of this kind # Testing this because there have been failures of this kind
# before. # before.
...@@ -48,10 +88,6 @@ def test_make_parser2(): ...@@ -48,10 +88,6 @@ def test_make_parser2():
p = make_parser() p = make_parser()
from xml.sax import make_parser from xml.sax import make_parser
p = make_parser() p = make_parser()
except:
return 0
else:
return p
# =========================================================================== # ===========================================================================
...@@ -60,215 +96,214 @@ def test_make_parser2(): ...@@ -60,215 +96,214 @@ def test_make_parser2():
# #
# =========================================================================== # ===========================================================================
# ===== escape class SaxutilsTest(unittest.TestCase):
# ===== escape
def test_escape_basic(): def test_escape_basic(self):
return escape("Donald Duck & Co") == "Donald Duck &amp; Co" self.assertEquals(escape("Donald Duck & Co"), "Donald Duck &amp; Co")
def test_escape_all(): def test_escape_all(self):
return escape("<Donald Duck & Co>") == "&lt;Donald Duck &amp; Co&gt;" self.assertEquals(escape("<Donald Duck & Co>"),
"&lt;Donald Duck &amp; Co&gt;")
def test_escape_extra():
return escape("Hei p deg", {"" : "&aring;"}) == "Hei p&aring; deg" def test_escape_extra(self):
self.assertEquals(escape("Hei p deg", {"" : "&aring;"}),
# ===== unescape "Hei p&aring; deg")
def test_unescape_basic(): # ===== unescape
return unescape("Donald Duck &amp; Co") == "Donald Duck & Co" def test_unescape_basic(self):
self.assertEquals(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
def test_unescape_all():
return unescape("&lt;Donald Duck &amp; Co&gt;") == "<Donald Duck & Co>" def test_unescape_all(self):
self.assertEquals(unescape("&lt;Donald Duck &amp; Co&gt;"),
def test_unescape_extra(): "<Donald Duck & Co>")
return unescape("Hei p deg", {"" : "&aring;"}) == "Hei p&aring; deg"
def test_unescape_extra(self):
def test_unescape_amp_extra(): self.assertEquals(unescape("Hei p deg", {"" : "&aring;"}),
return unescape("&amp;foo;", {"&foo;": "splat"}) == "&foo;" "Hei p&aring; deg")
# ===== quoteattr def test_unescape_amp_extra(self):
self.assertEquals(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
def test_quoteattr_basic():
return quoteattr("Donald Duck & Co") == '"Donald Duck &amp; Co"' # ===== quoteattr
def test_quoteattr_basic(self):
def test_single_quoteattr(): self.assertEquals(quoteattr("Donald Duck & Co"),
return (quoteattr('Includes "double" quotes') '"Donald Duck &amp; Co"')
== '\'Includes "double" quotes\'')
def test_single_quoteattr(self):
def test_double_quoteattr(): self.assertEquals(quoteattr('Includes "double" quotes'),
return (quoteattr("Includes 'single' quotes") '\'Includes "double" quotes\'')
== "\"Includes 'single' quotes\"")
def test_double_quoteattr(self):
def test_single_double_quoteattr(): self.assertEquals(quoteattr("Includes 'single' quotes"),
return (quoteattr("Includes 'single' and \"double\" quotes") "\"Includes 'single' quotes\"")
== "\"Includes 'single' and &quot;double&quot; quotes\"")
def test_single_double_quoteattr(self):
# ===== make_parser self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"),
"\"Includes 'single' and &quot;double&quot; quotes\"")
def test_make_parser():
try: # ===== make_parser
def test_make_parser(self):
# Creating a parser should succeed - it should fall back # Creating a parser should succeed - it should fall back
# to the expatreader # to the expatreader
p = make_parser(['xml.parsers.no_such_parser']) p = make_parser(['xml.parsers.no_such_parser'])
except:
return 0
else:
return p
# ===== XMLGenerator # ===== XMLGenerator
start = '<?xml version="1.0" encoding="iso-8859-1"?>\n' start = '<?xml version="1.0" encoding="iso-8859-1"?>\n'
def test_xmlgen_basic(): class XmlgenTest(unittest.TestCase):
result = StringIO() def test_xmlgen_basic(self):
gen = XMLGenerator(result) result = StringIO()
gen.startDocument() gen = XMLGenerator(result)
gen.startElement("doc", {}) gen.startDocument()
gen.endElement("doc") gen.startElement("doc", {})
gen.endDocument() gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc></doc>"
self.assertEquals(result.getvalue(), start + "<doc></doc>")
def test_xmlgen_content():
result = StringIO() def test_xmlgen_content(self):
gen = XMLGenerator(result) result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {}) gen.startDocument()
gen.characters("huhei") gen.startElement("doc", {})
gen.endElement("doc") gen.characters("huhei")
gen.endDocument() gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc>huhei</doc>"
self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>")
def test_xmlgen_pi():
result = StringIO() def test_xmlgen_pi(self):
gen = XMLGenerator(result) result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.processingInstruction("test", "data") gen.startDocument()
gen.startElement("doc", {}) gen.processingInstruction("test", "data")
gen.endElement("doc") gen.startElement("doc", {})
gen.endDocument() gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<?test data?><doc></doc>"
self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>")
def test_xmlgen_content_escape():
result = StringIO() def test_xmlgen_content_escape(self):
gen = XMLGenerator(result) result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {}) gen.startDocument()
gen.characters("<huhei&") gen.startElement("doc", {})
gen.endElement("doc") gen.characters("<huhei&")
gen.endDocument() gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc>&lt;huhei&amp;</doc>"
self.assertEquals(result.getvalue(),
def test_xmlgen_attr_escape(): start + "<doc>&lt;huhei&amp;</doc>")
result = StringIO()
gen = XMLGenerator(result) def test_xmlgen_attr_escape(self):
result = StringIO()
gen.startDocument() gen = XMLGenerator(result)
gen.startElement("doc", {"a": '"'})
gen.startElement("e", {"a": "'"}) gen.startDocument()
gen.endElement("e") gen.startElement("doc", {"a": '"'})
gen.startElement("e", {"a": "'\""}) gen.startElement("e", {"a": "'"})
gen.endElement("e") gen.endElement("e")
gen.startElement("e", {"a": "\n\r\t"}) gen.startElement("e", {"a": "'\""})
gen.endElement("e") gen.endElement("e")
gen.endElement("doc") gen.startElement("e", {"a": "\n\r\t"})
gen.endDocument() gen.endElement("e")
gen.endElement("doc")
return result.getvalue() == start + ("<doc a='\"'><e a=\"'\"></e>" gen.endDocument()
"<e a=\"'&quot;\"></e>"
"<e a=\"&#10;&#13;&#9;\"></e></doc>") self.assertEquals(result.getvalue(), start +
("<doc a='\"'><e a=\"'\"></e>"
def test_xmlgen_ignorable(): "<e a=\"'&quot;\"></e>"
result = StringIO() "<e a=\"&#10;&#13;&#9;\"></e></doc>"))
gen = XMLGenerator(result)
def test_xmlgen_ignorable(self):
gen.startDocument() result = StringIO()
gen.startElement("doc", {}) gen = XMLGenerator(result)
gen.ignorableWhitespace(" ")
gen.endElement("doc") gen.startDocument()
gen.endDocument() gen.startElement("doc", {})
gen.ignorableWhitespace(" ")
return result.getvalue() == start + "<doc> </doc>" gen.endElement("doc")
gen.endDocument()
ns_uri = "http://www.python.org/xml-ns/saxtest/"
self.assertEquals(result.getvalue(), start + "<doc> </doc>")
def test_xmlgen_ns():
result = StringIO() def test_xmlgen_ns(self):
gen = XMLGenerator(result) result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startPrefixMapping("ns1", ns_uri) gen.startDocument()
gen.startElementNS((ns_uri, "doc"), "ns1:doc", {}) gen.startPrefixMapping("ns1", ns_uri)
# add an unqualified name gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
gen.startElementNS((None, "udoc"), None, {}) # add an unqualified name
gen.endElementNS((None, "udoc"), None) gen.startElementNS((None, "udoc"), None, {})
gen.endElementNS((ns_uri, "doc"), "ns1:doc") gen.endElementNS((None, "udoc"), None)
gen.endPrefixMapping("ns1") gen.endElementNS((ns_uri, "doc"), "ns1:doc")
gen.endDocument() gen.endPrefixMapping("ns1")
gen.endDocument()
return result.getvalue() == start + \
self.assertEquals(result.getvalue(), start + \
('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' % ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
ns_uri) ns_uri))
def test_1463026_1(): def test_1463026_1(self):
result = StringIO() result = StringIO()
gen = XMLGenerator(result) gen = XMLGenerator(result)
gen.startDocument() gen.startDocument()
gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'}) gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
gen.endElementNS((None, 'a'), 'a') gen.endElementNS((None, 'a'), 'a')
gen.endDocument() gen.endDocument()
return result.getvalue() == start+'<a b="c"></a>' self.assertEquals(result.getvalue(), start+'<a b="c"></a>')
def test_1463026_2(): def test_1463026_2(self):
result = StringIO() result = StringIO()
gen = XMLGenerator(result) gen = XMLGenerator(result)
gen.startDocument() gen.startDocument()
gen.startPrefixMapping(None, 'qux') gen.startPrefixMapping(None, 'qux')
gen.startElementNS(('qux', 'a'), 'a', {}) gen.startElementNS(('qux', 'a'), 'a', {})
gen.endElementNS(('qux', 'a'), 'a') gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping(None) gen.endPrefixMapping(None)
gen.endDocument() gen.endDocument()
return result.getvalue() == start+'<a xmlns="qux"></a>' self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>')
def test_1463026_3(): def test_1463026_3(self):
result = StringIO() result = StringIO()
gen = XMLGenerator(result) gen = XMLGenerator(result)
gen.startDocument() gen.startDocument()
gen.startPrefixMapping('my', 'qux') gen.startPrefixMapping('my', 'qux')
gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'}) gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
gen.endElementNS(('qux', 'a'), 'a') gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping('my') gen.endPrefixMapping('my')
gen.endDocument() gen.endDocument()
return result.getvalue() == start+'<my:a xmlns:my="qux" b="c"></my:a>' self.assertEquals(result.getvalue(),
start+'<my:a xmlns:my="qux" b="c"></my:a>')
# ===== Xmlfilterbase
def test_filter_basic(): class XMLFilterBaseTest(unittest.TestCase):
result = StringIO() def test_filter_basic(self):
gen = XMLGenerator(result) result = StringIO()
filter = XMLFilterBase() gen = XMLGenerator(result)
filter.setContentHandler(gen) filter = XMLFilterBase()
filter.setContentHandler(gen)
filter.startDocument() filter.startDocument()
filter.startElement("doc", {}) filter.startElement("doc", {})
filter.characters("content") filter.characters("content")
filter.ignorableWhitespace(" ") filter.ignorableWhitespace(" ")
filter.endElement("doc") filter.endElement("doc")
filter.endDocument() filter.endDocument()
return result.getvalue() == start + "<doc>content </doc>" self.assertEquals(result.getvalue(), start + "<doc>content </doc>")
# =========================================================================== # ===========================================================================
# #
...@@ -276,294 +311,294 @@ def test_filter_basic(): ...@@ -276,294 +311,294 @@ def test_filter_basic():
# #
# =========================================================================== # ===========================================================================
# ===== XMLReader support
def test_expat_file():
parser = create_parser()
result = StringIO()
xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
parser.parse(open(findfile("test"+os.extsep+"xml")))
return 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():
parser = create_parser()
handler = 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()
return handler._notations == [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)] and \
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():
parser = create_parser()
parser.setEntityResolver(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()
return 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():
parser = create_parser()
gather = AttrGatherer()
parser.setContentHandler(gather)
parser.feed("<doc/>")
parser.close()
return verify_empty_attrs(gather._attrs)
def test_expat_attrs_wattr():
parser = create_parser()
gather = AttrGatherer()
parser.setContentHandler(gather)
parser.feed("<doc attr='val'/>")
parser.close()
return verify_attrs_wattr(gather._attrs)
def test_expat_nsattrs_empty():
parser = create_parser(1)
gather = AttrGatherer()
parser.setContentHandler(gather)
parser.feed("<doc/>")
parser.close()
return verify_empty_nsattrs(gather._attrs)
def test_expat_nsattrs_wattr():
parser = create_parser(1)
gather = AttrGatherer()
parser.setContentHandler(gather)
parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
parser.close()
attrs = gather._attrs
return attrs.getLength() == 1 and \
attrs.getNames() == [(ns_uri, "attr")] and \
(attrs.getQNames() == [] or attrs.getQNames() == ["ns:attr"]) and \
len(attrs) == 1 and \
attrs.has_key((ns_uri, "attr")) and \
attrs.keys() == [(ns_uri, "attr")] and \
attrs.get((ns_uri, "attr")) == "val" and \
attrs.get((ns_uri, "attr"), 25) == "val" and \
attrs.items() == [((ns_uri, "attr"), "val")] and \
attrs.values() == ["val"] and \
attrs.getValue((ns_uri, "attr")) == "val" and \
attrs[(ns_uri, "attr")] == "val"
# ===== InputSource support
xml_test_out = open(findfile("test"+os.extsep+"xml"+os.extsep+"out")).read() xml_test_out = open(findfile("test"+os.extsep+"xml"+os.extsep+"out")).read()
def test_expat_inpsource_filename(): class ExpatReaderTest(XmlTestBase):
parser = create_parser()
result = StringIO() # ===== XMLReader support
xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
parser.parse(findfile("test"+os.extsep+"xml"))
return result.getvalue() == xml_test_out
def test_expat_inpsource_sysid():
parser = create_parser()
result = StringIO()
xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
parser.parse(InputSource(findfile("test"+os.extsep+"xml")))
return result.getvalue() == xml_test_out
def test_expat_inpsource_stream():
parser = create_parser()
result = StringIO()
xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
inpsrc = InputSource()
inpsrc.setByteStream(open(findfile("test"+os.extsep+"xml")))
parser.parse(inpsrc)
return result.getvalue() == xml_test_out
# ===== IncrementalParser support
def test_expat_incremental(): def test_expat_file(self):
result = StringIO() parser = create_parser()
xmlgen = XMLGenerator(result) result = StringIO()
parser = create_parser() xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
parser.feed("<doc>") parser.setContentHandler(xmlgen)
parser.feed("</doc>") parser.parse(open(findfile("test"+os.extsep+"xml")))
parser.close()
return result.getvalue() == start + "<doc></doc>" self.assertEquals(result.getvalue(), xml_test_out)
def test_expat_incremental_reset(): # ===== DTDHandler support
result = StringIO()
xmlgen = XMLGenerator(result)
parser = create_parser()
parser.setContentHandler(xmlgen)
parser.feed("<doc>") class TestDTDHandler:
parser.feed("text")
result = StringIO() def __init__(self):
xmlgen = XMLGenerator(result) self._notations = []
parser.setContentHandler(xmlgen) self._entities = []
parser.reset()
parser.feed("<doc>") def notationDecl(self, name, publicId, systemId):
parser.feed("text") self._notations.append((name, publicId, systemId))
parser.feed("</doc>")
parser.close()
return result.getvalue() == start + "<doc>text</doc>" def unparsedEntityDecl(self, name, publicId, systemId, ndata):
self._entities.append((name, publicId, systemId, ndata))
# ===== Locator support def test_expat_dtdhandler(self):
parser = create_parser()
handler = self.TestDTDHandler()
parser.setDTDHandler(handler)
def test_expat_locator_noinfo(): parser.feed('<!DOCTYPE doc [\n')
result = StringIO() parser.feed(' <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
xmlgen = XMLGenerator(result) parser.feed(' <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
parser = create_parser() parser.feed(']>\n')
parser.setContentHandler(xmlgen) parser.feed('<doc></doc>')
parser.close()
parser.feed("<doc>") self.assertEquals(handler._notations,
parser.feed("</doc>") [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
parser.close() self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")])
return parser.getSystemId() is None and \ # ===== EntityResolver support
parser.getPublicId() is None and \
parser.getLineNumber() == 1
def test_expat_locator_withinfo(): class TestEntityResolver:
result = StringIO()
xmlgen = XMLGenerator(result)
parser = create_parser()
parser.setContentHandler(xmlgen)
parser.parse(findfile("test.xml"))
return parser.getSystemId() == findfile("test.xml") and \
parser.getPublicId() is None
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(attrs.has_key((ns_uri, "attr")))
self.assertEquals(attrs.get((ns_uri, "attr")), "val")
self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
self.assertEquals(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 # error reporting
# #
# =========================================================================== # ===========================================================================
def test_expat_inpsource_location(): class ErrorReportingTest(unittest.TestCase):
parser = create_parser() def test_expat_inpsource_location(self):
parser.setContentHandler(ContentHandler()) # do nothing parser = create_parser()
source = InputSource() parser.setContentHandler(ContentHandler()) # do nothing
source.setByteStream(StringIO("<foo bar foobar>")) #ill-formed source = InputSource()
name = "a file name" source.setByteStream(StringIO("<foo bar foobar>")) #ill-formed
source.setSystemId(name) name = "a file name"
try: source.setSystemId(name)
parser.parse(source) try:
except SAXException, e: parser.parse(source)
return e.getSystemId() == name self.fail()
except SAXException, e:
def test_expat_incomplete(): self.assertEquals(e.getSystemId(), name)
parser = create_parser()
parser.setContentHandler(ContentHandler()) # do nothing def test_expat_incomplete(self):
try: parser = create_parser()
parser.parse(StringIO("<foo>")) parser.setContentHandler(ContentHandler()) # do nothing
except SAXParseException: self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
return 1 # ok, error found
else: def test_sax_parse_exception_str(self):
return 0 # pass various values from a locator to the SAXParseException to
# make sure that the __str__() doesn't fall apart when None is
def test_sax_parse_exception_str(): # passed instead of an integer line and column number
# pass various values from a locator to the SAXParseException to #
# make sure that the __str__() doesn't fall apart when None is # use "normal" values for the locator:
# passed instead of an integer line and column number str(SAXParseException("message", None,
# self.DummyLocator(1, 1)))
# use "normal" values for the locator: # use None for the line number:
str(SAXParseException("message", None, str(SAXParseException("message", None,
DummyLocator(1, 1))) self.DummyLocator(None, 1)))
# use None for the line number: # use None for the column number:
str(SAXParseException("message", None, str(SAXParseException("message", None,
DummyLocator(None, 1))) self.DummyLocator(1, None)))
# use None for the column number: # use None for both:
str(SAXParseException("message", None, str(SAXParseException("message", None,
DummyLocator(1, None))) self.DummyLocator(None, None)))
# use None for both:
str(SAXParseException("message", None, class DummyLocator:
DummyLocator(None, None))) def __init__(self, lineno, colno):
return 1 self._lineno = lineno
self._colno = colno
class DummyLocator:
def __init__(self, lineno, colno): def getPublicId(self):
self._lineno = lineno return "pubid"
self._colno = colno
def getSystemId(self):
def getPublicId(self): return "sysid"
return "pubid"
def getLineNumber(self):
def getSystemId(self): return self._lineno
return "sysid"
def getColumnNumber(self):
def getLineNumber(self): return self._colno
return self._lineno
def getColumnNumber(self):
return self._colno
# =========================================================================== # ===========================================================================
# #
...@@ -571,218 +606,91 @@ class DummyLocator: ...@@ -571,218 +606,91 @@ class DummyLocator:
# #
# =========================================================================== # ===========================================================================
# ===== AttributesImpl class XmlReaderTest(XmlTestBase):
def verify_empty_attrs(attrs): # ===== AttributesImpl
try: def test_attrs_empty(self):
attrs.getValue("attr") self.verify_empty_attrs(AttributesImpl({}))
gvk = 0
except KeyError: def test_attrs_wattr(self):
gvk = 1 self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
try: def test_nsattrs_empty(self):
attrs.getValueByQName("attr") self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
gvqk = 0
except KeyError: def test_nsattrs_wattr(self):
gvqk = 1 attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
{(ns_uri, "attr") : "ns:attr"})
try:
attrs.getNameByQName("attr") self.assertEquals(attrs.getLength(), 1)
gnqk = 0 self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
except KeyError: self.assertEquals(attrs.getQNames(), ["ns:attr"])
gnqk = 1 self.assertEquals(len(attrs), 1)
self.assertTrue(attrs.has_key((ns_uri, "attr")))
try: self.assertEquals(attrs.keys(), [(ns_uri, "attr")])
attrs.getQNameByName("attr") self.assertEquals(attrs.get((ns_uri, "attr")), "val")
gqnk = 0 self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
except KeyError: self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
gqnk = 1 self.assertEquals(attrs.values(), ["val"])
self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
try: self.assertEquals(attrs.getValueByQName("ns:attr"), "val")
attrs["attr"] self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
gik = 0 self.assertEquals(attrs[(ns_uri, "attr")], "val")
except KeyError: self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
gik = 1
return attrs.getLength() == 0 and \ # During the development of Python 2.5, an attempt to move the "xml"
attrs.getNames() == [] and \ # package implementation to a new package ("xmlcore") proved painful.
attrs.getQNames() == [] and \ # The goal of this change was to allow applications to be able to
len(attrs) == 0 and \ # obtain and rely on behavior in the standard library implementation
not attrs.has_key("attr") and \ # of the XML support without needing to be concerned about the
attrs.keys() == [] and \ # availability of the PyXML implementation.
attrs.get("attrs") is None and \ #
attrs.get("attrs", 25) == 25 and \ # While the existing import hackery in Lib/xml/__init__.py can cause
attrs.items() == [] and \ # PyXML's _xmlpus package to supplant the "xml" package, that only
attrs.values() == [] and \ # works because either implementation uses the "xml" package name for
gvk and gvqk and gnqk and gik and gqnk # imports.
#
def verify_attrs_wattr(attrs): # The move resulted in a number of problems related to the fact that
return attrs.getLength() == 1 and \ # the import machinery's "package context" is based on the name that's
attrs.getNames() == ["attr"] and \ # being imported rather than the __name__ of the actual package
attrs.getQNames() == ["attr"] and \ # containment; it wasn't possible for the "xml" package to be replaced
len(attrs) == 1 and \ # by a simple module that indirected imports to the "xmlcore" package.
attrs.has_key("attr") and \ #
attrs.keys() == ["attr"] and \ # The following two tests exercised bugs that were introduced in that
attrs.get("attr") == "val" and \ # attempt. Keeping these tests around will help detect problems with
attrs.get("attr", 25) == "val" and \ # other attempts to provide reliable access to the standard library's
attrs.items() == [("attr", "val")] and \ # implementation of the XML support.
attrs.values() == ["val"] and \
attrs.getValue("attr") == "val" and \ def test_sf_1511497(self):
attrs.getValueByQName("attr") == "val" and \ # Bug report: http://www.python.org/sf/1511497
attrs.getNameByQName("attr") == "attr" and \ import sys
attrs["attr"] == "val" and \ old_modules = sys.modules.copy()
attrs.getQNameByName("attr") == "attr" for modname in sys.modules.keys():
if modname.startswith("xml."):
def test_attrs_empty(): del sys.modules[modname]
return verify_empty_attrs(AttributesImpl({})) try:
import xml.sax.expatreader
def test_attrs_wattr(): module = xml.sax.expatreader
return verify_attrs_wattr(AttributesImpl({"attr" : "val"})) self.assertEquals(module.__name__, "xml.sax.expatreader")
finally:
# ===== AttributesImpl sys.modules.update(old_modules)
def verify_empty_nsattrs(attrs): def test_sf_1513611(self):
try: # Bug report: http://www.python.org/sf/1513611
attrs.getValue((ns_uri, "attr")) sio = StringIO("invalid")
gvk = 0 parser = make_parser()
except KeyError: from xml.sax import SAXParseException
gvk = 1 self.assertRaises(SAXParseException, parser.parse, sio)
try:
attrs.getValueByQName("ns:attr") def unittest_main():
gvqk = 0 run_unittest(MakeParserTest,
except KeyError: SaxutilsTest,
gvqk = 1 XmlgenTest,
ExpatReaderTest,
try: ErrorReportingTest,
attrs.getNameByQName("ns:attr") XmlReaderTest)
gnqk = 0
except KeyError: if __name__ == "__main__":
gnqk = 1 unittest_main()
try:
attrs.getQNameByName((ns_uri, "attr"))
gqnk = 0
except KeyError:
gqnk = 1
try:
attrs[(ns_uri, "attr")]
gik = 0
except KeyError:
gik = 1
return attrs.getLength() == 0 and \
attrs.getNames() == [] and \
attrs.getQNames() == [] and \
len(attrs) == 0 and \
not attrs.has_key((ns_uri, "attr")) and \
attrs.keys() == [] and \
attrs.get((ns_uri, "attr")) is None and \
attrs.get((ns_uri, "attr"), 25) == 25 and \
attrs.items() == [] and \
attrs.values() == [] and \
gvk and gvqk and gnqk and gik and gqnk
def test_nsattrs_empty():
return verify_empty_nsattrs(AttributesNSImpl({}, {}))
def test_nsattrs_wattr():
attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
{(ns_uri, "attr") : "ns:attr"})
return attrs.getLength() == 1 and \
attrs.getNames() == [(ns_uri, "attr")] and \
attrs.getQNames() == ["ns:attr"] and \
len(attrs) == 1 and \
attrs.has_key((ns_uri, "attr")) and \
attrs.keys() == [(ns_uri, "attr")] and \
attrs.get((ns_uri, "attr")) == "val" and \
attrs.get((ns_uri, "attr"), 25) == "val" and \
attrs.items() == [((ns_uri, "attr"), "val")] and \
attrs.values() == ["val"] and \
attrs.getValue((ns_uri, "attr")) == "val" and \
attrs.getValueByQName("ns:attr") == "val" and \
attrs.getNameByQName("ns:attr") == (ns_uri, "attr") and \
attrs[(ns_uri, "attr")] == "val" and \
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():
# Bug report: http://www.python.org/sf/1511497
import sys
old_modules = sys.modules.copy()
for modname in sys.modules.keys():
if modname.startswith("xml."):
del sys.modules[modname]
try:
import xml.sax.expatreader
module = xml.sax.expatreader
return module.__name__ == "xml.sax.expatreader"
finally:
sys.modules.update(old_modules)
def test_sf_1513611():
# Bug report: http://www.python.org/sf/1513611
sio = StringIO("invalid")
parser = make_parser()
from xml.sax import SAXParseException
try:
parser.parse(sio)
except SAXParseException:
return True
else:
return False
# ===== Main program
def make_test_output():
parser = create_parser()
result = StringIO()
xmlgen = XMLGenerator(result)
parser.setContentHandler(xmlgen)
parser.parse(findfile("test"+os.extsep+"xml"))
outf = open(findfile("test"+os.extsep+"xml"+os.extsep+"out"), "w")
outf.write(result.getvalue())
outf.close()
items = locals().items()
items.sort()
for (name, value) in items:
if name[ : 5] == "test_":
confirm(value(), name)
# We delete the items variable so that the assignment to items above
# doesn't pick up the old value of items (which messes with attempts
# to find reference leaks).
del items
if verbose:
print "%d tests, %d failures" % (tests, len(failures))
if failures:
raise TestFailed("%d of %d tests failed: %s"
% (len(failures), tests, ", ".join(failures)))
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment