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.
This commit is contained in:
Collin Winter
parent
366d6262f8
commit
d28fcbc7fb
|
|
@ -1,110 +0,0 @@
|
|||
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
|
||||
|
|
@ -1,364 +0,0 @@
|
|||
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
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,108 +1,40 @@
|
|||
# Very simple test - Parse a file and print what happens
|
||||
|
||||
# XXX TypeErrors on calling handlers, or on bad return values from a
|
||||
# handler, are obscure and unhelpful.
|
||||
|
||||
import StringIO
|
||||
import unittest
|
||||
|
||||
import pyexpat
|
||||
from xml.parsers import expat
|
||||
|
||||
from test.test_support import sortdict, TestFailed
|
||||
|
||||
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
|
||||
from test.test_support import sortdict, run_unittest
|
||||
|
||||
|
||||
def confirm(ok):
|
||||
if ok:
|
||||
print "OK."
|
||||
else:
|
||||
print "Not OK."
|
||||
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)
|
||||
|
||||
out = Outputter()
|
||||
parser = expat.ParserCreate(namespace_separator='!')
|
||||
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)
|
||||
|
||||
# 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 = '''\
|
||||
<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
|
||||
|
|
@ -126,108 +58,228 @@ data = '''\
|
|||
</root>
|
||||
'''
|
||||
|
||||
|
||||
# Produce UTF-8 output
|
||||
parser.returns_unicode = 0
|
||||
try:
|
||||
parser.Parse(data, 1)
|
||||
except expat.error:
|
||||
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
|
||||
print '** Line', parser.ErrorLineNumber
|
||||
print '** Column', parser.ErrorColumnNumber
|
||||
print '** Byte', parser.ErrorByteIndex
|
||||
class ParseTest(unittest.TestCase):
|
||||
class Outputter:
|
||||
def __init__(self):
|
||||
self.out = []
|
||||
|
||||
def StartElementHandler(self, name, attrs):
|
||||
self.out.append('Start element: ' + repr(name) + ' ' +
|
||||
sortdict(attrs))
|
||||
|
||||
def EndElementHandler(self, name):
|
||||
self.out.append('End element: ' + repr(name))
|
||||
|
||||
def CharacterDataHandler(self, data):
|
||||
data = data.strip()
|
||||
if data:
|
||||
self.out.append('Character data: ' + repr(data))
|
||||
|
||||
def ProcessingInstructionHandler(self, target, data):
|
||||
self.out.append('PI: ' + repr(target) + ' ' + repr(data))
|
||||
|
||||
def StartNamespaceDeclHandler(self, prefix, uri):
|
||||
self.out.append('NS decl: ' + repr(prefix) + ' ' + repr(uri))
|
||||
|
||||
def EndNamespaceDeclHandler(self, prefix):
|
||||
self.out.append('End of NS decl: ' + repr(prefix))
|
||||
|
||||
def StartCdataSectionHandler(self):
|
||||
self.out.append('Start of CDATA section')
|
||||
|
||||
def EndCdataSectionHandler(self):
|
||||
self.out.append('End of CDATA section')
|
||||
|
||||
def CommentHandler(self, text):
|
||||
self.out.append('Comment: ' + repr(text))
|
||||
|
||||
def NotationDeclHandler(self, *args):
|
||||
name, base, sysid, pubid = args
|
||||
self.out.append('Notation declared: %s' %(args,))
|
||||
|
||||
def UnparsedEntityDeclHandler(self, *args):
|
||||
entityName, base, systemId, publicId, notationName = args
|
||||
self.out.append('Unparsed entity decl: %s' %(args,))
|
||||
|
||||
def NotStandaloneHandler(self, userData):
|
||||
self.out.append('Not standalone')
|
||||
return 1
|
||||
|
||||
def ExternalEntityRefHandler(self, *args):
|
||||
context, base, sysId, pubId = args
|
||||
self.out.append('External entity ref: %s' %(args[1:],))
|
||||
return 1
|
||||
|
||||
def DefaultHandler(self, userData):
|
||||
pass
|
||||
|
||||
def DefaultHandlerExpand(self, userData):
|
||||
pass
|
||||
|
||||
# Try the parse again, this time producing Unicode output
|
||||
parser = expat.ParserCreate(namespace_separator='!')
|
||||
parser.returns_unicode = 1
|
||||
handler_names = [
|
||||
'StartElementHandler', 'EndElementHandler',
|
||||
'CharacterDataHandler', 'ProcessingInstructionHandler',
|
||||
'UnparsedEntityDeclHandler', 'NotationDeclHandler',
|
||||
'StartNamespaceDeclHandler', 'EndNamespaceDeclHandler',
|
||||
'CommentHandler', 'StartCdataSectionHandler',
|
||||
'EndCdataSectionHandler',
|
||||
'DefaultHandler', 'DefaultHandlerExpand',
|
||||
#'NotStandaloneHandler',
|
||||
'ExternalEntityRefHandler'
|
||||
]
|
||||
|
||||
def test_utf8(self):
|
||||
|
||||
for name in HANDLER_NAMES:
|
||||
setattr(parser, name, getattr(out, name))
|
||||
try:
|
||||
parser.Parse(data, 1)
|
||||
except expat.error:
|
||||
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
|
||||
print '** Line', parser.ErrorLineNumber
|
||||
print '** Column', parser.ErrorColumnNumber
|
||||
print '** Byte', parser.ErrorByteIndex
|
||||
out = self.Outputter()
|
||||
parser = expat.ParserCreate(namespace_separator='!')
|
||||
for name in self.handler_names:
|
||||
setattr(parser, name, getattr(out, name))
|
||||
parser.returns_unicode = 0
|
||||
parser.Parse(data, 1)
|
||||
|
||||
# Verify output
|
||||
op = out.out
|
||||
self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
|
||||
self.assertEquals(op[1], "Comment: ' comment data '")
|
||||
self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
|
||||
self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
|
||||
self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}")
|
||||
self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
|
||||
self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
|
||||
self.assertEquals(op[7], "Character data: 'Contents of subelements'")
|
||||
self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'")
|
||||
self.assertEquals(op[9], "End of NS decl: 'myns'")
|
||||
self.assertEquals(op[10], "Start element: 'sub2' {}")
|
||||
self.assertEquals(op[11], 'Start of CDATA section')
|
||||
self.assertEquals(op[12], "Character data: 'contents of CDATA section'")
|
||||
self.assertEquals(op[13], 'End of CDATA section')
|
||||
self.assertEquals(op[14], "End element: 'sub2'")
|
||||
self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)")
|
||||
self.assertEquals(op[16], "End element: 'root'")
|
||||
|
||||
# Try parsing a file
|
||||
parser = expat.ParserCreate(namespace_separator='!')
|
||||
parser.returns_unicode = 1
|
||||
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)
|
||||
|
||||
for name in HANDLER_NAMES:
|
||||
setattr(parser, name, getattr(out, name))
|
||||
import StringIO
|
||||
file = StringIO.StringIO(data)
|
||||
try:
|
||||
parser.ParseFile(file)
|
||||
except expat.error:
|
||||
print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
|
||||
print '** Line', parser.ErrorLineNumber
|
||||
print '** Column', parser.ErrorColumnNumber
|
||||
print '** Byte', parser.ErrorByteIndex
|
||||
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'")
|
||||
|
||||
|
||||
# Tests that make sure we get errors when the namespace_separator value
|
||||
# is illegal, and that we don't for good values:
|
||||
print
|
||||
print "Testing constructor for proper handling of namespace_separator values:"
|
||||
expat.ParserCreate()
|
||||
expat.ParserCreate(namespace_separator=None)
|
||||
expat.ParserCreate(namespace_separator=' ')
|
||||
print "Legal values tested o.k."
|
||||
try:
|
||||
expat.ParserCreate(namespace_separator=42)
|
||||
except TypeError, e:
|
||||
print "Caught expected TypeError:"
|
||||
print e
|
||||
else:
|
||||
print "Failed to catch expected TypeError."
|
||||
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')
|
||||
|
||||
try:
|
||||
expat.ParserCreate(namespace_separator='too long')
|
||||
except ValueError, e:
|
||||
print "Caught expected ValueError:"
|
||||
print e
|
||||
else:
|
||||
print "Failed to catch expected ValueError."
|
||||
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
|
||||
|
||||
# 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
|
||||
|
||||
# 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]
|
||||
if len(L) != 6:
|
||||
print "L should only contain 6 entries; found", len(L)
|
||||
for entry in L:
|
||||
if tag is not entry:
|
||||
print "expected L to contain many references to the same string",
|
||||
print "(it didn't)"
|
||||
print "L =", repr(L)
|
||||
break
|
||||
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)
|
||||
|
||||
# Tests of the buffer_text attribute.
|
||||
import sys
|
||||
|
||||
class TextCollector:
|
||||
def __init__(self, parser):
|
||||
class BufferTextTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.stuff = []
|
||||
|
||||
self.parser = expat.ParserCreate()
|
||||
self.parser.buffer_text = 1
|
||||
self.parser.CharacterDataHandler = self.CharacterDataHandler
|
||||
|
||||
def check(self, expected, label):
|
||||
require(self.stuff == expected,
|
||||
self.assertEquals(self.stuff, expected,
|
||||
"%s\nstuff = %r\nexpected = %r"
|
||||
% (label, self.stuff, map(unicode, expected)))
|
||||
|
||||
|
|
@ -238,9 +290,9 @@ class TextCollector:
|
|||
self.stuff.append("<%s>" % name)
|
||||
bt = attrs.get("buffer-text")
|
||||
if bt == "yes":
|
||||
parser.buffer_text = 1
|
||||
self.parser.buffer_text = 1
|
||||
elif bt == "no":
|
||||
parser.buffer_text = 0
|
||||
self.parser.buffer_text = 0
|
||||
|
||||
def EndElementHandler(self, name):
|
||||
self.stuff.append("</%s>" % name)
|
||||
|
|
@ -248,95 +300,91 @@ class TextCollector:
|
|||
def CommentHandler(self, data):
|
||||
self.stuff.append("<!--%s-->" % data)
|
||||
|
||||
def require(cond, label):
|
||||
# similar to confirm(), but no extraneous output
|
||||
if not cond:
|
||||
raise TestFailed(label)
|
||||
def setHandlers(self, handlers=[]):
|
||||
for name in handlers:
|
||||
setattr(self.parser, name, getattr(self, name))
|
||||
|
||||
def setup(handlers=[]):
|
||||
parser = expat.ParserCreate()
|
||||
require(not parser.buffer_text,
|
||||
"buffer_text not disabled by default")
|
||||
parser.buffer_text = 1
|
||||
handler = TextCollector(parser)
|
||||
parser.CharacterDataHandler = handler.CharacterDataHandler
|
||||
for name in handlers:
|
||||
setattr(parser, name, getattr(handler, name))
|
||||
return parser, handler
|
||||
def test_default_to_disabled(self):
|
||||
parser = expat.ParserCreate()
|
||||
self.assertFalse(parser.buffer_text)
|
||||
|
||||
def test_buffering_enabled(self):
|
||||
# Make sure buffering is turned on
|
||||
self.assertTrue(self.parser.buffer_text)
|
||||
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
self.assertEquals(self.stuff, ['123'],
|
||||
"buffered text not properly collapsed")
|
||||
|
||||
parser, handler = setup()
|
||||
require(parser.buffer_text,
|
||||
"text buffering either not acknowledged or not enabled")
|
||||
parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
handler.check(["123"],
|
||||
"buffered text not properly collapsed")
|
||||
def test1(self):
|
||||
# XXX This test exposes more detail of Expat's text chunking than we
|
||||
# XXX like, but it tests what we need to concisely.
|
||||
self.setHandlers(["StartElementHandler"])
|
||||
self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
|
||||
self.assertEquals(self.stuff,
|
||||
["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
|
||||
"buffering control not reacting as expected")
|
||||
|
||||
def test2(self):
|
||||
self.parser.Parse("<a>1<b/><2><c/> \n 3</a>", 1)
|
||||
self.assertEquals(self.stuff, ["1<2> \n 3"],
|
||||
"buffered text not properly collapsed")
|
||||
|
||||
# XXX This test exposes more detail of Expat's text chunking than we
|
||||
# XXX like, but it tests what we need to concisely.
|
||||
parser, handler = setup(["StartElementHandler"])
|
||||
parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
|
||||
handler.check(["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
|
||||
"buffering control not reacting as expected")
|
||||
def test3(self):
|
||||
self.setHandlers(["StartElementHandler"])
|
||||
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
|
||||
"buffered text not properly split")
|
||||
|
||||
parser, handler = setup()
|
||||
parser.Parse("<a>1<b/><2><c/> \n 3</a>", 1)
|
||||
handler.check(["1<2> \n 3"],
|
||||
"buffered text not properly collapsed")
|
||||
def test4(self):
|
||||
self.setHandlers(["StartElementHandler", "EndElementHandler"])
|
||||
self.parser.CharacterDataHandler = None
|
||||
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
self.assertEquals(self.stuff,
|
||||
["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
|
||||
|
||||
parser, handler = setup(["StartElementHandler"])
|
||||
parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
handler.check(["<a>", "1", "<b>", "2", "<c>", "3"],
|
||||
"buffered text not properly split")
|
||||
def test5(self):
|
||||
self.setHandlers(["StartElementHandler", "EndElementHandler"])
|
||||
self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
|
||||
self.assertEquals(self.stuff,
|
||||
["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
|
||||
|
||||
parser, handler = setup(["StartElementHandler", "EndElementHandler"])
|
||||
parser.CharacterDataHandler = None
|
||||
parser.Parse("<a>1<b/>2<c/>3</a>", 1)
|
||||
handler.check(["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"],
|
||||
"huh?")
|
||||
def test6(self):
|
||||
self.setHandlers(["CommentHandler", "EndElementHandler",
|
||||
"StartElementHandler"])
|
||||
self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
|
||||
self.assertEquals(self.stuff,
|
||||
["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
|
||||
"buffered text not properly split")
|
||||
|
||||
parser, handler = setup(["StartElementHandler", "EndElementHandler"])
|
||||
parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
|
||||
handler.check(["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"],
|
||||
"huh?")
|
||||
def test7(self):
|
||||
self.setHandlers(["CommentHandler", "EndElementHandler",
|
||||
"StartElementHandler"])
|
||||
self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1)
|
||||
self.assertEquals(self.stuff,
|
||||
["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
|
||||
"<!--abc-->", "4", "<!--def-->", "5", "</a>"],
|
||||
"buffered text not properly split")
|
||||
|
||||
parser, handler = setup(["CommentHandler", "EndElementHandler",
|
||||
"StartElementHandler"])
|
||||
parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
|
||||
handler.check(["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
|
||||
"buffered text not properly split")
|
||||
|
||||
parser, handler = setup(["CommentHandler", "EndElementHandler",
|
||||
"StartElementHandler"])
|
||||
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",
|
||||
"<!--abc-->", "4", "<!--def-->", "5", "</a>"],
|
||||
"buffered text not properly split")
|
||||
|
||||
# Test handling of exception from callback:
|
||||
def StartElementHandler(name, attrs):
|
||||
raise RuntimeError(name)
|
||||
class HandlerExceptionTest(unittest.TestCase):
|
||||
def StartElementHandler(self, name, attrs):
|
||||
raise RuntimeError(name)
|
||||
|
||||
parser = expat.ParserCreate()
|
||||
parser.StartElementHandler = StartElementHandler
|
||||
def test(self):
|
||||
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:
|
||||
class PositionTest:
|
||||
|
||||
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
|
||||
|
||||
class PositionTest(unittest.TestCase):
|
||||
def StartElementHandler(self, name, attrs):
|
||||
self.check_pos('s')
|
||||
|
||||
|
|
@ -348,41 +396,54 @@ class PositionTest:
|
|||
self.parser.CurrentByteIndex,
|
||||
self.parser.CurrentLineNumber,
|
||||
self.parser.CurrentColumnNumber)
|
||||
require(self.upto < len(self.expected_list),
|
||||
'too many parser events')
|
||||
self.assertTrue(self.upto < len(self.expected_list),
|
||||
'too many parser events')
|
||||
expected = self.expected_list[self.upto]
|
||||
require(pos == expected,
|
||||
'expected position %s, got %s' % (expected, pos))
|
||||
self.assertEquals(pos, expected,
|
||||
'Expected position %s, got position %s' %(pos, expected))
|
||||
self.upto += 1
|
||||
|
||||
def test(self):
|
||||
self.parser = expat.ParserCreate()
|
||||
self.parser.StartElementHandler = self.StartElementHandler
|
||||
self.parser.EndElementHandler = self.EndElementHandler
|
||||
self.upto = 0
|
||||
self.expected_list = [('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2),
|
||||
('e', 15, 3, 6), ('e', 17, 4, 1), ('e', 22, 5, 0)]
|
||||
|
||||
parser = expat.ParserCreate()
|
||||
handler = PositionTest([('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2),
|
||||
('e', 15, 3, 6), ('e', 17, 4, 1), ('e', 22, 5, 0)],
|
||||
parser)
|
||||
parser.Parse('''<a>
|
||||
<b>
|
||||
<c/>
|
||||
</b>
|
||||
</a>''', 1)
|
||||
xml = '<a>\n <b>\n <c/>\n </b>\n</a>'
|
||||
self.parser.Parse(xml, 1)
|
||||
|
||||
|
||||
def test_parse_only_xml_data():
|
||||
# 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'?><s>%s</s>" % ('a' * 10000)
|
||||
class sf1296433Test(unittest.TestCase):
|
||||
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'?><s>%s</s>" % ('a' * 10000)
|
||||
|
||||
class SpecificException(Exception):
|
||||
pass
|
||||
|
||||
def handler(text):
|
||||
raise SpecificException
|
||||
|
||||
parser = expat.ParserCreate()
|
||||
parser.CharacterDataHandler = handler
|
||||
|
||||
self.assertRaises(Exception, parser.Parse, xml)
|
||||
|
||||
def handler(text):
|
||||
raise Exception
|
||||
|
||||
parser = expat.ParserCreate()
|
||||
parser.CharacterDataHandler = handler
|
||||
def test_main():
|
||||
run_unittest(SetAttributeTest,
|
||||
ParseTest,
|
||||
NamespaceSeparatorTest,
|
||||
InterningTest,
|
||||
BufferTextTest,
|
||||
HandlerExceptionTest,
|
||||
PositionTest,
|
||||
sf1296433Test)
|
||||
|
||||
try:
|
||||
parser.Parse(xml)
|
||||
except:
|
||||
pass
|
||||
|
||||
test_parse_only_xml_data()
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
|||
1216
Lib/test/test_sax.py
1216
Lib/test/test_sax.py
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue