selftest.py 34 KB

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