/Lib/test/test_pyexpat.py

http://unladen-swallow.googlecode.com/ · Python · 594 lines · 453 code · 104 blank · 37 comment · 23 complexity · 822a9df423805846d1fb1411eec1c363 MD5 · raw file

  1. # XXX TypeErrors on calling handlers, or on bad return values from a
  2. # handler, are obscure and unhelpful.
  3. import StringIO, sys
  4. import unittest
  5. import pyexpat
  6. from xml.parsers import expat
  7. from test.test_support import sortdict, run_unittest
  8. class SetAttributeTest(unittest.TestCase):
  9. def setUp(self):
  10. self.parser = expat.ParserCreate(namespace_separator='!')
  11. self.set_get_pairs = [
  12. [0, 0],
  13. [1, 1],
  14. [2, 1],
  15. [0, 0],
  16. ]
  17. def test_returns_unicode(self):
  18. for x, y in self.set_get_pairs:
  19. self.parser.returns_unicode = x
  20. self.assertEquals(self.parser.returns_unicode, y)
  21. def test_ordered_attributes(self):
  22. for x, y in self.set_get_pairs:
  23. self.parser.ordered_attributes = x
  24. self.assertEquals(self.parser.ordered_attributes, y)
  25. def test_specified_attributes(self):
  26. for x, y in self.set_get_pairs:
  27. self.parser.specified_attributes = x
  28. self.assertEquals(self.parser.specified_attributes, y)
  29. data = '''\
  30. <?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
  31. <?xml-stylesheet href="stylesheet.css"?>
  32. <!-- comment data -->
  33. <!DOCTYPE quotations SYSTEM "quotations.dtd" [
  34. <!ELEMENT root ANY>
  35. <!NOTATION notation SYSTEM "notation.jpeg">
  36. <!ENTITY acirc "&#226;">
  37. <!ENTITY external_entity SYSTEM "entity.file">
  38. <!ENTITY unparsed_entity SYSTEM "entity.file" NDATA notation>
  39. %unparsed_entity;
  40. ]>
  41. <root attr1="value1" attr2="value2&#8000;">
  42. <myns:subelement xmlns:myns="http://www.python.org/namespace">
  43. Contents of subelements
  44. </myns:subelement>
  45. <sub2><![CDATA[contents of CDATA section]]></sub2>
  46. &external_entity;
  47. </root>
  48. '''
  49. # Produce UTF-8 output
  50. class ParseTest(unittest.TestCase):
  51. class Outputter:
  52. def __init__(self):
  53. self.out = []
  54. def StartElementHandler(self, name, attrs):
  55. self.out.append('Start element: ' + repr(name) + ' ' +
  56. sortdict(attrs))
  57. def EndElementHandler(self, name):
  58. self.out.append('End element: ' + repr(name))
  59. def CharacterDataHandler(self, data):
  60. data = data.strip()
  61. if data:
  62. self.out.append('Character data: ' + repr(data))
  63. def ProcessingInstructionHandler(self, target, data):
  64. self.out.append('PI: ' + repr(target) + ' ' + repr(data))
  65. def StartNamespaceDeclHandler(self, prefix, uri):
  66. self.out.append('NS decl: ' + repr(prefix) + ' ' + repr(uri))
  67. def EndNamespaceDeclHandler(self, prefix):
  68. self.out.append('End of NS decl: ' + repr(prefix))
  69. def StartCdataSectionHandler(self):
  70. self.out.append('Start of CDATA section')
  71. def EndCdataSectionHandler(self):
  72. self.out.append('End of CDATA section')
  73. def CommentHandler(self, text):
  74. self.out.append('Comment: ' + repr(text))
  75. def NotationDeclHandler(self, *args):
  76. name, base, sysid, pubid = args
  77. self.out.append('Notation declared: %s' %(args,))
  78. def UnparsedEntityDeclHandler(self, *args):
  79. entityName, base, systemId, publicId, notationName = args
  80. self.out.append('Unparsed entity decl: %s' %(args,))
  81. def NotStandaloneHandler(self, userData):
  82. self.out.append('Not standalone')
  83. return 1
  84. def ExternalEntityRefHandler(self, *args):
  85. context, base, sysId, pubId = args
  86. self.out.append('External entity ref: %s' %(args[1:],))
  87. return 1
  88. def DefaultHandler(self, userData):
  89. pass
  90. def DefaultHandlerExpand(self, userData):
  91. pass
  92. handler_names = [
  93. 'StartElementHandler', 'EndElementHandler',
  94. 'CharacterDataHandler', 'ProcessingInstructionHandler',
  95. 'UnparsedEntityDeclHandler', 'NotationDeclHandler',
  96. 'StartNamespaceDeclHandler', 'EndNamespaceDeclHandler',
  97. 'CommentHandler', 'StartCdataSectionHandler',
  98. 'EndCdataSectionHandler',
  99. 'DefaultHandler', 'DefaultHandlerExpand',
  100. #'NotStandaloneHandler',
  101. 'ExternalEntityRefHandler'
  102. ]
  103. def test_utf8(self):
  104. out = self.Outputter()
  105. parser = expat.ParserCreate(namespace_separator='!')
  106. for name in self.handler_names:
  107. setattr(parser, name, getattr(out, name))
  108. parser.returns_unicode = 0
  109. parser.Parse(data, 1)
  110. # Verify output
  111. op = out.out
  112. self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
  113. self.assertEquals(op[1], "Comment: ' comment data '")
  114. self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
  115. self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
  116. self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}")
  117. self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
  118. self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
  119. self.assertEquals(op[7], "Character data: 'Contents of subelements'")
  120. self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'")
  121. self.assertEquals(op[9], "End of NS decl: 'myns'")
  122. self.assertEquals(op[10], "Start element: 'sub2' {}")
  123. self.assertEquals(op[11], 'Start of CDATA section')
  124. self.assertEquals(op[12], "Character data: 'contents of CDATA section'")
  125. self.assertEquals(op[13], 'End of CDATA section')
  126. self.assertEquals(op[14], "End element: 'sub2'")
  127. self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)")
  128. self.assertEquals(op[16], "End element: 'root'")
  129. def test_unicode(self):
  130. # Try the parse again, this time producing Unicode output
  131. out = self.Outputter()
  132. parser = expat.ParserCreate(namespace_separator='!')
  133. parser.returns_unicode = 1
  134. for name in self.handler_names:
  135. setattr(parser, name, getattr(out, name))
  136. parser.Parse(data, 1)
  137. op = out.out
  138. self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
  139. self.assertEquals(op[1], "Comment: u' comment data '")
  140. self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
  141. self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
  142. self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
  143. self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
  144. self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
  145. self.assertEquals(op[7], "Character data: u'Contents of subelements'")
  146. self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
  147. self.assertEquals(op[9], "End of NS decl: u'myns'")
  148. self.assertEquals(op[10], "Start element: u'sub2' {}")
  149. self.assertEquals(op[11], 'Start of CDATA section')
  150. self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
  151. self.assertEquals(op[13], 'End of CDATA section')
  152. self.assertEquals(op[14], "End element: u'sub2'")
  153. self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
  154. self.assertEquals(op[16], "End element: u'root'")
  155. def test_parse_file(self):
  156. # Try parsing a file
  157. out = self.Outputter()
  158. parser = expat.ParserCreate(namespace_separator='!')
  159. parser.returns_unicode = 1
  160. for name in self.handler_names:
  161. setattr(parser, name, getattr(out, name))
  162. file = StringIO.StringIO(data)
  163. parser.ParseFile(file)
  164. op = out.out
  165. self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'')
  166. self.assertEquals(op[1], "Comment: u' comment data '")
  167. self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)")
  168. self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')")
  169. self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}")
  170. self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'")
  171. self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}")
  172. self.assertEquals(op[7], "Character data: u'Contents of subelements'")
  173. self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'")
  174. self.assertEquals(op[9], "End of NS decl: u'myns'")
  175. self.assertEquals(op[10], "Start element: u'sub2' {}")
  176. self.assertEquals(op[11], 'Start of CDATA section')
  177. self.assertEquals(op[12], "Character data: u'contents of CDATA section'")
  178. self.assertEquals(op[13], 'End of CDATA section')
  179. self.assertEquals(op[14], "End element: u'sub2'")
  180. self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)")
  181. self.assertEquals(op[16], "End element: u'root'")
  182. class NamespaceSeparatorTest(unittest.TestCase):
  183. def test_legal(self):
  184. # Tests that make sure we get errors when the namespace_separator value
  185. # is illegal, and that we don't for good values:
  186. expat.ParserCreate()
  187. expat.ParserCreate(namespace_separator=None)
  188. expat.ParserCreate(namespace_separator=' ')
  189. def test_illegal(self):
  190. try:
  191. expat.ParserCreate(namespace_separator=42)
  192. self.fail()
  193. except TypeError, e:
  194. self.assertEquals(str(e),
  195. 'ParserCreate() argument 2 must be string or None, not int')
  196. try:
  197. expat.ParserCreate(namespace_separator='too long')
  198. self.fail()
  199. except ValueError, e:
  200. self.assertEquals(str(e),
  201. 'namespace_separator must be at most one character, omitted, or None')
  202. def test_zero_length(self):
  203. # ParserCreate() needs to accept a namespace_separator of zero length
  204. # to satisfy the requirements of RDF applications that are required
  205. # to simply glue together the namespace URI and the localname. Though
  206. # considered a wart of the RDF specifications, it needs to be supported.
  207. #
  208. # See XML-SIG mailing list thread starting with
  209. # http://mail.python.org/pipermail/xml-sig/2001-April/005202.html
  210. #
  211. expat.ParserCreate(namespace_separator='') # too short
  212. class InterningTest(unittest.TestCase):
  213. def test(self):
  214. # Test the interning machinery.
  215. p = expat.ParserCreate()
  216. L = []
  217. def collector(name, *args):
  218. L.append(name)
  219. p.StartElementHandler = collector
  220. p.EndElementHandler = collector
  221. p.Parse("<e> <e/> <e></e> </e>", 1)
  222. tag = L[0]
  223. self.assertEquals(len(L), 6)
  224. for entry in L:
  225. # L should have the same string repeated over and over.
  226. self.assertTrue(tag is entry)
  227. class BufferTextTest(unittest.TestCase):
  228. def setUp(self):
  229. self.stuff = []
  230. self.parser = expat.ParserCreate()
  231. self.parser.buffer_text = 1
  232. self.parser.CharacterDataHandler = self.CharacterDataHandler
  233. def check(self, expected, label):
  234. self.assertEquals(self.stuff, expected,
  235. "%s\nstuff = %r\nexpected = %r"
  236. % (label, self.stuff, map(unicode, expected)))
  237. def CharacterDataHandler(self, text):
  238. self.stuff.append(text)
  239. def StartElementHandler(self, name, attrs):
  240. self.stuff.append("<%s>" % name)
  241. bt = attrs.get("buffer-text")
  242. if bt == "yes":
  243. self.parser.buffer_text = 1
  244. elif bt == "no":
  245. self.parser.buffer_text = 0
  246. def EndElementHandler(self, name):
  247. self.stuff.append("</%s>" % name)
  248. def CommentHandler(self, data):
  249. self.stuff.append("<!--%s-->" % data)
  250. def setHandlers(self, handlers=[]):
  251. for name in handlers:
  252. setattr(self.parser, name, getattr(self, name))
  253. def test_default_to_disabled(self):
  254. parser = expat.ParserCreate()
  255. self.assertFalse(parser.buffer_text)
  256. def test_buffering_enabled(self):
  257. # Make sure buffering is turned on
  258. self.assertTrue(self.parser.buffer_text)
  259. self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
  260. self.assertEquals(self.stuff, ['123'],
  261. "buffered text not properly collapsed")
  262. def test1(self):
  263. # XXX This test exposes more detail of Expat's text chunking than we
  264. # XXX like, but it tests what we need to concisely.
  265. self.setHandlers(["StartElementHandler"])
  266. self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
  267. self.assertEquals(self.stuff,
  268. ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
  269. "buffering control not reacting as expected")
  270. def test2(self):
  271. self.parser.Parse("<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", 1)
  272. self.assertEquals(self.stuff, ["1<2> \n 3"],
  273. "buffered text not properly collapsed")
  274. def test3(self):
  275. self.setHandlers(["StartElementHandler"])
  276. self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
  277. self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
  278. "buffered text not properly split")
  279. def test4(self):
  280. self.setHandlers(["StartElementHandler", "EndElementHandler"])
  281. self.parser.CharacterDataHandler = None
  282. self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
  283. self.assertEquals(self.stuff,
  284. ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
  285. def test5(self):
  286. self.setHandlers(["StartElementHandler", "EndElementHandler"])
  287. self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
  288. self.assertEquals(self.stuff,
  289. ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
  290. def test6(self):
  291. self.setHandlers(["CommentHandler", "EndElementHandler",
  292. "StartElementHandler"])
  293. self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
  294. self.assertEquals(self.stuff,
  295. ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
  296. "buffered text not properly split")
  297. def test7(self):
  298. self.setHandlers(["CommentHandler", "EndElementHandler",
  299. "StartElementHandler"])
  300. self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1)
  301. self.assertEquals(self.stuff,
  302. ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
  303. "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
  304. "buffered text not properly split")
  305. # Test handling of exception from callback:
  306. class HandlerExceptionTest(unittest.TestCase):
  307. def StartElementHandler(self, name, attrs):
  308. raise RuntimeError(name)
  309. def test(self):
  310. parser = expat.ParserCreate()
  311. parser.StartElementHandler = self.StartElementHandler
  312. try:
  313. parser.Parse("<a><b><c/></b></a>", 1)
  314. self.fail()
  315. except RuntimeError, e:
  316. self.assertEquals(e.args[0], 'a',
  317. "Expected RuntimeError for element 'a', but" + \
  318. " found %r" % e.args[0])
  319. # Test Current* members:
  320. class PositionTest(unittest.TestCase):
  321. def StartElementHandler(self, name, attrs):
  322. self.check_pos('s')
  323. def EndElementHandler(self, name):
  324. self.check_pos('e')
  325. def check_pos(self, event):
  326. pos = (event,
  327. self.parser.CurrentByteIndex,
  328. self.parser.CurrentLineNumber,
  329. self.parser.CurrentColumnNumber)
  330. self.assertTrue(self.upto < len(self.expected_list),
  331. 'too many parser events')
  332. expected = self.expected_list[self.upto]
  333. self.assertEquals(pos, expected,
  334. 'Expected position %s, got position %s' %(pos, expected))
  335. self.upto += 1
  336. def test(self):
  337. self.parser = expat.ParserCreate()
  338. self.parser.StartElementHandler = self.StartElementHandler
  339. self.parser.EndElementHandler = self.EndElementHandler
  340. self.upto = 0
  341. self.expected_list = [('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2),
  342. ('e', 15, 3, 6), ('e', 17, 4, 1), ('e', 22, 5, 0)]
  343. xml = '<a>\n <b>\n <c/>\n </b>\n</a>'
  344. self.parser.Parse(xml, 1)
  345. class sf1296433Test(unittest.TestCase):
  346. def test_parse_only_xml_data(self):
  347. # http://python.org/sf/1296433
  348. #
  349. xml = "<?xml version='1.0' encoding='iso8859'?><s>%s</s>" % ('a' * 1025)
  350. # this one doesn't crash
  351. #xml = "<?xml version='1.0'?><s>%s</s>" % ('a' * 10000)
  352. class SpecificException(Exception):
  353. pass
  354. def handler(text):
  355. raise SpecificException
  356. parser = expat.ParserCreate()
  357. parser.CharacterDataHandler = handler
  358. self.assertRaises(Exception, parser.Parse, xml)
  359. class ChardataBufferTest(unittest.TestCase):
  360. """
  361. test setting of chardata buffer size
  362. """
  363. def test_1025_bytes(self):
  364. self.assertEquals(self.small_buffer_test(1025), 2)
  365. def test_1000_bytes(self):
  366. self.assertEquals(self.small_buffer_test(1000), 1)
  367. def test_wrong_size(self):
  368. parser = expat.ParserCreate()
  369. parser.buffer_text = 1
  370. def f(size):
  371. parser.buffer_size = size
  372. self.assertRaises(TypeError, f, sys.maxint+1)
  373. self.assertRaises(ValueError, f, -1)
  374. self.assertRaises(ValueError, f, 0)
  375. def test_unchanged_size(self):
  376. xml1 = ("<?xml version='1.0' encoding='iso8859'?><s>%s" % ('a' * 512))
  377. xml2 = 'a'*512 + '</s>'
  378. parser = expat.ParserCreate()
  379. parser.CharacterDataHandler = self.counting_handler
  380. parser.buffer_size = 512
  381. parser.buffer_text = 1
  382. # Feed 512 bytes of character data: the handler should be called
  383. # once.
  384. self.n = 0
  385. parser.Parse(xml1)
  386. self.assertEquals(self.n, 1)
  387. # Reassign to buffer_size, but assign the same size.
  388. parser.buffer_size = parser.buffer_size
  389. self.assertEquals(self.n, 1)
  390. # Try parsing rest of the document
  391. parser.Parse(xml2)
  392. self.assertEquals(self.n, 2)
  393. def test_disabling_buffer(self):
  394. xml1 = "<?xml version='1.0' encoding='iso8859'?><a>%s" % ('a' * 512)
  395. xml2 = ('b' * 1024)
  396. xml3 = "%s</a>" % ('c' * 1024)
  397. parser = expat.ParserCreate()
  398. parser.CharacterDataHandler = self.counting_handler
  399. parser.buffer_text = 1
  400. parser.buffer_size = 1024
  401. self.assertEquals(parser.buffer_size, 1024)
  402. # Parse one chunk of XML
  403. self.n = 0
  404. parser.Parse(xml1, 0)
  405. self.assertEquals(parser.buffer_size, 1024)
  406. self.assertEquals(self.n, 1)
  407. # Turn off buffering and parse the next chunk.
  408. parser.buffer_text = 0
  409. self.assertFalse(parser.buffer_text)
  410. self.assertEquals(parser.buffer_size, 1024)
  411. for i in range(10):
  412. parser.Parse(xml2, 0)
  413. self.assertEquals(self.n, 11)
  414. parser.buffer_text = 1
  415. self.assertTrue(parser.buffer_text)
  416. self.assertEquals(parser.buffer_size, 1024)
  417. parser.Parse(xml3, 1)
  418. self.assertEquals(self.n, 12)
  419. def make_document(self, bytes):
  420. return ("<?xml version='1.0'?><tag>" + bytes * 'a' + '</tag>')
  421. def counting_handler(self, text):
  422. self.n += 1
  423. def small_buffer_test(self, buffer_len):
  424. xml = "<?xml version='1.0' encoding='iso8859'?><s>%s</s>" % ('a' * buffer_len)
  425. parser = expat.ParserCreate()
  426. parser.CharacterDataHandler = self.counting_handler
  427. parser.buffer_size = 1024
  428. parser.buffer_text = 1
  429. self.n = 0
  430. parser.Parse(xml)
  431. return self.n
  432. def test_change_size_1(self):
  433. xml1 = "<?xml version='1.0' encoding='iso8859'?><a><s>%s" % ('a' * 1024)
  434. xml2 = "aaa</s><s>%s</s></a>" % ('a' * 1025)
  435. parser = expat.ParserCreate()
  436. parser.CharacterDataHandler = self.counting_handler
  437. parser.buffer_text = 1
  438. parser.buffer_size = 1024
  439. self.assertEquals(parser.buffer_size, 1024)
  440. self.n = 0
  441. parser.Parse(xml1, 0)
  442. parser.buffer_size *= 2
  443. self.assertEquals(parser.buffer_size, 2048)
  444. parser.Parse(xml2, 1)
  445. self.assertEquals(self.n, 2)
  446. def test_change_size_2(self):
  447. xml1 = "<?xml version='1.0' encoding='iso8859'?><a>a<s>%s" % ('a' * 1023)
  448. xml2 = "aaa</s><s>%s</s></a>" % ('a' * 1025)
  449. parser = expat.ParserCreate()
  450. parser.CharacterDataHandler = self.counting_handler
  451. parser.buffer_text = 1
  452. parser.buffer_size = 2048
  453. self.assertEquals(parser.buffer_size, 2048)
  454. self.n=0
  455. parser.Parse(xml1, 0)
  456. parser.buffer_size /= 2
  457. self.assertEquals(parser.buffer_size, 1024)
  458. parser.Parse(xml2, 1)
  459. self.assertEquals(self.n, 4)
  460. class MalformedInputText(unittest.TestCase):
  461. def test1(self):
  462. xml = "\0\r\n"
  463. parser = expat.ParserCreate()
  464. try:
  465. parser.Parse(xml, True)
  466. self.fail()
  467. except expat.ExpatError as e:
  468. self.assertEquals(str(e), 'no element found: line 2, column 1')
  469. def test2(self):
  470. xml = "<?xml version\xc2\x85='1.0'?>\r\n"
  471. parser = expat.ParserCreate()
  472. try:
  473. parser.Parse(xml, True)
  474. self.fail()
  475. except expat.ExpatError as e:
  476. self.assertEquals(str(e), 'XML declaration not well-formed: line 1, column 14')
  477. def test_main():
  478. run_unittest(SetAttributeTest,
  479. ParseTest,
  480. NamespaceSeparatorTest,
  481. InterningTest,
  482. BufferTextTest,
  483. HandlerExceptionTest,
  484. PositionTest,
  485. sf1296433Test,
  486. ChardataBufferTest,
  487. MalformedInputText)
  488. if __name__ == "__main__":
  489. test_main()