selftest.py 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264
  1. # $Id: selftest.py 3276 2007-09-12 06:52:30Z fredrik $
  2. # -*- coding: iso-8859-1 -*-
  3. # elementtree selftest program
  4. # this test script uses Python's "doctest" module to check that the
  5. # *test script* works as expected.
  6. # TODO: add more elementtree method tests
  7. # TODO: add xml/html parsing tests
  8. # TODO: etc
  9. import re, sys
  10. def stdout():
  11. if sys.version_info[0] < 3:
  12. return sys.stdout
  13. class bytes_stdout(object):
  14. def write(self, data):
  15. if isinstance(data, bytes):
  16. data = data.decode('ISO8859-1')
  17. sys.stdout.write(data)
  18. return bytes_stdout()
  19. try:
  20. from StringIO import StringIO as BytesIO
  21. except ImportError:
  22. from io import BytesIO
  23. from lxml import etree as ElementTree
  24. from lxml import _elementpath as ElementPath
  25. from lxml import ElementInclude
  26. ET = ElementTree
  27. #from elementtree import ElementTree
  28. #from elementtree import ElementPath
  29. #from elementtree import ElementInclude
  30. #from elementtree import HTMLTreeBuilder
  31. #from elementtree import SimpleXMLWriter
  32. def fix_compatibility(xml_data):
  33. xml_data = re.sub('\s*xmlns:[a-z0-9]+="http://www.w3.org/2001/XInclude"', '', xml_data)
  34. xml_data = xml_data.replace(' />', '/>')
  35. if xml_data[-1:] == '\n':
  36. xml_data = xml_data[:-1]
  37. return xml_data
  38. def serialize(elem, **options):
  39. file = BytesIO()
  40. tree = ElementTree.ElementTree(elem)
  41. tree.write(file, **options)
  42. if sys.version_info[0] < 3:
  43. try:
  44. encoding = options["encoding"]
  45. except KeyError:
  46. encoding = "utf-8"
  47. else:
  48. encoding = 'ISO8859-1'
  49. result = fix_compatibility(file.getvalue().decode(encoding))
  50. if sys.version_info[0] < 3:
  51. result = result.encode(encoding)
  52. return result
  53. def summarize(elem):
  54. return elem.tag
  55. def summarize_list(seq):
  56. return list(map(summarize, seq))
  57. def normalize_crlf(tree):
  58. for elem in tree.getiterator():
  59. if elem.text: elem.text = elem.text.replace("\r\n", "\n")
  60. if elem.tail: elem.tail = elem.tail.replace("\r\n", "\n")
  61. SAMPLE_XML = ElementTree.XML("""
  62. <body>
  63. <tag class='a'>text</tag>
  64. <tag class='b' />
  65. <section>
  66. <tag class='b' id='inner'>subtext</tag>
  67. </section>
  68. </body>
  69. """)
  70. #
  71. # interface tests
  72. def check_string(string):
  73. len(string)
  74. for char in string:
  75. if len(char) != 1:
  76. print("expected one-character string, got %r" % char)
  77. new_string = string + ""
  78. new_string = string + " "
  79. string[:0]
  80. def check_string_or_none(value):
  81. if value is None:
  82. return
  83. return check_string(value)
  84. def check_mapping(mapping):
  85. len(mapping)
  86. keys = mapping.keys()
  87. items = mapping.items()
  88. for key in keys:
  89. item = mapping[key]
  90. mapping["key"] = "value"
  91. if mapping["key"] != "value":
  92. print("expected value string, got %r" % mapping["key"])
  93. def check_element(element):
  94. if not hasattr(element, "tag"):
  95. print("no tag member")
  96. if not hasattr(element, "attrib"):
  97. print("no attrib member")
  98. if not hasattr(element, "text"):
  99. print("no text member")
  100. if not hasattr(element, "tail"):
  101. print("no tail member")
  102. check_string(element.tag)
  103. check_mapping(element.attrib)
  104. check_string_or_none(element.text)
  105. check_string_or_none(element.tail)
  106. for elem in element:
  107. check_element(elem)
  108. def check_element_tree(tree):
  109. check_element(tree.getroot())
  110. # --------------------------------------------------------------------
  111. # element tree tests
  112. def sanity():
  113. """
  114. >>> from elementtree.ElementTree import *
  115. >>> from elementtree.ElementInclude import *
  116. >>> from elementtree.ElementPath import *
  117. >>> from elementtree.HTMLTreeBuilder import *
  118. >>> from elementtree.SimpleXMLWriter import *
  119. >>> from elementtree.TidyTools import *
  120. """
  121. # doesn't work with lxml.etree
  122. del sanity
  123. def version():
  124. """
  125. >>> ElementTree.VERSION
  126. '1.3a2'
  127. """
  128. # doesn't work with lxml.etree
  129. del version
  130. def interface():
  131. """
  132. Test element tree interface.
  133. >>> element = ElementTree.Element("tag")
  134. >>> check_element(element)
  135. >>> tree = ElementTree.ElementTree(element)
  136. >>> check_element_tree(tree)
  137. """
  138. def simpleops():
  139. """
  140. >>> elem = ElementTree.XML("<body><tag/></body>")
  141. >>> serialize(elem)
  142. '<body><tag/></body>'
  143. >>> e = ElementTree.Element("tag2")
  144. >>> elem.append(e)
  145. >>> serialize(elem)
  146. '<body><tag/><tag2/></body>'
  147. >>> elem.remove(e)
  148. >>> serialize(elem)
  149. '<body><tag/></body>'
  150. >>> elem.insert(0, e)
  151. >>> serialize(elem)
  152. '<body><tag2/><tag/></body>'
  153. >>> elem.remove(e)
  154. >>> elem.extend([e])
  155. >>> serialize(elem)
  156. '<body><tag/><tag2/></body>'
  157. >>> elem.remove(e)
  158. """
  159. def simplefind():
  160. """
  161. Test find methods using the elementpath fallback.
  162. >>> CurrentElementPath = ElementTree.ElementPath
  163. >>> ElementTree.ElementPath = ElementTree._SimpleElementPath()
  164. >>> elem = SAMPLE_XML
  165. >>> elem.find("tag").tag
  166. 'tag'
  167. >>> ElementTree.ElementTree(elem).find("tag").tag
  168. 'tag'
  169. >>> elem.findtext("tag")
  170. 'text'
  171. >>> elem.findtext("tog")
  172. >>> elem.findtext("tog", "default")
  173. 'default'
  174. >>> ElementTree.ElementTree(elem).findtext("tag")
  175. 'text'
  176. >>> summarize_list(elem.findall("tag"))
  177. ['tag', 'tag']
  178. >>> summarize_list(elem.findall(".//tag"))
  179. ['tag', 'tag', 'tag']
  180. Path syntax doesn't work in this case.
  181. >>> elem.find("section/tag")
  182. >>> elem.findtext("section/tag")
  183. >>> elem.findall("section/tag")
  184. []
  185. >>> ElementTree.ElementPath = CurrentElementPath
  186. """
  187. # doesn't work with lxml.etree
  188. del simplefind
  189. def find():
  190. """
  191. Test find methods (including xpath syntax).
  192. >>> elem = SAMPLE_XML
  193. >>> elem.find("tag").tag
  194. 'tag'
  195. >>> ElementTree.ElementTree(elem).find("tag").tag
  196. 'tag'
  197. >>> elem.find("section/tag").tag
  198. 'tag'
  199. >>> ElementTree.ElementTree(elem).find("section/tag").tag
  200. 'tag'
  201. >>> elem.findtext("tag")
  202. 'text'
  203. >>> elem.findtext("tog")
  204. >>> elem.findtext("tog", "default")
  205. 'default'
  206. >>> ElementTree.ElementTree(elem).findtext("tag")
  207. 'text'
  208. >>> elem.findtext("section/tag")
  209. 'subtext'
  210. >>> ElementTree.ElementTree(elem).findtext("section/tag")
  211. 'subtext'
  212. >>> summarize_list(elem.findall("tag"))
  213. ['tag', 'tag']
  214. >>> summarize_list(elem.findall("*"))
  215. ['tag', 'tag', 'section']
  216. >>> summarize_list(elem.findall(".//tag"))
  217. ['tag', 'tag', 'tag']
  218. >>> summarize_list(elem.findall("section/tag"))
  219. ['tag']
  220. >>> summarize_list(elem.findall("section//tag"))
  221. ['tag']
  222. >>> summarize_list(elem.findall("section/*"))
  223. ['tag']
  224. >>> summarize_list(elem.findall("section//*"))
  225. ['tag']
  226. >>> summarize_list(elem.findall("section/.//*"))
  227. ['tag']
  228. >>> summarize_list(elem.findall("*/*"))
  229. ['tag']
  230. >>> summarize_list(elem.findall("*//*"))
  231. ['tag']
  232. >>> summarize_list(elem.findall("*/tag"))
  233. ['tag']
  234. >>> summarize_list(elem.findall("*/./tag"))
  235. ['tag']
  236. >>> summarize_list(elem.findall("./tag"))
  237. ['tag', 'tag']
  238. >>> summarize_list(elem.findall(".//tag"))
  239. ['tag', 'tag', 'tag']
  240. >>> summarize_list(elem.findall("././tag"))
  241. ['tag', 'tag']
  242. >>> summarize_list(elem.findall(".//tag[@class]"))
  243. ['tag', 'tag', 'tag']
  244. >>> summarize_list(elem.findall(".//tag[@class='a']"))
  245. ['tag']
  246. >>> summarize_list(elem.findall(".//tag[@class='b']"))
  247. ['tag', 'tag']
  248. >>> summarize_list(elem.findall(".//tag[@id]"))
  249. ['tag']
  250. >>> summarize_list(elem.findall(".//section[tag]"))
  251. ['section']
  252. >>> summarize_list(elem.findall(".//section[element]"))
  253. []
  254. >>> summarize_list(elem.findall("../tag"))
  255. []
  256. >>> summarize_list(elem.findall("section/../tag"))
  257. ['tag', 'tag']
  258. >>> summarize_list(ElementTree.ElementTree(elem).findall("./tag"))
  259. ['tag', 'tag']
  260. FIXME: ET's Path module handles this case incorrectly; this gives
  261. a warning in 1.3, and the behaviour will be modified in 1.4.
  262. >>> summarize_list(ElementTree.ElementTree(elem).findall("/tag"))
  263. ['tag', 'tag']
  264. """
  265. def bad_find():
  266. """
  267. Check bad or unsupported path expressions.
  268. >>> elem = SAMPLE_XML
  269. >>> elem.findall("/tag")
  270. Traceback (most recent call last):
  271. SyntaxError: cannot use absolute path on element
  272. # this is supported in ET 1.3:
  273. #>>> elem.findall("section//")
  274. #Traceback (most recent call last):
  275. #SyntaxError: invalid path
  276. """
  277. def parsefile():
  278. """
  279. Test parsing from file.
  280. >>> tree = ElementTree.parse("samples/simple.xml")
  281. >>> normalize_crlf(tree)
  282. >>> tree.write(stdout())
  283. <root>
  284. <element key="value">text</element>
  285. <element>text</element>tail
  286. <empty-element/>
  287. </root>
  288. >>> tree = ElementTree.parse("samples/simple-ns.xml")
  289. >>> normalize_crlf(tree)
  290. >>> tree.write(stdout())
  291. <root xmlns="http://namespace/">
  292. <element key="value">text</element>
  293. <element>text</element>tail
  294. <empty-element/>
  295. </root>
  296. ## <ns0:root xmlns:ns0="http://namespace/">
  297. ## <ns0:element key="value">text</ns0:element>
  298. ## <ns0:element>text</ns0:element>tail
  299. ## <ns0:empty-element/>
  300. ## </ns0:root>
  301. """
  302. def parsehtml():
  303. """
  304. Test HTML parsing.
  305. >>> # p = HTMLTreeBuilder.TreeBuilder()
  306. >>> p = ElementTree.HTMLParser()
  307. >>> p.feed("<p><p>spam<b>egg</b></p>")
  308. >>> serialize(p.close())
  309. '<p>spam<b>egg</b></p>'
  310. """
  311. # doesn't work with lxml.etree
  312. del parsehtml
  313. def parseliteral():
  314. r"""
  315. >>> element = ElementTree.XML("<html><body>text</body></html>")
  316. >>> ElementTree.ElementTree(element).write(stdout())
  317. <html><body>text</body></html>
  318. >>> element = ElementTree.fromstring("<html><body>text</body></html>")
  319. >>> ElementTree.ElementTree(element).write(stdout())
  320. <html><body>text</body></html>
  321. ## >>> sequence = ["<html><body>", "text</bo", "dy></html>"]
  322. ## >>> element = ElementTree.fromstringlist(sequence)
  323. ## >>> ElementTree.ElementTree(element).write(stdout())
  324. ## <html><body>text</body></html>
  325. >>> print(repr(ElementTree.tostring(element)).lstrip('b'))
  326. '<html><body>text</body></html>'
  327. # looks different in lxml
  328. # >>> print(ElementTree.tostring(element, "ascii"))
  329. # <?xml version='1.0' encoding='ascii'?>
  330. # <html><body>text</body></html>
  331. >>> _, ids = ElementTree.XMLID("<html><body>text</body></html>")
  332. >>> len(ids)
  333. 0
  334. >>> _, ids = ElementTree.XMLID("<html><body id='body'>text</body></html>")
  335. >>> len(ids)
  336. 1
  337. >>> ids["body"].tag
  338. 'body'
  339. """
  340. def simpleparsefile():
  341. """
  342. Test the xmllib-based parser.
  343. >>> from elementtree import SimpleXMLTreeBuilder
  344. >>> parser = SimpleXMLTreeBuilder.TreeBuilder()
  345. >>> tree = ElementTree.parse("samples/simple.xml", parser)
  346. >>> normalize_crlf(tree)
  347. >>> tree.write(sys.stdout)
  348. <root>
  349. <element key="value">text</element>
  350. <element>text</element>tail
  351. <empty-element />
  352. </root>
  353. """
  354. # doesn't work with lxml.etree
  355. del simpleparsefile
  356. def iterparse():
  357. """
  358. Test iterparse interface.
  359. >>> iterparse = ElementTree.iterparse
  360. >>> context = iterparse("samples/simple.xml")
  361. >>> for action, elem in context:
  362. ... print("%s %s" % (action, elem.tag))
  363. end element
  364. end element
  365. end empty-element
  366. end root
  367. >>> context.root.tag
  368. 'root'
  369. >>> context = iterparse("samples/simple-ns.xml")
  370. >>> for action, elem in context:
  371. ... print("%s %s" % (action, elem.tag))
  372. end {http://namespace/}element
  373. end {http://namespace/}element
  374. end {http://namespace/}empty-element
  375. end {http://namespace/}root
  376. >>> events = ()
  377. >>> context = iterparse("samples/simple.xml", events)
  378. >>> for action, elem in context:
  379. ... print("%s %s" % (action, elem.tag))
  380. >>> events = ()
  381. >>> context = iterparse("samples/simple.xml", events=events)
  382. >>> for action, elem in context:
  383. ... print("%s %s" % (action, elem.tag))
  384. >>> events = ("start", "end")
  385. >>> context = iterparse("samples/simple.xml", events)
  386. >>> for action, elem in context:
  387. ... print("%s %s" % (action, elem.tag))
  388. start root
  389. start element
  390. end element
  391. start element
  392. end element
  393. start empty-element
  394. end empty-element
  395. end root
  396. >>> events = ("start", "end", "start-ns", "end-ns")
  397. >>> context = iterparse("samples/simple-ns.xml", events)
  398. >>> for action, elem in context:
  399. ... if action in ("start", "end"):
  400. ... print("%s %s" % (action, elem.tag))
  401. ... else:
  402. ... print("%s %s" % (action, elem))
  403. start-ns ('', 'http://namespace/')
  404. start {http://namespace/}root
  405. start {http://namespace/}element
  406. end {http://namespace/}element
  407. start {http://namespace/}element
  408. end {http://namespace/}element
  409. start {http://namespace/}empty-element
  410. end {http://namespace/}empty-element
  411. end {http://namespace/}root
  412. end-ns None
  413. """
  414. def fancyparsefile():
  415. """
  416. Test the "fancy" parser.
  417. Sanity check.
  418. >>> from elementtree import XMLTreeBuilder
  419. >>> parser = XMLTreeBuilder.FancyTreeBuilder()
  420. >>> tree = ElementTree.parse("samples/simple.xml", parser)
  421. >>> normalize_crlf(tree)
  422. >>> tree.write(sys.stdout)
  423. <root>
  424. <element key="value">text</element>
  425. <element>text</element>tail
  426. <empty-element />
  427. </root>
  428. Callback check.
  429. >>> class MyFancyParser(XMLTreeBuilder.FancyTreeBuilder):
  430. ... def start(self, elem):
  431. ... print("START %s" % elem.tag)
  432. ... def end(self, elem):
  433. ... print("END %s" % elem.tag)
  434. >>> parser = MyFancyParser()
  435. >>> tree = ElementTree.parse("samples/simple.xml", parser)
  436. START root
  437. START element
  438. END element
  439. START element
  440. END element
  441. START empty-element
  442. END empty-element
  443. END root
  444. """
  445. # doesn't work with lxml.etree
  446. del fancyparsefile
  447. def writefile():
  448. """
  449. >>> elem = ElementTree.Element("tag")
  450. >>> elem.text = "text"
  451. >>> serialize(elem)
  452. '<tag>text</tag>'
  453. >>> ElementTree.SubElement(elem, "subtag").text = "subtext"
  454. >>> serialize(elem)
  455. '<tag>text<subtag>subtext</subtag></tag>'
  456. ## Test tag suppression
  457. ## >>> elem.tag = None
  458. ## >>> serialize(elem)
  459. ## 'text<subtag>subtext</subtag>'
  460. """
  461. def writestring():
  462. """
  463. >>> elem = ElementTree.XML("<html><body>text</body></html>")
  464. >>> print(repr(ElementTree.tostring(elem)).lstrip('b'))
  465. '<html><body>text</body></html>'
  466. >>> elem = ElementTree.fromstring("<html><body>text</body></html>")
  467. >>> print(repr(ElementTree.tostring(elem)).lstrip('b'))
  468. '<html><body>text</body></html>'
  469. """
  470. def encoding():
  471. r"""
  472. Test encoding issues.
  473. >>> elem = ElementTree.Element("tag")
  474. >>> elem.text = u'abc'
  475. >>> serialize(elem)
  476. '<tag>abc</tag>'
  477. >>> serialize(elem, encoding="utf-8")
  478. '<tag>abc</tag>'
  479. >>> serialize(elem, encoding="us-ascii")
  480. '<tag>abc</tag>'
  481. >>> serialize(elem, encoding="iso-8859-1").lower()
  482. "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>"
  483. >>> elem.text = "<&\"\'>"
  484. >>> serialize(elem)
  485. '<tag>&lt;&amp;"\'&gt;</tag>'
  486. >>> serialize(elem, encoding="utf-8")
  487. '<tag>&lt;&amp;"\'&gt;</tag>'
  488. >>> serialize(elem, encoding="us-ascii") # cdata characters
  489. '<tag>&lt;&amp;"\'&gt;</tag>'
  490. >>> serialize(elem, encoding="iso-8859-1").lower()
  491. '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag>&lt;&amp;"\'&gt;</tag>'
  492. >>> elem.attrib["key"] = "<&\"\'>"
  493. >>> elem.text = None
  494. >>> serialize(elem)
  495. '<tag key="&lt;&amp;&quot;\'&gt;"/>'
  496. >>> serialize(elem, encoding="utf-8")
  497. '<tag key="&lt;&amp;&quot;\'&gt;"/>'
  498. >>> serialize(elem, encoding="us-ascii")
  499. '<tag key="&lt;&amp;&quot;\'&gt;"/>'
  500. >>> serialize(elem, encoding="iso-8859-1").lower()
  501. '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="&lt;&amp;&quot;\'&gt;"/>'
  502. >>> elem.text = u'\xe5\xf6\xf6<>'
  503. >>> elem.attrib.clear()
  504. >>> serialize(elem)
  505. '<tag>&#229;&#246;&#246;&lt;&gt;</tag>'
  506. >>> serialize(elem, encoding="utf-8")
  507. '<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>'
  508. >>> serialize(elem, encoding="us-ascii")
  509. '<tag>&#229;&#246;&#246;&lt;&gt;</tag>'
  510. >>> serialize(elem, encoding="iso-8859-1").lower()
  511. "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6&lt;&gt;</tag>"
  512. >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>'
  513. >>> elem.text = None
  514. >>> serialize(elem)
  515. '<tag key="&#229;&#246;&#246;&lt;&gt;"/>'
  516. >>> serialize(elem, encoding="utf-8")
  517. '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;"/>'
  518. >>> serialize(elem, encoding="us-ascii")
  519. '<tag key="&#229;&#246;&#246;&lt;&gt;"/>'
  520. >>> serialize(elem, encoding="iso-8859-1").lower()
  521. '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6&lt;&gt;"/>'
  522. """
  523. if sys.version_info[0] >= 3:
  524. encoding.__doc__ = encoding.__doc__.replace("u'", "'")
  525. def methods():
  526. r"""
  527. Test serialization methods.
  528. >>> e = ET.XML("<html><link/><script>1 &lt; 2</script></html>")
  529. >>> e.tail = "\n"
  530. >>> serialize(e)
  531. '<html><link /><script>1 &lt; 2</script></html>\n'
  532. >>> serialize(e, method=None)
  533. '<html><link /><script>1 &lt; 2</script></html>\n'
  534. >>> serialize(e, method="xml")
  535. '<html><link /><script>1 &lt; 2</script></html>\n'
  536. >>> serialize(e, method="html")
  537. '<html><link><script>1 < 2</script></html>\n'
  538. >>> serialize(e, method="text")
  539. '1 < 2\n'
  540. """
  541. # doesn't work with lxml.etree
  542. del methods
  543. def iterators():
  544. """
  545. Test iterators.
  546. >>> e = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")
  547. >>> summarize_list(e.iter())
  548. ['html', 'body', 'i']
  549. >>> summarize_list(e.find("body").iter())
  550. ['body', 'i']
  551. >>> "".join(e.itertext())
  552. 'this is a paragraph...'
  553. >>> "".join(e.find("body").itertext())
  554. 'this is a paragraph.'
  555. """
  556. ENTITY_XML = """\
  557. <!DOCTYPE points [
  558. <!ENTITY % user-entities SYSTEM 'user-entities.xml'>
  559. %user-entities;
  560. ]>
  561. <document>&entity;</document>
  562. """
  563. def entity():
  564. """
  565. Test entity handling.
  566. 1) bad entities
  567. >>> ElementTree.XML("<document>&entity;</document>")
  568. Traceback (most recent call last):
  569. ExpatError: undefined entity: line 1, column 10
  570. >>> ElementTree.XML(ENTITY_XML)
  571. Traceback (most recent call last):
  572. ExpatError: undefined entity &entity;: line 5, column 10
  573. (add more tests here)
  574. """
  575. # doesn't work with lxml.etree
  576. del entity
  577. def error(xml):
  578. """
  579. Test error handling.
  580. >>> error("foo").position
  581. (1, 0)
  582. >>> error("<tag>&foo;</tag>").position
  583. (1, 5)
  584. >>> error("foobar<").position
  585. (1, 6)
  586. """
  587. try:
  588. ET.XML(xml)
  589. except ET.ParseError:
  590. return sys.exc_value
  591. # doesn't work with lxml.etree -> different positions
  592. del error
  593. def namespace():
  594. """
  595. Test namespace issues.
  596. 1) xml namespace
  597. >>> elem = ElementTree.XML("<tag xml:lang='en' />")
  598. >>> serialize(elem) # 1.1
  599. '<tag xml:lang="en"/>'
  600. 2) other "well-known" namespaces
  601. >>> elem = ElementTree.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")
  602. >>> serialize(elem) # 2.1
  603. '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>'
  604. >>> elem = ElementTree.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")
  605. >>> serialize(elem) # 2.2
  606. '<html:html xmlns:html="http://www.w3.org/1999/xhtml"/>'
  607. >>> elem = ElementTree.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")
  608. >>> serialize(elem) # 2.3
  609. '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope"/>'
  610. 3) unknown namespaces
  611. """
  612. def qname():
  613. """
  614. Test QName handling.
  615. 1) decorated tags
  616. >>> elem = ElementTree.Element("{uri}tag")
  617. >>> serialize(elem) # 1.1
  618. '<ns0:tag xmlns:ns0="uri"/>'
  619. >>> elem = ElementTree.Element(ElementTree.QName("{uri}tag"))
  620. >>> serialize(elem) # 1.2
  621. '<ns0:tag xmlns:ns0="uri"/>'
  622. >>> elem = ElementTree.Element(ElementTree.QName("uri", "tag"))
  623. >>> serialize(elem) # 1.3
  624. '<ns0:tag xmlns:ns0="uri"/>'
  625. # ns/attribute order ...
  626. ## 2) decorated attributes
  627. ## >>> elem.clear()
  628. ## >>> elem.attrib["{uri}key"] = "value"
  629. ## >>> serialize(elem) # 2.1
  630. ## '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>'
  631. ## >>> elem.clear()
  632. ## >>> elem.attrib[ElementTree.QName("{uri}key")] = "value"
  633. ## >>> serialize(elem) # 2.2
  634. ## '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>'
  635. ## 3) decorated values are not converted by default, but the
  636. ## QName wrapper can be used for values
  637. ## >>> elem.clear()
  638. ## >>> elem.attrib["{uri}key"] = "{uri}value"
  639. ## >>> serialize(elem) # 3.1
  640. ## '<ns0:tag ns0:key="{uri}value" xmlns:ns0="uri"/>'
  641. ## >>> elem.clear()
  642. ## >>> elem.attrib["{uri}key"] = ElementTree.QName("{uri}value")
  643. ## >>> serialize(elem) # 3.2
  644. ## '<ns0:tag ns0:key="ns0:value" xmlns:ns0="uri"/>'
  645. ## >>> elem.clear()
  646. ## >>> subelem = ElementTree.Element("tag")
  647. ## >>> subelem.attrib["{uri1}key"] = ElementTree.QName("{uri2}value")
  648. ## >>> elem.append(subelem)
  649. ## >>> elem.append(subelem)
  650. ## >>> serialize(elem) # 3.3
  651. ## '<ns0:tag xmlns:ns0="uri"><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/></ns0:tag>'
  652. """
  653. def xpath_tokenizer(p):
  654. """
  655. Test the XPath tokenizer.
  656. >>> # tests from the xml specification
  657. >>> xpath_tokenizer("*")
  658. ['*']
  659. >>> xpath_tokenizer("text()")
  660. ['text', '()']
  661. >>> xpath_tokenizer("@name")
  662. ['@', 'name']
  663. >>> xpath_tokenizer("@*")
  664. ['@', '*']
  665. >>> xpath_tokenizer("para[1]")
  666. ['para', '[', '1', ']']
  667. >>> xpath_tokenizer("para[last()]")
  668. ['para', '[', 'last', '()', ']']
  669. >>> xpath_tokenizer("*/para")
  670. ['*', '/', 'para']
  671. >>> xpath_tokenizer("/doc/chapter[5]/section[2]")
  672. ['/', 'doc', '/', 'chapter', '[', '5', ']', '/', 'section', '[', '2', ']']
  673. >>> xpath_tokenizer("chapter//para")
  674. ['chapter', '//', 'para']
  675. >>> xpath_tokenizer("//para")
  676. ['//', 'para']
  677. >>> xpath_tokenizer("//olist/item")
  678. ['//', 'olist', '/', 'item']
  679. >>> xpath_tokenizer(".")
  680. ['.']
  681. >>> xpath_tokenizer(".//para")
  682. ['.', '//', 'para']
  683. >>> xpath_tokenizer("..")
  684. ['..']
  685. >>> xpath_tokenizer("../@lang")
  686. ['..', '/', '@', 'lang']
  687. >>> xpath_tokenizer("chapter[title]")
  688. ['chapter', '[', 'title', ']']
  689. >>> xpath_tokenizer("employee[@secretary and @assistant]")
  690. ['employee', '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']']
  691. >>> # additional tests
  692. >>> xpath_tokenizer("{http://spam}egg")
  693. ['{http://spam}egg']
  694. >>> xpath_tokenizer("./spam.egg")
  695. ['.', '/', 'spam.egg']
  696. >>> xpath_tokenizer(".//{http://spam}egg")
  697. ['.', '//', '{http://spam}egg']
  698. """
  699. out = []
  700. for op, tag in ElementPath.xpath_tokenizer(p):
  701. out.append(op or tag)
  702. return out
  703. #
  704. # xinclude tests (samples from appendix C of the xinclude specification)
  705. XINCLUDE = {}
  706. XINCLUDE["C1.xml"] = """\
  707. <?xml version='1.0'?>
  708. <document xmlns:xi="http://www.w3.org/2001/XInclude">
  709. <p>120 Mz is adequate for an average home user.</p>
  710. <xi:include href="disclaimer.xml"/>
  711. </document>
  712. """
  713. XINCLUDE["disclaimer.xml"] = """\
  714. <?xml version='1.0'?>
  715. <disclaimer>
  716. <p>The opinions represented herein represent those of the individual
  717. and should not be interpreted as official policy endorsed by this
  718. organization.</p>
  719. </disclaimer>
  720. """
  721. XINCLUDE["C2.xml"] = """\
  722. <?xml version='1.0'?>
  723. <document xmlns:xi="http://www.w3.org/2001/XInclude">
  724. <p>This document has been accessed
  725. <xi:include href="count.txt" parse="text"/> times.</p>
  726. </document>
  727. """
  728. XINCLUDE["count.txt"] = "324387"
  729. XINCLUDE["C3.xml"] = """\
  730. <?xml version='1.0'?>
  731. <document xmlns:xi="http://www.w3.org/2001/XInclude">
  732. <p>The following is the source of the "data.xml" resource:</p>
  733. <example><xi:include href="data.xml" parse="text"/></example>
  734. </document>
  735. """
  736. XINCLUDE["data.xml"] = """\
  737. <?xml version='1.0'?>
  738. <data>
  739. <item><![CDATA[Brooks & Shields]]></item>
  740. </data>
  741. """
  742. XINCLUDE["C5.xml"] = """\
  743. <?xml version='1.0'?>
  744. <div xmlns:xi="http://www.w3.org/2001/XInclude">
  745. <xi:include href="example.txt" parse="text">
  746. <xi:fallback>
  747. <xi:include href="fallback-example.txt" parse="text">
  748. <xi:fallback><a href="mailto:bob@example.org">Report error</a></xi:fallback>
  749. </xi:include>
  750. </xi:fallback>
  751. </xi:include>
  752. </div>
  753. """
  754. XINCLUDE["default.xml"] = """\
  755. <?xml version='1.0'?>
  756. <document xmlns:xi="http://www.w3.org/2001/XInclude">
  757. <p>Example.</p>
  758. <xi:include href="samples/simple.xml"/>
  759. </document>
  760. """
  761. def xinclude_loader(href, parse="xml", encoding=None):
  762. try:
  763. data = XINCLUDE[href]
  764. except KeyError:
  765. raise IOError("resource not found")
  766. if parse == "xml":
  767. return ElementTree.XML(data)
  768. return data
  769. def xinclude():
  770. r"""
  771. Basic inclusion example (XInclude C.1)
  772. >>> document = xinclude_loader("C1.xml")
  773. >>> ElementInclude.include(document, xinclude_loader)
  774. >>> print(serialize(document)) # C1
  775. <document>
  776. <p>120 Mz is adequate for an average home user.</p>
  777. <disclaimer>
  778. <p>The opinions represented herein represent those of the individual
  779. and should not be interpreted as official policy endorsed by this
  780. organization.</p>
  781. </disclaimer>
  782. </document>
  783. Textual inclusion example (XInclude C.2)
  784. >>> document = xinclude_loader("C2.xml")
  785. >>> ElementInclude.include(document, xinclude_loader)
  786. >>> print(serialize(document)) # C2
  787. <document>
  788. <p>This document has been accessed
  789. 324387 times.</p>
  790. </document>
  791. Textual inclusion of XML example (XInclude C.3)
  792. >>> document = xinclude_loader("C3.xml")
  793. >>> ElementInclude.include(document, xinclude_loader)
  794. >>> print(serialize(document)) # C3
  795. <document>
  796. <p>The following is the source of the "data.xml" resource:</p>
  797. <example>&lt;?xml version='1.0'?&gt;
  798. &lt;data&gt;
  799. &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt;
  800. &lt;/data&gt;
  801. </example>
  802. </document>
  803. ## Fallback example (XInclude C.5)
  804. ## Note! Fallback support is not yet implemented
  805. ## >>> document = xinclude_loader("C5.xml")
  806. ## >>> ElementInclude.include(document, xinclude_loader)
  807. ## Traceback (most recent call last):
  808. ## IOError: resource not found
  809. ## >>> # print(serialize(document)) # C5
  810. """
  811. def xinclude_default():
  812. """
  813. >>> document = xinclude_loader("default.xml")
  814. >>> ElementInclude.include(document)
  815. >>> print(serialize(document)) # default
  816. <document>
  817. <p>Example.</p>
  818. <root>
  819. <element key="value">text</element>
  820. <element>text</element>tail
  821. <empty-element/>
  822. </root>
  823. </document>
  824. """
  825. #
  826. # xmlwriter
  827. def xmlwriter():
  828. r"""
  829. >>> file = BytesIO()
  830. >>> w = SimpleXMLWriter.XMLWriter(file)
  831. >>> html = w.start("html")
  832. >>> x = w.start("head")
  833. >>> w.element("title", "my document")
  834. >>> w.data("\n")
  835. >>> w.element("meta", name="hello", value="goodbye")
  836. >>> w.data("\n")
  837. >>> w.end()
  838. >>> x = w.start("body")
  839. >>> w.element("h1", "this is a heading")
  840. >>> w.data("\n")
  841. >>> w.element("p", u"this is a paragraph")
  842. >>> w.data("\n")
  843. >>> w.element("p", u"reserved characters: <&>")
  844. >>> w.data("\n")
  845. >>> w.element("p", u"detta är också ett stycke")
  846. >>> w.data("\n")
  847. >>> w.close(html)
  848. >>> print(file.getvalue())
  849. <html><head><title>my document</title>
  850. <meta name="hello" value="goodbye" />
  851. </head><body><h1>this is a heading</h1>
  852. <p>this is a paragraph</p>
  853. <p>reserved characters: &lt;&amp;&gt;</p>
  854. <p>detta &#228;r ocks&#229; ett stycke</p>
  855. </body></html>
  856. """
  857. # doesn't work with lxml.etree
  858. del xmlwriter
  859. # --------------------------------------------------------------------
  860. # reported bugs
  861. def bug_xmltoolkit21():
  862. """
  863. marshaller gives obscure errors for non-string values
  864. >>> elem = ElementTree.Element(123)
  865. >>> serialize(elem) # tag
  866. Traceback (most recent call last):
  867. TypeError: cannot serialize 123 (type int)
  868. >>> elem = ElementTree.Element("elem")
  869. >>> elem.text = 123
  870. >>> serialize(elem) # text
  871. Traceback (most recent call last):
  872. TypeError: cannot serialize 123 (type int)
  873. >>> elem = ElementTree.Element("elem")
  874. >>> elem.tail = 123
  875. >>> serialize(elem) # tail
  876. Traceback (most recent call last):
  877. TypeError: cannot serialize 123 (type int)
  878. >>> elem = ElementTree.Element("elem")
  879. >>> elem.set(123, "123")
  880. >>> serialize(elem) # attribute key
  881. Traceback (most recent call last):
  882. TypeError: cannot serialize 123 (type int)
  883. >>> elem = ElementTree.Element("elem")
  884. >>> elem.set("123", 123)
  885. >>> serialize(elem) # attribute value
  886. Traceback (most recent call last):
  887. TypeError: cannot serialize 123 (type int)
  888. """
  889. # doesn't work with lxml.etree
  890. del bug_xmltoolkit21
  891. def bug_xmltoolkit25():
  892. """
  893. typo in ElementTree.findtext
  894. >>> tree = ElementTree.ElementTree(SAMPLE_XML)
  895. >>> tree.findtext("tag")
  896. 'text'
  897. >>> tree.findtext("section/tag")
  898. 'subtext'
  899. """
  900. def bug_xmltoolkit28():
  901. """
  902. .//tag causes exceptions
  903. >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>")
  904. >>> summarize_list(tree.findall(".//thead"))
  905. []
  906. >>> summarize_list(tree.findall(".//tbody"))
  907. ['tbody']
  908. """
  909. def bug_xmltoolkitX1():
  910. """
  911. dump() doesn't flush the output buffer
  912. >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>")
  913. >>> ElementTree.dump(tree); sys.stdout.write("tail")
  914. <doc><table><tbody /></table></doc>
  915. tail
  916. """
  917. # doesn't work with lxml.etree
  918. del bug_xmltoolkitX1
  919. def bug_xmltoolkit39():
  920. """
  921. non-ascii element and attribute names doesn't work
  922. >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg />")
  923. >>> ElementTree.tostring(tree, "utf-8")
  924. '<t\\xc3\\xa4g />'
  925. >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><tag ättr='v&#228;lue' />")
  926. >>> tree.attrib
  927. {u'\\xe4ttr': u'v\\xe4lue'}
  928. >>> ElementTree.tostring(tree, "utf-8")
  929. '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'
  930. >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg>text</täg>")
  931. >>> ElementTree.tostring(tree, "utf-8")
  932. '<t\\xc3\\xa4g>text</t\\xc3\\xa4g>'
  933. >>> tree = ElementTree.Element(u"täg")
  934. >>> ElementTree.tostring(tree, "utf-8")
  935. '<t\\xc3\\xa4g />'
  936. >>> tree = ElementTree.Element("tag")
  937. >>> tree.set(u"ättr", u"välue")
  938. >>> ElementTree.tostring(tree, "utf-8")
  939. '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'
  940. """
  941. # doesn't work with lxml.etree
  942. del bug_xmltoolkit39
  943. def bug_xmltoolkit45():
  944. """
  945. problems parsing mixed unicode/non-ascii html documents
  946. latin-1 text
  947. >>> p = HTMLTreeBuilder.TreeBuilder()
  948. >>> p.feed("<p>välue</p>")
  949. >>> serialize(p.close())
  950. '<p>v&#228;lue</p>'
  951. utf-8 text
  952. >>> p = HTMLTreeBuilder.TreeBuilder(encoding="utf-8")
  953. >>> p.feed("<p>v\xc3\xa4lue</p>")
  954. >>> serialize(p.close())
  955. '<p>v&#228;lue</p>'
  956. utf-8 text using meta tag
  957. >>> p = HTMLTreeBuilder.TreeBuilder()
  958. >>> p.feed("<html><meta http-equiv='Content-Type' content='text/html; charset=utf-8'><p>v\xc3\xa4lue</p></html>")
  959. >>> serialize(p.close().find("p"))
  960. '<p>v&#228;lue</p>'
  961. latin-1 character references
  962. >>> p = HTMLTreeBuilder.TreeBuilder()
  963. >>> p.feed("<p>v&#228;lue</p>")
  964. >>> serialize(p.close())
  965. '<p>v&#228;lue</p>'
  966. latin-1 character entities
  967. >>> p = HTMLTreeBuilder.TreeBuilder()
  968. >>> p.feed("<p>v&auml;lue</p>")
  969. >>> serialize(p.close())
  970. '<p>v&#228;lue</p>'
  971. mixed latin-1 text and unicode entities
  972. >>> p = HTMLTreeBuilder.TreeBuilder()
  973. >>> p.feed("<p>&#8221;välue&#8221;</p>")
  974. >>> serialize(p.close())
  975. '<p>&#8221;v&#228;lue&#8221;</p>'
  976. mixed unicode and latin-1 entities
  977. >>> p = HTMLTreeBuilder.TreeBuilder()
  978. >>> p.feed("<p>&#8221;v&auml;lue&#8221;</p>")
  979. >>> serialize(p.close())
  980. '<p>&#8221;v&#228;lue&#8221;</p>'
  981. """
  982. # doesn't work with lxml.etree
  983. del bug_xmltoolkit45
  984. def bug_xmltoolkit46():
  985. """
  986. problems parsing open BR tags
  987. >>> p = HTMLTreeBuilder.TreeBuilder()
  988. >>> p.feed("<p>key<br>value</p>")
  989. >>> serialize(p.close())
  990. '<p>key<br />value</p>'
  991. """
  992. # doesn't work with lxml.etree
  993. del bug_xmltoolkit46
  994. def bug_xmltoolkit54():
  995. """
  996. problems handling internally defined entities
  997. >>> e = ElementTree.XML("<!DOCTYPE doc [<!ENTITY ldots '&#x8230;'>]><doc>&ldots;</doc>")
  998. >>> serialize(e)
  999. '<doc>&#33328;</doc>'
  1000. """
  1001. # doesn't work with lxml.etree
  1002. del bug_xmltoolkit54
  1003. def bug_xmltoolkit55():
  1004. """
  1005. make sure we're reporting the first error, not the last
  1006. >>> e = ElementTree.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'><doc>&ldots;&ndots;&rdots;</doc>")
  1007. Traceback (most recent call last):
  1008. ParseError: undefined entity &ldots;: line 1, column 36
  1009. """
  1010. # doesn't work with lxml.etree
  1011. del bug_xmltoolkit55
  1012. def bug_200708_version():
  1013. """
  1014. >>> parser = ET.XMLParser()
  1015. >>> parser.version
  1016. 'Expat 2.0.0'
  1017. >>> parser.feed(open("samples/simple.xml").read())
  1018. >>> print(serialize(parser.close()))
  1019. <root>
  1020. <element key="value">text</element>
  1021. <element>text</element>tail
  1022. <empty-element />
  1023. </root>
  1024. """
  1025. # doesn't work with lxml.etree
  1026. del bug_200708_version
  1027. def bug_200708_newline():
  1028. r"""
  1029. Preserve newlines in attributes.
  1030. >>> e = ET.Element('SomeTag', text="def _f():\n return 3\n")
  1031. >>> ET.tostring(e)
  1032. '<SomeTag text="def _f():&#10; return 3&#10;" />'
  1033. >>> ET.XML(ET.tostring(e)).get("text")
  1034. 'def _f():\n return 3\n'
  1035. >>> ET.tostring(ET.XML(ET.tostring(e)))
  1036. '<SomeTag text="def _f():&#10; return 3&#10;" />'
  1037. """
  1038. # doesn't work with lxml.etree
  1039. del bug_200708_newline
  1040. def bug_200709_default_namespace():
  1041. """
  1042. >>> e = ET.Element("{default}elem")
  1043. >>> s = ET.SubElement(e, "{default}elem")
  1044. >>> serialize(e, default_namespace="default") # 1
  1045. '<elem xmlns="default"><elem /></elem>'
  1046. >>> e = ET.Element("{default}elem")
  1047. >>> s = ET.SubElement(e, "{default}elem")
  1048. >>> s = ET.SubElement(e, "{not-default}elem")
  1049. >>> serialize(e, default_namespace="default") # 2
  1050. '<elem xmlns="default" xmlns:ns1="not-default"><elem /><ns1:elem /></elem>'
  1051. >>> e = ET.Element("{default}elem")
  1052. >>> s = ET.SubElement(e, "{default}elem")
  1053. >>> s = ET.SubElement(e, "elem") # unprefixed name
  1054. >>> serialize(e, default_namespace="default") # 3
  1055. Traceback (most recent call last):
  1056. ValueError: cannot use non-qualified names with default_namespace option
  1057. """
  1058. # doesn't work with lxml.etree
  1059. del bug_200709_default_namespace
  1060. # --------------------------------------------------------------------
  1061. if __name__ == "__main__":
  1062. import doctest, selftest
  1063. failed, tested = doctest.testmod(selftest)
  1064. print("%d tests ok." % (tested - failed))
  1065. if failed > 0:
  1066. print("%d tests failed. Exiting with non-zero return code." % failed)
  1067. sys.exit(1)