Debian Codegraph @

Lib/test/test_xml_etree.py

raw
1 # IMPORTANT: the same tests are run from "test_xml_etree_c" in order
2 # to ensure consistency between the C implementation and the Python
3 # implementation.
4 #
5 # For this purpose, the module-level "ET" symbol is temporarily
6 # monkey-patched when running the "test_xml_etree_c" test suite.
7
8 import copy
9 import functools
10 import html
11 import io
12 import itertools
13 import operator
14 import os
15 import pickle
16 import pyexpat
17 import sys
18 import textwrap
19 import types
20 import unittest
21 import unittest.mock as mock
22 import warnings
23 import weakref
24
25 from contextlib import nullcontext
26 from functools import partial
27 from itertools import product, islice
28 from test import support
29 from test.support import os_helper
30 from test.support import warnings_helper
31 from test.support import findfile, gc_collect, swap_attr, swap_item
32 from test.support.import_helper import import_fresh_module
33 from test.support.os_helper import TESTFN
34
35
36 # pyET is the pure-Python implementation.
37 #
38 # ET is pyET in test_xml_etree and is the C accelerated version in
39 # test_xml_etree_c.
40 pyET = None
41 ET = None
42
43 SIMPLE_XMLFILE = findfile("simple.xml", subdir="xmltestdata")
44 try:
45 SIMPLE_XMLFILE.encode("utf-8")
46 except UnicodeEncodeError:
47 raise unittest.SkipTest("filename is not encodable to utf8")
48 SIMPLE_NS_XMLFILE = findfile("simple-ns.xml", subdir="xmltestdata")
49 UTF8_BUG_XMLFILE = findfile("expat224_utf8_bug.xml", subdir="xmltestdata")
50
51 SAMPLE_XML = """\
52 <body>
53 <tag class='a'>text</tag>
54 <tag class='b' />
55 <section>
56 <tag class='b' id='inner'>subtext</tag>
57 </section>
58 </body>
59 """
60
61 SAMPLE_SECTION = """\
62 <section>
63 <tag class='b' id='inner'>subtext</tag>
64 <nexttag />
65 <nextsection>
66 <tag />
67 </nextsection>
68 </section>
69 """
70
71 SAMPLE_XML_NS = """
72 <body xmlns="http://effbot.org/ns">
73 <tag>text</tag>
74 <tag />
75 <section>
76 <tag>subtext</tag>
77 </section>
78 </body>
79 """
80
81 SAMPLE_XML_NS_ELEMS = """
82 <root>
83 <h:table xmlns:h="hello">
84 <h:tr>
85 <h:td>Apples</h:td>
86 <h:td>Bananas</h:td>
87 </h:tr>
88 </h:table>
89
90 <f:table xmlns:f="foo">
91 <f:name>African Coffee Table</f:name>
92 <f:width>80</f:width>
93 <f:length>120</f:length>
94 </f:table>
95 </root>
96 """
97
98 ENTITY_XML = """\
99 <!DOCTYPE points [
100 <!ENTITY % user-entities SYSTEM 'user-entities.xml'>
101 %user-entities;
102 ]>
103 <document>&entity;</document>
104 """
105
106 EXTERNAL_ENTITY_XML = """\
107 <!DOCTYPE points [
108 <!ENTITY entity SYSTEM "file:///non-existing-file.xml">
109 ]>
110 <document>&entity;</document>
111 """
112
113 ATTLIST_XML = """\
114 <?xml version="1.0" encoding="UTF-8"?>
115 <!DOCTYPE Foo [
116 <!ELEMENT foo (bar*)>
117 <!ELEMENT bar (#PCDATA)*>
118 <!ATTLIST bar xml:lang CDATA "eng">
119 <!ENTITY qux "quux">
120 ]>
121 <foo>
122 <bar>&qux;</bar>
123 </foo>
124 """
125
126 def is_python_implementation():
127 assert ET is not None, "ET must be initialized"
128 assert pyET is not None, "pyET must be initialized"
129 return ET is pyET
130
131
132 def equal_wrapper(cls):
133 """Mock cls.__eq__ to check whether it has been called or not.
134
135 The behaviour of cls.__eq__ (side-effects included) is left as is.
136 """
137 eq = cls.__eq__
138 return mock.patch.object(cls, "__eq__", autospec=True, wraps=eq)
139
140
141 def checkwarnings(*filters, quiet=False):
142 def decorator(test):
143 def newtest(*args, **kwargs):
144 with warnings_helper.check_warnings(*filters, quiet=quiet):
145 test(*args, **kwargs)
146 functools.update_wrapper(newtest, test)
147 return newtest
148 return decorator
149
150 def convlinesep(data):
151 return data.replace(b'\n', os.linesep.encode())
152
153
154 class ModuleTest(unittest.TestCase):
155 def test_sanity(self):
156 # Import sanity.
157
158 from xml.etree import ElementTree # noqa: F401
159 from xml.etree import ElementInclude # noqa: F401
160 from xml.etree import ElementPath # noqa: F401
161
162 def test_all(self):
163 names = ("xml.etree.ElementTree", "_elementtree")
164 support.check__all__(self, ET, names, not_exported=("HTML_EMPTY",))
165
166
167 def serialize(elem, to_string=True, encoding='unicode', **options):
168 if encoding != 'unicode':
169 file = io.BytesIO()
170 else:
171 file = io.StringIO()
172 tree = ET.ElementTree(elem)
173 tree.write(file, encoding=encoding, **options)
174 if to_string:
175 return file.getvalue()
176 else:
177 file.seek(0)
178 return file
179
180 def summarize_list(seq):
181 return [elem.tag for elem in seq]
182
183
184 class ElementTestCase:
185 @classmethod
186 def setUpClass(cls):
187 cls.modules = {pyET, ET}
188
189 def pickleRoundTrip(self, obj, name, dumper, loader, proto):
190 try:
191 with swap_item(sys.modules, name, dumper):
192 temp = pickle.dumps(obj, proto)
193 with swap_item(sys.modules, name, loader):
194 result = pickle.loads(temp)
195 except pickle.PicklingError as pe:
196 # pyET must be second, because pyET may be (equal to) ET.
197 human = dict([(ET, "cET"), (pyET, "pyET")])
198 raise support.TestFailed("Failed to round-trip %r from %r to %r"
199 % (obj,
200 human.get(dumper, dumper),
201 human.get(loader, loader))) from pe
202 return result
203
204 def assertEqualElements(self, alice, bob):
205 self.assertIsInstance(alice, (ET.Element, pyET.Element))
206 self.assertIsInstance(bob, (ET.Element, pyET.Element))
207 self.assertEqual(len(list(alice)), len(list(bob)))
208 for x, y in zip(alice, bob):
209 self.assertEqualElements(x, y)
210 properties = operator.attrgetter('tag', 'tail', 'text', 'attrib')
211 self.assertEqual(properties(alice), properties(bob))
212
213 # --------------------------------------------------------------------
214 # element tree tests
215
216 class ElementTreeTest(unittest.TestCase):
217
218 def serialize_check(self, elem, expected):
219 self.assertEqual(serialize(elem), expected)
220
221 def test_constructor(self):
222 # Test constructor behavior.
223
224 with self.assertRaises(TypeError):
225 tree = ET.ElementTree("")
226 with self.assertRaises(TypeError):
227 tree = ET.ElementTree(ET.ElementTree())
228
229 def test_setroot(self):
230 # Test _setroot behavior.
231
232 tree = ET.ElementTree()
233 element = ET.Element("tag")
234 tree._setroot(element)
235 self.assertEqual(tree.getroot().tag, "tag")
236 self.assertEqual(tree.getroot(), element)
237
238 # Test behavior with an invalid root element
239
240 tree = ET.ElementTree()
241 with self.assertRaises(TypeError):
242 tree._setroot("")
243 with self.assertRaises(TypeError):
244 tree._setroot(ET.ElementTree())
245 with self.assertRaises(TypeError):
246 tree._setroot(None)
247
248 def test_interface(self):
249 # Test element tree interface.
250
251 def check_element(element):
252 self.assertTrue(ET.iselement(element), msg="not an element")
253 direlem = dir(element)
254 for attr in 'tag', 'attrib', 'text', 'tail':
255 self.assertHasAttr(element, attr)
256 self.assertIn(attr, direlem,
257 msg='no %s visible by dir' % attr)
258
259 self.assertIsInstance(element.tag, str)
260 self.assertIsInstance(element.attrib, dict)
261 if element.text is not None:
262 self.assertIsInstance(element.text, str)
263 if element.tail is not None:
264 self.assertIsInstance(element.tail, str)
265 for elem in element:
266 check_element(elem)
267
268 element = ET.Element("tag")
269 check_element(element)
270 tree = ET.ElementTree(element)
271 check_element(tree.getroot())
272 element = ET.Element("t\xe4g", key="value")
273 tree = ET.ElementTree(element)
274 self.assertRegex(repr(element), r"^<Element 't\xe4g' at 0x.*>$")
275 element = ET.Element("tag", key="value")
276
277 # Make sure all standard element methods exist.
278
279 def check_method(method):
280 self.assertHasAttr(method, '__call__',
281 msg="%s not callable" % method)
282
283 check_method(element.append)
284 check_method(element.extend)
285 check_method(element.insert)
286 check_method(element.remove)
287 check_method(element.find)
288 check_method(element.iterfind)
289 check_method(element.findall)
290 check_method(element.findtext)
291 check_method(element.clear)
292 check_method(element.get)
293 check_method(element.set)
294 check_method(element.keys)
295 check_method(element.items)
296 check_method(element.iter)
297 check_method(element.itertext)
298
299 # These methods return an iterable. See bug 6472.
300
301 def check_iter(it):
302 check_method(it.__next__)
303
304 check_iter(element.iterfind("tag"))
305 check_iter(element.iterfind("*"))
306 check_iter(tree.iterfind("tag"))
307 check_iter(tree.iterfind("*"))
308
309 # These aliases are provided:
310
311 self.assertEqual(ET.XML, ET.fromstring)
312 self.assertEqual(ET.PI, ET.ProcessingInstruction)
313
314 def test_set_attribute(self):
315 element = ET.Element('tag')
316
317 self.assertEqual(element.tag, 'tag')
318 element.tag = 'Tag'
319 self.assertEqual(element.tag, 'Tag')
320 element.tag = 'TAG'
321 self.assertEqual(element.tag, 'TAG')
322
323 self.assertIsNone(element.text)
324 element.text = 'Text'
325 self.assertEqual(element.text, 'Text')
326 element.text = 'TEXT'
327 self.assertEqual(element.text, 'TEXT')
328
329 self.assertIsNone(element.tail)
330 element.tail = 'Tail'
331 self.assertEqual(element.tail, 'Tail')
332 element.tail = 'TAIL'
333 self.assertEqual(element.tail, 'TAIL')
334
335 self.assertEqual(element.attrib, {})
336 element.attrib = {'a': 'b', 'c': 'd'}
337 self.assertEqual(element.attrib, {'a': 'b', 'c': 'd'})
338 element.attrib = {'A': 'B', 'C': 'D'}
339 self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
340
341 def test_simpleops(self):
342 # Basic method sanity checks.
343
344 elem = ET.XML("<body><tag/></body>")
345 self.serialize_check(elem, '<body><tag /></body>')
346 e = ET.Element("tag2")
347 elem.append(e)
348 self.serialize_check(elem, '<body><tag /><tag2 /></body>')
349 elem.remove(e)
350 self.serialize_check(elem, '<body><tag /></body>')
351 elem.insert(0, e)
352 self.serialize_check(elem, '<body><tag2 /><tag /></body>')
353 elem.remove(e)
354 elem.extend([e])
355 self.serialize_check(elem, '<body><tag /><tag2 /></body>')
356 elem.remove(e)
357 elem.extend(iter([e]))
358 self.serialize_check(elem, '<body><tag /><tag2 /></body>')
359 elem.remove(e)
360
361 element = ET.Element("tag", key="value")
362 self.serialize_check(element, '<tag key="value" />') # 1
363 subelement = ET.Element("subtag")
364 element.append(subelement)
365 self.serialize_check(element, '<tag key="value"><subtag /></tag>') # 2
366 element.insert(0, subelement)
367 self.serialize_check(element,
368 '<tag key="value"><subtag /><subtag /></tag>') # 3
369 element.remove(subelement)
370 self.serialize_check(element, '<tag key="value"><subtag /></tag>') # 4
371 element.remove(subelement)
372 self.serialize_check(element, '<tag key="value" />') # 5
373 with self.assertRaisesRegex(ValueError,
374 r'Element\.remove\(.+\): element not found'):
375 element.remove(subelement)
376 self.serialize_check(element, '<tag key="value" />') # 6
377 element[0:0] = [subelement, subelement, subelement]
378 self.serialize_check(element[1], '<subtag />')
379 self.assertEqual(element[1:9], [element[1], element[2]])
380 self.assertEqual(element[:9:2], [element[0], element[2]])
381 del element[1:2]
382 self.serialize_check(element,
383 '<tag key="value"><subtag /><subtag /></tag>')
384
385 def test_cdata(self):
386 # Test CDATA handling (etc).
387
388 self.serialize_check(ET.XML("<tag>hello</tag>"),
389 '<tag>hello</tag>')
390 self.serialize_check(ET.XML("<tag>&#104;&#101;&#108;&#108;&#111;</tag>"),
391 '<tag>hello</tag>')
392 self.serialize_check(ET.XML("<tag><![CDATA[hello]]></tag>"),
393 '<tag>hello</tag>')
394
395 def test_file_init(self):
396 stringfile = io.BytesIO(SAMPLE_XML.encode("utf-8"))
397 tree = ET.ElementTree(file=stringfile)
398 self.assertEqual(tree.find("tag").tag, 'tag')
399 self.assertEqual(tree.find("section/tag").tag, 'tag')
400
401 tree = ET.ElementTree(file=SIMPLE_XMLFILE)
402 self.assertEqual(tree.find("element").tag, 'element')
403 self.assertEqual(tree.find("element/../empty-element").tag,
404 'empty-element')
405
406 def test_path_cache(self):
407 # Check that the path cache behaves sanely.
408
409 from xml.etree import ElementPath
410
411 elem = ET.XML(SAMPLE_XML)
412 ElementPath._cache.clear()
413 for i in range(10): ET.ElementTree(elem).find('./'+str(i))
414 cache_len_10 = len(ElementPath._cache)
415 for i in range(10): ET.ElementTree(elem).find('./'+str(i))
416 self.assertEqual(len(ElementPath._cache), cache_len_10)
417 for i in range(20): ET.ElementTree(elem).find('./'+str(i))
418 self.assertGreater(len(ElementPath._cache), cache_len_10)
419 for i in range(600): ET.ElementTree(elem).find('./'+str(i))
420 self.assertLess(len(ElementPath._cache), 500)
421
422 def test_copy(self):
423 # Test copy handling (etc).
424
425 import copy
426 e1 = ET.XML("<tag>hello<foo/></tag>")
427 e2 = copy.copy(e1)
428 e3 = copy.deepcopy(e1)
429 e1.find("foo").tag = "bar"
430 self.serialize_check(e1, '<tag>hello<bar /></tag>')
431 self.serialize_check(e2, '<tag>hello<bar /></tag>')
432 self.serialize_check(e3, '<tag>hello<foo /></tag>')
433
434 def test_attrib(self):
435 # Test attribute handling.
436
437 elem = ET.Element("tag")
438 elem.get("key") # 1.1
439 self.assertEqual(elem.get("key", "default"), 'default') # 1.2
440
441 elem.set("key", "value")
442 self.assertEqual(elem.get("key"), 'value') # 1.3
443
444 elem = ET.Element("tag", key="value")
445 self.assertEqual(elem.get("key"), 'value') # 2.1
446 self.assertEqual(elem.attrib, {'key': 'value'}) # 2.2
447
448 attrib = {"key": "value"}
449 elem = ET.Element("tag", attrib)
450 attrib.clear() # check for aliasing issues
451 self.assertEqual(elem.get("key"), 'value') # 3.1
452 self.assertEqual(elem.attrib, {'key': 'value'}) # 3.2
453
454 attrib = {"key": "value"}
455 elem = ET.Element("tag", **attrib)
456 attrib.clear() # check for aliasing issues
457 self.assertEqual(elem.get("key"), 'value') # 4.1
458 self.assertEqual(elem.attrib, {'key': 'value'}) # 4.2
459
460 elem = ET.Element("tag", {"key": "other"}, key="value")
461 self.assertEqual(elem.get("key"), 'value') # 5.1
462 self.assertEqual(elem.attrib, {'key': 'value'}) # 5.2
463
464 elem = ET.Element('test')
465 elem.text = "aa"
466 elem.set('testa', 'testval')
467 elem.set('testb', 'test2')
468 self.assertEqual(ET.tostring(elem),
469 b'<test testa="testval" testb="test2">aa</test>')
470 self.assertEqual(sorted(elem.keys()), ['testa', 'testb'])
471 self.assertEqual(sorted(elem.items()),
472 [('testa', 'testval'), ('testb', 'test2')])
473 self.assertEqual(elem.attrib['testb'], 'test2')
474 elem.attrib['testb'] = 'test1'
475 elem.attrib['testc'] = 'test2'
476 self.assertEqual(ET.tostring(elem),
477 b'<test testa="testval" testb="test1" testc="test2">aa</test>')
478
479 # Test preserving white space chars in attributes
480 elem = ET.Element('test')
481 elem.set('a', '\r')
482 elem.set('b', '\r\n')
483 elem.set('c', '\t\n\r ')
484 elem.set('d', '\n\n\r\r\t\t ')
485 self.assertEqual(ET.tostring(elem),
486 b'<test a="&#13;" b="&#13;&#10;" c="&#09;&#10;&#13; " d="&#10;&#10;&#13;&#13;&#09;&#09; " />')
487
488 def test_makeelement(self):
489 # Test makeelement handling.
490
491 elem = ET.Element("tag")
492 attrib = {"key": "value"}
493 subelem = elem.makeelement("subtag", attrib)
494 self.assertIsNot(subelem.attrib, attrib, msg="attrib aliasing")
495 elem.append(subelem)
496 self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
497
498 elem.clear()
499 self.serialize_check(elem, '<tag />')
500 elem.append(subelem)
501 self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
502 elem.extend([subelem, subelem])
503 self.serialize_check(elem,
504 '<tag><subtag key="value" /><subtag key="value" /><subtag key="value" /></tag>')
505 elem[:] = [subelem]
506 self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
507 elem[:] = tuple([subelem])
508 self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
509
510 def test_parsefile(self):
511 # Test parsing from file.
512
513 tree = ET.parse(SIMPLE_XMLFILE)
514 stream = io.StringIO()
515 tree.write(stream, encoding='unicode')
516 self.assertEqual(stream.getvalue(),
517 '<root>\n'
518 ' <element key="value">text</element>\n'
519 ' <element>text</element>tail\n'
520 ' <empty-element />\n'
521 '</root>')
522 tree = ET.parse(SIMPLE_NS_XMLFILE)
523 stream = io.StringIO()
524 tree.write(stream, encoding='unicode')
525 self.assertEqual(stream.getvalue(),
526 '<ns0:root xmlns:ns0="namespace">\n'
527 ' <ns0:element key="value">text</ns0:element>\n'
528 ' <ns0:element>text</ns0:element>tail\n'
529 ' <ns0:empty-element />\n'
530 '</ns0:root>')
531
532 with open(SIMPLE_XMLFILE) as f:
533 data = f.read()
534
535 parser = ET.XMLParser()
536 self.assertRegex(parser.version, r'^Expat ')
537 parser.feed(data)
538 self.serialize_check(parser.close(),
539 '<root>\n'
540 ' <element key="value">text</element>\n'
541 ' <element>text</element>tail\n'
542 ' <empty-element />\n'
543 '</root>')
544
545 target = ET.TreeBuilder()
546 parser = ET.XMLParser(target=target)
547 parser.feed(data)
548 self.serialize_check(parser.close(),
549 '<root>\n'
550 ' <element key="value">text</element>\n'
551 ' <element>text</element>tail\n'
552 ' <empty-element />\n'
553 '</root>')
554
555 def test_parseliteral(self):
556 element = ET.XML("<html><body>text</body></html>")
557 self.assertEqual(ET.tostring(element, encoding='unicode'),
558 '<html><body>text</body></html>')
559 element = ET.fromstring("<html><body>text</body></html>")
560 self.assertEqual(ET.tostring(element, encoding='unicode'),
561 '<html><body>text</body></html>')
562 sequence = ["<html><body>", "text</bo", "dy></html>"]
563 element = ET.fromstringlist(sequence)
564 self.assertEqual(ET.tostring(element),
565 b'<html><body>text</body></html>')
566 self.assertEqual(b"".join(ET.tostringlist(element)),
567 b'<html><body>text</body></html>')
568 self.assertEqual(ET.tostring(element, "ascii"),
569 b"<?xml version='1.0' encoding='ascii'?>\n"
570 b"<html><body>text</body></html>")
571 _, ids = ET.XMLID("<html><body>text</body></html>")
572 self.assertEqual(len(ids), 0)
573 _, ids = ET.XMLID("<html><body id='body'>text</body></html>")
574 self.assertEqual(len(ids), 1)
575 self.assertEqual(ids["body"].tag, 'body')
576
577 def test_writefile(self):
578 elem = ET.Element("tag")
579 elem.text = "text"
580 self.serialize_check(elem, '<tag>text</tag>')
581 ET.SubElement(elem, "subtag").text = "subtext"
582 self.serialize_check(elem, '<tag>text<subtag>subtext</subtag></tag>')
583
584 # Test tag suppression
585 elem.tag = None
586 self.serialize_check(elem, 'text<subtag>subtext</subtag>')
587 elem.insert(0, ET.Comment("comment"))
588 self.serialize_check(elem,
589 'text<!--comment--><subtag>subtext</subtag>') # assumes 1.3
590
591 elem[0] = ET.PI("key", "value")
592 self.serialize_check(elem, 'text<?key value?><subtag>subtext</subtag>')
593
594 def test_custom_builder(self):
595 # Test parser w. custom builder.
596
597 with open(SIMPLE_XMLFILE) as f:
598 data = f.read()
599 class Builder(list):
600 def start(self, tag, attrib):
601 self.append(("start", tag))
602 def end(self, tag):
603 self.append(("end", tag))
604 def data(self, text):
605 pass
606 builder = Builder()
607 parser = ET.XMLParser(target=builder)
608 parser.feed(data)
609 self.assertEqual(builder, [
610 ('start', 'root'),
611 ('start', 'element'),
612 ('end', 'element'),
613 ('start', 'element'),
614 ('end', 'element'),
615 ('start', 'empty-element'),
616 ('end', 'empty-element'),
617 ('end', 'root'),
618 ])
619
620 with open(SIMPLE_NS_XMLFILE) as f:
621 data = f.read()
622 class Builder(list):
623 def start(self, tag, attrib):
624 self.append(("start", tag))
625 def end(self, tag):
626 self.append(("end", tag))
627 def data(self, text):
628 pass
629 def pi(self, target, data):
630 self.append(("pi", target, data))
631 def comment(self, data):
632 self.append(("comment", data))
633 def start_ns(self, prefix, uri):
634 self.append(("start-ns", prefix, uri))
635 def end_ns(self, prefix):
636 self.append(("end-ns", prefix))
637 builder = Builder()
638 parser = ET.XMLParser(target=builder)
639 parser.feed(data)
640 self.assertEqual(builder, [
641 ('pi', 'pi', 'data'),
642 ('comment', ' comment '),
643 ('start-ns', '', 'namespace'),
644 ('start', '{namespace}root'),
645 ('start', '{namespace}element'),
646 ('end', '{namespace}element'),
647 ('start', '{namespace}element'),
648 ('end', '{namespace}element'),
649 ('start', '{namespace}empty-element'),
650 ('end', '{namespace}empty-element'),
651 ('end', '{namespace}root'),
652 ('end-ns', ''),
653 ])
654
655 def test_custom_builder_only_end_ns(self):
656 class Builder(list):
657 def end_ns(self, prefix):
658 self.append(("end-ns", prefix))
659
660 builder = Builder()
661 parser = ET.XMLParser(target=builder)
662 parser.feed(textwrap.dedent("""\
663 <?pi data?>
664 <!-- comment -->
665 <root xmlns='namespace' xmlns:p='pns' xmlns:a='ans'>
666 <a:element key='value'>text</a:element>
667 <p:element>text</p:element>tail
668 <empty-element/>
669 </root>
670 """))
671 self.assertEqual(builder, [
672 ('end-ns', 'a'),
673 ('end-ns', 'p'),
674 ('end-ns', ''),
675 ])
676
677 def test_initialize_parser_without_target(self):
678 # Explicit None
679 parser = ET.XMLParser(target=None)
680 self.assertIsInstance(parser.target, ET.TreeBuilder)
681
682 # Implicit None
683 parser2 = ET.XMLParser()
684 self.assertIsInstance(parser2.target, ET.TreeBuilder)
685
686 def test_children(self):
687 # Test Element children iteration
688
689 with open(SIMPLE_XMLFILE, "rb") as f:
690 tree = ET.parse(f)
691 self.assertEqual([summarize_list(elem)
692 for elem in tree.getroot().iter()], [
693 ['element', 'element', 'empty-element'],
694 [],
695 [],
696 [],
697 ])
698 self.assertEqual([summarize_list(elem)
699 for elem in tree.iter()], [
700 ['element', 'element', 'empty-element'],
701 [],
702 [],
703 [],
704 ])
705
706 elem = ET.XML(SAMPLE_XML)
707 self.assertEqual(len(list(elem)), 3)
708 self.assertEqual(len(list(elem[2])), 1)
709 self.assertEqual(elem[:], list(elem))
710 child1 = elem[0]
711 child2 = elem[2]
712 del elem[1:2]
713 self.assertEqual(len(list(elem)), 2)
714 self.assertEqual(child1, elem[0])
715 self.assertEqual(child2, elem[1])
716 elem[0:2] = [child2, child1]
717 self.assertEqual(child2, elem[0])
718 self.assertEqual(child1, elem[1])
719 self.assertNotEqual(child1, elem[0])
720 elem.clear()
721 self.assertEqual(list(elem), [])
722
723 def test_writestring(self):
724 elem = ET.XML("<html><body>text</body></html>")
725 self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
726 elem = ET.fromstring("<html><body>text</body></html>")
727 self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
728
729 def test_indent(self):
730 elem = ET.XML("<root></root>")
731 ET.indent(elem)
732 self.assertEqual(ET.tostring(elem), b'<root />')
733
734 elem = ET.XML("<html><body>text</body></html>")
735 ET.indent(elem)
736 self.assertEqual(ET.tostring(elem), b'<html>\n <body>text</body>\n</html>')
737
738 elem = ET.XML("<html> <body>text</body> </html>")
739 ET.indent(elem)
740 self.assertEqual(ET.tostring(elem), b'<html>\n <body>text</body>\n</html>')
741
742 elem = ET.XML("<html><body>text</body>tail</html>")
743 ET.indent(elem)
744 self.assertEqual(ET.tostring(elem), b'<html>\n <body>text</body>tail</html>')
745
746 elem = ET.XML("<html><body><p>par</p>\n<p>text</p>\t<p><br/></p></body></html>")
747 ET.indent(elem)
748 self.assertEqual(
749 ET.tostring(elem),
750 b'<html>\n'
751 b' <body>\n'
752 b' <p>par</p>\n'
753 b' <p>text</p>\n'
754 b' <p>\n'
755 b' <br />\n'
756 b' </p>\n'
757 b' </body>\n'
758 b'</html>'
759 )
760
761 elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
762 ET.indent(elem)
763 self.assertEqual(
764 ET.tostring(elem),
765 b'<html>\n'
766 b' <body>\n'
767 b' <p>pre<br />post</p>\n'
768 b' <p>text</p>\n'
769 b' </body>\n'
770 b'</html>'
771 )
772
773 def test_indent_space(self):
774 elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
775 ET.indent(elem, space='\t')
776 self.assertEqual(
777 ET.tostring(elem),
778 b'<html>\n'
779 b'\t<body>\n'
780 b'\t\t<p>pre<br />post</p>\n'
781 b'\t\t<p>text</p>\n'
782 b'\t</body>\n'
783 b'</html>'
784 )
785
786 elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
787 ET.indent(elem, space='')
788 self.assertEqual(
789 ET.tostring(elem),
790 b'<html>\n'
791 b'<body>\n'
792 b'<p>pre<br />post</p>\n'
793 b'<p>text</p>\n'
794 b'</body>\n'
795 b'</html>'
796 )
797
798 def test_indent_space_caching(self):
799 elem = ET.XML("<html><body><p>par</p><p>text</p><p><br/></p><p /></body></html>")
800 ET.indent(elem)
801 self.assertEqual(
802 {el.tail for el in elem.iter()},
803 {None, "\n", "\n ", "\n "}
804 )
805 self.assertEqual(
806 {el.text for el in elem.iter()},
807 {None, "\n ", "\n ", "\n ", "par", "text"}
808 )
809 self.assertEqual(
810 len({el.tail for el in elem.iter()}),
811 len({id(el.tail) for el in elem.iter()}),
812 )
813
814 def test_indent_level(self):
815 elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
816 with self.assertRaises(ValueError):
817 ET.indent(elem, level=-1)
818 self.assertEqual(
819 ET.tostring(elem),
820 b"<html><body><p>pre<br />post</p><p>text</p></body></html>"
821 )
822
823 ET.indent(elem, level=2)
824 self.assertEqual(
825 ET.tostring(elem),
826 b'<html>\n'
827 b' <body>\n'
828 b' <p>pre<br />post</p>\n'
829 b' <p>text</p>\n'
830 b' </body>\n'
831 b' </html>'
832 )
833
834 elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
835 ET.indent(elem, level=1, space=' ')
836 self.assertEqual(
837 ET.tostring(elem),
838 b'<html>\n'
839 b' <body>\n'
840 b' <p>pre<br />post</p>\n'
841 b' <p>text</p>\n'
842 b' </body>\n'
843 b' </html>'
844 )
845
846 def test_tostring_default_namespace(self):
847 elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
848 self.assertEqual(
849 ET.tostring(elem, encoding='unicode'),
850 '<ns0:body xmlns:ns0="http://effbot.org/ns"><ns0:tag /></ns0:body>'
851 )
852 self.assertEqual(
853 ET.tostring(elem, encoding='unicode', default_namespace='http://effbot.org/ns'),
854 '<body xmlns="http://effbot.org/ns"><tag /></body>'
855 )
856
857 def test_tostring_default_namespace_different_namespace(self):
858 elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
859 self.assertEqual(
860 ET.tostring(elem, encoding='unicode', default_namespace='foobar'),
861 '<ns1:body xmlns="foobar" xmlns:ns1="http://effbot.org/ns"><ns1:tag /></ns1:body>'
862 )
863
864 def test_tostring_default_namespace_original_no_namespace(self):
865 elem = ET.XML('<body><tag/></body>')
866 EXPECTED_MSG = '^cannot use non-qualified names with default_namespace option$'
867 with self.assertRaisesRegex(ValueError, EXPECTED_MSG):
868 ET.tostring(elem, encoding='unicode', default_namespace='foobar')
869
870 def test_tostring_no_xml_declaration(self):
871 elem = ET.XML('<body><tag/></body>')
872 self.assertEqual(
873 ET.tostring(elem, encoding='unicode'),
874 '<body><tag /></body>'
875 )
876
877 def test_tostring_xml_declaration(self):
878 elem = ET.XML('<body><tag/></body>')
879 self.assertEqual(
880 ET.tostring(elem, encoding='utf8', xml_declaration=True),
881 b"<?xml version='1.0' encoding='utf8'?>\n<body><tag /></body>"
882 )
883
884 def test_tostring_xml_declaration_unicode_encoding(self):
885 elem = ET.XML('<body><tag/></body>')
886 self.assertEqual(
887 ET.tostring(elem, encoding='unicode', xml_declaration=True),
888 "<?xml version='1.0' encoding='utf-8'?>\n<body><tag /></body>"
889 )
890
891 def test_tostring_xml_declaration_cases(self):
892 elem = ET.XML('<body><tag>ø</tag></body>')
893 TESTCASES = [
894 # (expected_retval, encoding, xml_declaration)
895 # ... xml_declaration = None
896 (b'<body><tag>&#248;</tag></body>', None, None),
897 (b'<body><tag>\xc3\xb8</tag></body>', 'UTF-8', None),
898 (b'<body><tag>&#248;</tag></body>', 'US-ASCII', None),
899 (b"<?xml version='1.0' encoding='ISO-8859-1'?>\n"
900 b"<body><tag>\xf8</tag></body>", 'ISO-8859-1', None),
901 ('<body><tag>ø</tag></body>', 'unicode', None),
902
903 # ... xml_declaration = False
904 (b"<body><tag>&#248;</tag></body>", None, False),
905 (b"<body><tag>\xc3\xb8</tag></body>", 'UTF-8', False),
906 (b"<body><tag>&#248;</tag></body>", 'US-ASCII', False),
907 (b"<body><tag>\xf8</tag></body>", 'ISO-8859-1', False),
908 ("<body><tag>ø</tag></body>", 'unicode', False),
909
910 # ... xml_declaration = True
911 (b"<?xml version='1.0' encoding='us-ascii'?>\n"
912 b"<body><tag>&#248;</tag></body>", None, True),
913 (b"<?xml version='1.0' encoding='UTF-8'?>\n"
914 b"<body><tag>\xc3\xb8</tag></body>", 'UTF-8', True),
915 (b"<?xml version='1.0' encoding='US-ASCII'?>\n"
916 b"<body><tag>&#248;</tag></body>", 'US-ASCII', True),
917 (b"<?xml version='1.0' encoding='ISO-8859-1'?>\n"
918 b"<body><tag>\xf8</tag></body>", 'ISO-8859-1', True),
919 ("<?xml version='1.0' encoding='utf-8'?>\n"
920 "<body><tag>ø</tag></body>", 'unicode', True),
921
922 ]
923 for expected_retval, encoding, xml_declaration in TESTCASES:
924 with self.subTest(f'encoding={encoding} '
925 f'xml_declaration={xml_declaration}'):
926 self.assertEqual(
927 ET.tostring(
928 elem,
929 encoding=encoding,
930 xml_declaration=xml_declaration
931 ),
932 expected_retval
933 )
934
935 def test_tostringlist_default_namespace(self):
936 elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
937 self.assertEqual(
938 ''.join(ET.tostringlist(elem, encoding='unicode')),
939 '<ns0:body xmlns:ns0="http://effbot.org/ns"><ns0:tag /></ns0:body>'
940 )
941 self.assertEqual(
942 ''.join(ET.tostringlist(elem, encoding='unicode', default_namespace='http://effbot.org/ns')),
943 '<body xmlns="http://effbot.org/ns"><tag /></body>'
944 )
945
946 def test_tostringlist_xml_declaration(self):
947 elem = ET.XML('<body><tag/></body>')
948 self.assertEqual(
949 ''.join(ET.tostringlist(elem, encoding='unicode')),
950 '<body><tag /></body>'
951 )
952 self.assertEqual(
953 b''.join(ET.tostringlist(elem, xml_declaration=True)),
954 b"<?xml version='1.0' encoding='us-ascii'?>\n<body><tag /></body>"
955 )
956
957 stringlist = ET.tostringlist(elem, encoding='unicode', xml_declaration=True)
958 self.assertEqual(
959 ''.join(stringlist),
960 "<?xml version='1.0' encoding='utf-8'?>\n<body><tag /></body>"
961 )
962 self.assertRegex(stringlist[0], r"^<\?xml version='1.0' encoding='.+'?>")
963 self.assertEqual(['<body', '>', '<tag', ' />', '</body>'], stringlist[1:])
964
965 def test_encoding(self):
966 def check(encoding, body=''):
967 xml = ("<?xml version='1.0' encoding='%s'?><xml>%s</xml>" %
968 (encoding, body))
969 self.assertEqual(ET.XML(xml.encode(encoding)).text, body)
970 self.assertEqual(ET.XML(xml).text, body)
971 check("ascii", 'a')
972 check("us-ascii", 'a')
973 check("iso-8859-1", '\xbd')
974 check("iso-8859-15", '\u20ac')
975 check("cp437", '\u221a')
976 check("mac-roman", '\u02da')
977
978 def xml(encoding):
979 return "<?xml version='1.0' encoding='%s'?><xml />" % encoding
980 def bxml(encoding):
981 return xml(encoding).encode(encoding)
982 supported_encodings = [
983 'ascii', 'utf-8', 'utf-8-sig', 'utf-16', 'utf-16be', 'utf-16le',
984 'iso8859-1', 'iso8859-2', 'iso8859-3', 'iso8859-4', 'iso8859-5',
985 'iso8859-6', 'iso8859-7', 'iso8859-8', 'iso8859-9', 'iso8859-10',
986 'iso8859-13', 'iso8859-14', 'iso8859-15', 'iso8859-16',
987 'cp437', 'cp720', 'cp737', 'cp775', 'cp850', 'cp852',
988 'cp855', 'cp856', 'cp857', 'cp858', 'cp860', 'cp861', 'cp862',
989 'cp863', 'cp865', 'cp866', 'cp869', 'cp874', 'cp1006', 'cp1125',
990 'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
991 'cp1256', 'cp1257', 'cp1258',
992 'mac-cyrillic', 'mac-greek', 'mac-iceland', 'mac-latin2',
993 'mac-roman', 'mac-turkish',
994 'iso2022-jp', 'iso2022-jp-1', 'iso2022-jp-2', 'iso2022-jp-2004',
995 'iso2022-jp-3', 'iso2022-jp-ext',
996 'koi8-r', 'koi8-t', 'koi8-u', 'kz1048',
997 'hz', 'ptcp154',
998 ]
999 for encoding in supported_encodings:
1000 self.assertEqual(ET.tostring(ET.XML(bxml(encoding))), b'<xml />')
1001
1002 unsupported_ascii_compatible_encodings = [
1003 'big5', 'big5hkscs',
1004 'cp932', 'cp949', 'cp950',
1005 'euc-jp', 'euc-jis-2004', 'euc-jisx0213', 'euc-kr',
1006 'gb2312', 'gbk', 'gb18030',
1007 'iso2022-kr', 'johab',
1008 'shift-jis', 'shift-jis-2004', 'shift-jisx0213',
1009 'utf-7',
1010 ]
1011 for encoding in unsupported_ascii_compatible_encodings:
1012 self.assertRaises(ValueError, ET.XML, bxml(encoding))
1013
1014 unsupported_ascii_incompatible_encodings = [
1015 'cp037', 'cp424', 'cp500', 'cp864', 'cp875', 'cp1026', 'cp1140',
1016 'utf_32', 'utf_32_be', 'utf_32_le',
1017 ]
1018 for encoding in unsupported_ascii_incompatible_encodings:
1019 self.assertRaises(ET.ParseError, ET.XML, bxml(encoding))
1020
1021 self.assertRaises(ValueError, ET.XML, xml('undefined').encode('ascii'))
1022 self.assertRaises(LookupError, ET.XML, xml('xxx').encode('ascii'))
1023
1024 def test_methods(self):
1025 # Test serialization methods.
1026
1027 e = ET.XML("<html><link/><script>1 &lt; 2</script></html>")
1028 e.tail = "\n"
1029 self.assertEqual(serialize(e),
1030 '<html><link /><script>1 &lt; 2</script></html>\n')
1031 self.assertEqual(serialize(e, method=None),
1032 '<html><link /><script>1 &lt; 2</script></html>\n')
1033 self.assertEqual(serialize(e, method="xml"),
1034 '<html><link /><script>1 &lt; 2</script></html>\n')
1035 self.assertEqual(serialize(e, method="html"),
1036 '<html><link><script>1 < 2</script></html>\n')
1037 self.assertEqual(serialize(e, method="text"), '1 < 2\n')
1038
1039 def test_issue18347(self):
1040 e = ET.XML('<html><CamelCase>text</CamelCase></html>')
1041 self.assertEqual(serialize(e),
1042 '<html><CamelCase>text</CamelCase></html>')
1043 self.assertEqual(serialize(e, method="html"),
1044 '<html><CamelCase>text</CamelCase></html>')
1045
1046 def test_entity(self):
1047 # Test entity handling.
1048
1049 # 1) good entities
1050
1051 e = ET.XML("<document title='&#x8230;'>test</document>")
1052 self.assertEqual(serialize(e, encoding="us-ascii"),
1053 b'<document title="&#33328;">test</document>')
1054 self.serialize_check(e, '<document title="\u8230">test</document>')
1055
1056 # 2) bad entities
1057
1058 with self.assertRaises(ET.ParseError) as cm:
1059 ET.XML("<document>&entity;</document>")
1060 self.assertEqual(str(cm.exception),
1061 'undefined entity: line 1, column 10')
1062
1063 with self.assertRaises(ET.ParseError) as cm:
1064 ET.XML(ENTITY_XML)
1065 self.assertEqual(str(cm.exception),
1066 'undefined entity &entity;: line 5, column 10')
1067
1068 # 3) custom entity
1069
1070 parser = ET.XMLParser()
1071 parser.entity["entity"] = "text"
1072 parser.feed(ENTITY_XML)
1073 root = parser.close()
1074 self.serialize_check(root, '<document>text</document>')
1075
1076 # 4) external (SYSTEM) entity
1077
1078 with self.assertRaises(ET.ParseError) as cm:
1079 ET.XML(EXTERNAL_ENTITY_XML)
1080 self.assertEqual(str(cm.exception),
1081 'undefined entity &entity;: line 4, column 10')
1082
1083 def test_namespace(self):
1084 # Test namespace issues.
1085
1086 # 1) xml namespace
1087
1088 elem = ET.XML("<tag xml:lang='en' />")
1089 self.serialize_check(elem, '<tag xml:lang="en" />') # 1.1
1090
1091 # 2) other "well-known" namespaces
1092
1093 elem = ET.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")
1094 self.serialize_check(elem,
1095 '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" />') # 2.1
1096
1097 elem = ET.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")
1098 self.serialize_check(elem,
1099 '<html:html xmlns:html="http://www.w3.org/1999/xhtml" />') # 2.2
1100
1101 elem = ET.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")
1102 self.serialize_check(elem,
1103 '<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope" />') # 2.3
1104
1105 # 3) unknown namespaces
1106 elem = ET.XML(SAMPLE_XML_NS)
1107 self.serialize_check(elem,
1108 '<ns0:body xmlns:ns0="http://effbot.org/ns">\n'
1109 ' <ns0:tag>text</ns0:tag>\n'
1110 ' <ns0:tag />\n'
1111 ' <ns0:section>\n'
1112 ' <ns0:tag>subtext</ns0:tag>\n'
1113 ' </ns0:section>\n'
1114 '</ns0:body>')
1115
1116 def test_qname(self):
1117 # Test QName handling.
1118
1119 # 1) decorated tags
1120
1121 elem = ET.Element("{uri}tag")
1122 self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.1
1123 elem = ET.Element(ET.QName("{uri}tag"))
1124 self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.2
1125 elem = ET.Element(ET.QName("uri", "tag"))
1126 self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.3
1127 elem = ET.Element(ET.QName("uri", "tag"))
1128 subelem = ET.SubElement(elem, ET.QName("uri", "tag1"))
1129 subelem = ET.SubElement(elem, ET.QName("uri", "tag2"))
1130 self.serialize_check(elem,
1131 '<ns0:tag xmlns:ns0="uri"><ns0:tag1 /><ns0:tag2 /></ns0:tag>') # 1.4
1132
1133 # 2) decorated attributes
1134
1135 elem.clear()
1136 elem.attrib["{uri}key"] = "value"
1137 self.serialize_check(elem,
1138 '<ns0:tag xmlns:ns0="uri" ns0:key="value" />') # 2.1
1139
1140 elem.clear()
1141 elem.attrib[ET.QName("{uri}key")] = "value"
1142 self.serialize_check(elem,
1143 '<ns0:tag xmlns:ns0="uri" ns0:key="value" />') # 2.2
1144
1145 # 3) decorated values are not converted by default, but the
1146 # QName wrapper can be used for values
1147
1148 elem.clear()
1149 elem.attrib["{uri}key"] = "{uri}value"
1150 self.serialize_check(elem,
1151 '<ns0:tag xmlns:ns0="uri" ns0:key="{uri}value" />') # 3.1
1152
1153 elem.clear()
1154 elem.attrib["{uri}key"] = ET.QName("{uri}value")
1155 self.serialize_check(elem,
1156 '<ns0:tag xmlns:ns0="uri" ns0:key="ns0:value" />') # 3.2
1157
1158 elem.clear()
1159 subelem = ET.Element("tag")
1160 subelem.attrib["{uri1}key"] = ET.QName("{uri2}value")
1161 elem.append(subelem)
1162 elem.append(subelem)
1163 self.serialize_check(elem,
1164 '<ns0:tag xmlns:ns0="uri" xmlns:ns1="uri1" xmlns:ns2="uri2">'
1165 '<tag ns1:key="ns2:value" />'
1166 '<tag ns1:key="ns2:value" />'
1167 '</ns0:tag>') # 3.3
1168
1169 # 4) Direct QName tests
1170
1171 self.assertEqual(str(ET.QName('ns', 'tag')), '{ns}tag')
1172 self.assertEqual(str(ET.QName('{ns}tag')), '{ns}tag')
1173 q1 = ET.QName('ns', 'tag')
1174 q2 = ET.QName('ns', 'tag')
1175 self.assertEqual(q1, q2)
1176 q2 = ET.QName('ns', 'other-tag')
1177 self.assertNotEqual(q1, q2)
1178 self.assertNotEqual(q1, 'ns:tag')
1179 self.assertEqual(q1, '{ns}tag')
1180
1181 def test_doctype_public(self):
1182 # Test PUBLIC doctype.
1183
1184 elem = ET.XML('<!DOCTYPE html PUBLIC'
1185 ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
1186 ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
1187 '<html>text</html>')
1188
1189 def test_xpath_tokenizer(self):
1190 # Test the XPath tokenizer.
1191 from xml.etree import ElementPath
1192 def check(p, expected, namespaces=None):
1193 self.assertEqual([op or tag
1194 for op, tag in ElementPath.xpath_tokenizer(p, namespaces)],
1195 expected)
1196
1197 # tests from the xml specification
1198 check("*", ['*'])
1199 check("text()", ['text', '()'])
1200 check("@name", ['@', 'name'])
1201 check("@*", ['@', '*'])
1202 check("para[1]", ['para', '[', '1', ']'])
1203 check("para[last()]", ['para', '[', 'last', '()', ']'])
1204 check("*/para", ['*', '/', 'para'])
1205 check("/doc/chapter[5]/section[2]",
1206 ['/', 'doc', '/', 'chapter', '[', '5', ']',
1207 '/', 'section', '[', '2', ']'])
1208 check("chapter//para", ['chapter', '//', 'para'])
1209 check("//para", ['//', 'para'])
1210 check("//olist/item", ['//', 'olist', '/', 'item'])
1211 check(".", ['.'])
1212 check(".//para", ['.', '//', 'para'])
1213 check("..", ['..'])
1214 check("../@lang", ['..', '/', '@', 'lang'])
1215 check("chapter[title]", ['chapter', '[', 'title', ']'])
1216 check("employee[@secretary and @assistant]", ['employee',
1217 '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']'])
1218
1219 # additional tests
1220 check("@{ns}attr", ['@', '{ns}attr'])
1221 check("{http://spam}egg", ['{http://spam}egg'])
1222 check("./spam.egg", ['.', '/', 'spam.egg'])
1223 check(".//{http://spam}egg", ['.', '//', '{http://spam}egg'])
1224
1225 # wildcard tags
1226 check("{ns}*", ['{ns}*'])
1227 check("{}*", ['{}*'])
1228 check("{*}tag", ['{*}tag'])
1229 check("{*}*", ['{*}*'])
1230 check(".//{*}tag", ['.', '//', '{*}tag'])
1231
1232 # namespace prefix resolution
1233 check("./xsd:type", ['.', '/', '{http://www.w3.org/2001/XMLSchema}type'],
1234 {'xsd': 'http://www.w3.org/2001/XMLSchema'})
1235 check("type", ['{http://www.w3.org/2001/XMLSchema}type'],
1236 {'': 'http://www.w3.org/2001/XMLSchema'})
1237 check("@xsd:type", ['@', '{http://www.w3.org/2001/XMLSchema}type'],
1238 {'xsd': 'http://www.w3.org/2001/XMLSchema'})
1239 check("@type", ['@', 'type'],
1240 {'': 'http://www.w3.org/2001/XMLSchema'})
1241 check("@{*}type", ['@', '{*}type'],
1242 {'': 'http://www.w3.org/2001/XMLSchema'})
1243 check("@{ns}attr", ['@', '{ns}attr'],
1244 {'': 'http://www.w3.org/2001/XMLSchema',
1245 'ns': 'http://www.w3.org/2001/XMLSchema'})
1246
1247 def test_processinginstruction(self):
1248 # Test ProcessingInstruction directly
1249
1250 self.assertEqual(ET.tostring(ET.ProcessingInstruction('test', 'instruction')),
1251 b'<?test instruction?>')
1252 self.assertEqual(ET.tostring(ET.PI('test', 'instruction')),
1253 b'<?test instruction?>')
1254
1255 # Issue #2746
1256
1257 self.assertEqual(ET.tostring(ET.PI('test', '<testing&>')),
1258 b'<?test <testing&>?>')
1259 self.assertEqual(ET.tostring(ET.PI('test', '<testing&>\xe3'), 'latin-1'),
1260 b"<?xml version='1.0' encoding='latin-1'?>\n"
1261 b"<?test <testing&>\xe3?>")
1262
1263 def test_html_empty_elems_serialization(self):
1264 # issue 15970
1265 # from http://www.w3.org/TR/html401/index/elements.html
1266 for element in ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'EMBED', 'FRAME',
1267 'HR', 'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM',
1268 'SOURCE', 'TRACK', 'WBR']:
1269 for elem in [element, element.lower()]:
1270 expected = '<%s>' % elem
1271 serialized = serialize(ET.XML('<%s />' % elem), method='html')
1272 self.assertEqual(serialized, expected)
1273 serialized = serialize(ET.XML('<%s></%s>' % (elem,elem)),
1274 method='html')
1275 self.assertEqual(serialized, expected)
1276
1277 def test_dump_attribute_order(self):
1278 # See BPO 34160
1279 e = ET.Element('cirriculum', status='public', company='example')
1280 with support.captured_stdout() as stdout:
1281 ET.dump(e)
1282 self.assertEqual(stdout.getvalue(),
1283 '<cirriculum status="public" company="example" />\n')
1284
1285 def test_tree_write_attribute_order(self):
1286 # See BPO 34160
1287 root = ET.Element('cirriculum', status='public', company='example')
1288 self.assertEqual(serialize(root),
1289 '<cirriculum status="public" company="example" />')
1290 self.assertEqual(serialize(root, method='html'),
1291 '<cirriculum status="public" company="example"></cirriculum>')
1292
1293 def test_attlist_default(self):
1294 # Test default attribute values; See BPO 42151.
1295 root = ET.fromstring(ATTLIST_XML)
1296 self.assertEqual(root[0].attrib,
1297 {'{http://www.w3.org/XML/1998/namespace}lang': 'eng'})
1298
1299
1300 class IterparseTest(unittest.TestCase):
1301 # Test iterparse interface.
1302
1303 def test_basic(self):
1304 iterparse = ET.iterparse
1305
1306 it = iterparse(SIMPLE_XMLFILE)
1307 self.assertIsNone(it.root)
1308 action, elem = next(it)
1309 self.assertIsNone(it.root)
1310 self.assertEqual((action, elem.tag), ('end', 'element'))
1311 self.assertEqual([(action, elem.tag) for action, elem in it], [
1312 ('end', 'element'),
1313 ('end', 'empty-element'),
1314 ('end', 'root'),
1315 ])
1316 self.assertEqual(it.root.tag, 'root')
1317 it.close()
1318
1319 it = iterparse(SIMPLE_NS_XMLFILE)
1320 self.assertEqual([(action, elem.tag) for action, elem in it], [
1321 ('end', '{namespace}element'),
1322 ('end', '{namespace}element'),
1323 ('end', '{namespace}empty-element'),
1324 ('end', '{namespace}root'),
1325 ])
1326 it.close()
1327
1328 def test_external_file(self):
1329 with open(SIMPLE_XMLFILE, 'rb') as source:
1330 it = ET.iterparse(source)
1331 action, elem = next(it)
1332 self.assertEqual((action, elem.tag), ('end', 'element'))
1333 self.assertEqual([(action, elem.tag) for action, elem in it], [
1334 ('end', 'element'),
1335 ('end', 'empty-element'),
1336 ('end', 'root'),
1337 ])
1338 self.assertEqual(it.root.tag, 'root')
1339
1340 def test_events(self):
1341 iterparse = ET.iterparse
1342
1343 events = ()
1344 it = iterparse(SIMPLE_XMLFILE, events)
1345 self.assertEqual([(action, elem.tag) for action, elem in it], [])
1346 it.close()
1347
1348 events = ()
1349 it = iterparse(SIMPLE_XMLFILE, events=events)
1350 self.assertEqual([(action, elem.tag) for action, elem in it], [])
1351 it.close()
1352
1353 events = ("start", "end")
1354 it = iterparse(SIMPLE_XMLFILE, events)
1355 self.assertEqual([(action, elem.tag) for action, elem in it], [
1356 ('start', 'root'),
1357 ('start', 'element'),
1358 ('end', 'element'),
1359 ('start', 'element'),
1360 ('end', 'element'),
1361 ('start', 'empty-element'),
1362 ('end', 'empty-element'),
1363 ('end', 'root'),
1364 ])
1365 it.close()
1366
1367 def test_namespace_events(self):
1368 iterparse = ET.iterparse
1369
1370 events = ("start", "end", "start-ns", "end-ns")
1371 it = iterparse(SIMPLE_NS_XMLFILE, events)
1372 self.assertEqual([(action, elem.tag) if action in ("start", "end")
1373 else (action, elem)
1374 for action, elem in it], [
1375 ('start-ns', ('', 'namespace')),
1376 ('start', '{namespace}root'),
1377 ('start', '{namespace}element'),
1378 ('end', '{namespace}element'),
1379 ('start', '{namespace}element'),
1380 ('end', '{namespace}element'),
1381 ('start', '{namespace}empty-element'),
1382 ('end', '{namespace}empty-element'),
1383 ('end', '{namespace}root'),
1384 ('end-ns', None),
1385 ])
1386 it.close()
1387
1388 events = ('start-ns', 'end-ns')
1389 it = iterparse(io.BytesIO(br"<root xmlns=''/>"), events)
1390 res = [action for action, elem in it]
1391 self.assertEqual(res, ['start-ns', 'end-ns'])
1392 it.close()
1393
1394 def test_unknown_events(self):
1395 iterparse = ET.iterparse
1396
1397 events = ("start", "end", "bogus")
1398 with open(SIMPLE_XMLFILE, "rb") as f:
1399 with self.assertRaises(ValueError) as cm:
1400 iterparse(f, events)
1401 self.assertFalse(f.closed)
1402 self.assertEqual(str(cm.exception), "unknown event 'bogus'")
1403
1404 with warnings_helper.check_no_resource_warning(self):
1405 with self.assertRaises(ValueError) as cm:
1406 iterparse(SIMPLE_XMLFILE, events)
1407 self.assertEqual(str(cm.exception), "unknown event 'bogus'")
1408 del cm
1409 gc_collect()
1410
1411 def test_non_utf8(self):
1412 source = io.BytesIO(
1413 b"<?xml version='1.0' encoding='iso-8859-1'?>\n"
1414 b"<body xmlns='http://&#233;ffbot.org/ns'\n"
1415 b" xmlns:cl\xe9='http://effbot.org/ns'>text</body>\n")
1416 events = ("start-ns",)
1417 it = ET.iterparse(source, events)
1418 self.assertEqual([(action, elem) for action, elem in it], [
1419 ('start-ns', ('', 'http://\xe9ffbot.org/ns')),
1420 ('start-ns', ('cl\xe9', 'http://effbot.org/ns')),
1421 ])
1422
1423 def test_parsing_error(self):
1424 source = io.BytesIO(b"<document />junk")
1425 it = ET.iterparse(source)
1426 action, elem = next(it)
1427 self.assertEqual((action, elem.tag), ('end', 'document'))
1428 with self.assertRaises(ET.ParseError) as cm:
1429 next(it)
1430 self.assertEqual(str(cm.exception),
1431 'junk after document element: line 1, column 12')
1432
1433 def test_nonexistent_file(self):
1434 with self.assertRaises(FileNotFoundError):
1435 ET.iterparse("nonexistent")
1436
1437 def test_resource_warnings_not_exhausted(self):
1438 # Not exhausting the iterator still closes the underlying file (bpo-43292)
1439 it = ET.iterparse(SIMPLE_XMLFILE)
1440 with warnings_helper.check_no_resource_warning(self):
1441 del it
1442 gc_collect()
1443
1444 it = ET.iterparse(SIMPLE_XMLFILE)
1445 with warnings_helper.check_no_resource_warning(self):
1446 action, elem = next(it)
1447 self.assertEqual((action, elem.tag), ('end', 'element'))
1448 del it, elem
1449 gc_collect()
1450
1451 def test_resource_warnings_failed_iteration(self):
1452 self.addCleanup(os_helper.unlink, TESTFN)
1453 with open(TESTFN, "wb") as f:
1454 f.write(b"<document />junk")
1455
1456 it = ET.iterparse(TESTFN)
1457 action, elem = next(it)
1458 self.assertEqual((action, elem.tag), ('end', 'document'))
1459 with warnings_helper.check_no_resource_warning(self):
1460 with self.assertRaises(ET.ParseError) as cm:
1461 next(it)
1462 self.assertEqual(str(cm.exception),
1463 'junk after document element: line 1, column 12')
1464 del cm, it
1465 gc_collect()
1466
1467 def test_resource_warnings_exhausted(self):
1468 it = ET.iterparse(SIMPLE_XMLFILE)
1469 with warnings_helper.check_no_resource_warning(self):
1470 list(it)
1471 del it
1472 gc_collect()
1473
1474 def test_close_not_exhausted(self):
1475 iterparse = ET.iterparse
1476
1477 it = iterparse(SIMPLE_XMLFILE)
1478 it.close()
1479 with self.assertRaises(StopIteration):
1480 next(it)
1481 it.close() # idempotent
1482
1483 with open(SIMPLE_XMLFILE, 'rb') as source:
1484 it = iterparse(source)
1485 it.close()
1486 self.assertFalse(source.closed)
1487 with self.assertRaises(StopIteration):
1488 next(it)
1489 it.close() # idempotent
1490
1491 it = iterparse(SIMPLE_XMLFILE)
1492 action, elem = next(it)
1493 self.assertEqual((action, elem.tag), ('end', 'element'))
1494 it.close()
1495 with self.assertRaises(StopIteration):
1496 next(it)
1497 it.close() # idempotent
1498
1499 with open(SIMPLE_XMLFILE, 'rb') as source:
1500 it = iterparse(source)
1501 action, elem = next(it)
1502 self.assertEqual((action, elem.tag), ('end', 'element'))
1503 it.close()
1504 self.assertFalse(source.closed)
1505 with self.assertRaises(StopIteration):
1506 next(it)
1507 it.close() # idempotent
1508
1509 def test_close_exhausted(self):
1510 iterparse = ET.iterparse
1511 it = iterparse(SIMPLE_XMLFILE)
1512 list(it)
1513 it.close()
1514 with self.assertRaises(StopIteration):
1515 next(it)
1516 it.close() # idempotent
1517
1518 with open(SIMPLE_XMLFILE, 'rb') as source:
1519 it = iterparse(source)
1520 list(it)
1521 it.close()
1522 self.assertFalse(source.closed)
1523 with self.assertRaises(StopIteration):
1524 next(it)
1525 it.close() # idempotent
1526
1527
1528 class XMLPullParserTest(unittest.TestCase):
1529
1530 def _feed(self, parser, data, chunk_size=None, flush=False):
1531 if chunk_size is None:
1532 parser.feed(data)
1533 else:
1534 for i in range(0, len(data), chunk_size):
1535 parser.feed(data[i:i+chunk_size])
1536 if flush:
1537 parser.flush()
1538
1539 def assert_events(self, parser, expected, max_events=None):
1540 self.assertEqual(
1541 [(event, (elem.tag, elem.text))
1542 for event, elem in islice(parser.read_events(), max_events)],
1543 expected)
1544
1545 def assert_event_tuples(self, parser, expected, max_events=None):
1546 self.assertEqual(
1547 list(islice(parser.read_events(), max_events)),
1548 expected)
1549
1550 def assert_event_tags(self, parser, expected, max_events=None):
1551 events = islice(parser.read_events(), max_events)
1552 self.assertEqual([(action, elem.tag) for action, elem in events],
1553 expected)
1554
1555 def test_simple_xml(self, chunk_size=None, flush=False):
1556 parser = ET.XMLPullParser()
1557 self.assert_event_tags(parser, [])
1558 self._feed(parser, "<!-- comment -->\n", chunk_size, flush)
1559 self.assert_event_tags(parser, [])
1560 self._feed(parser,
1561 "<root>\n <element key='value'>text</element",
1562 chunk_size, flush)
1563 self.assert_event_tags(parser, [])
1564 self._feed(parser, ">\n", chunk_size, flush)
1565 self.assert_event_tags(parser, [('end', 'element')])
1566 self._feed(parser, "<element>text</element>tail\n", chunk_size, flush)
1567 self._feed(parser, "<empty-element/>\n", chunk_size, flush)
1568 self.assert_event_tags(parser, [
1569 ('end', 'element'),
1570 ('end', 'empty-element'),
1571 ])
1572 self._feed(parser, "</root>\n", chunk_size, flush)
1573 self.assert_event_tags(parser, [('end', 'root')])
1574 self.assertIsNone(parser.close())
1575
1576 def test_simple_xml_chunk_1(self):
1577 self.test_simple_xml(chunk_size=1, flush=True)
1578
1579 def test_simple_xml_chunk_5(self):
1580 self.test_simple_xml(chunk_size=5, flush=True)
1581
1582 def test_simple_xml_chunk_22(self):
1583 self.test_simple_xml(chunk_size=22)
1584
1585 def test_feed_while_iterating(self):
1586 parser = ET.XMLPullParser()
1587 it = parser.read_events()
1588 self._feed(parser, "<root>\n <element key='value'>text</element>\n")
1589 action, elem = next(it)
1590 self.assertEqual((action, elem.tag), ('end', 'element'))
1591 self._feed(parser, "</root>\n")
1592 action, elem = next(it)
1593 self.assertEqual((action, elem.tag), ('end', 'root'))
1594 with self.assertRaises(StopIteration):
1595 next(it)
1596
1597 def test_simple_xml_with_ns(self):
1598 parser = ET.XMLPullParser()
1599 self.assert_event_tags(parser, [])
1600 self._feed(parser, "<!-- comment -->\n")
1601 self.assert_event_tags(parser, [])
1602 self._feed(parser, "<root xmlns='namespace'>\n")
1603 self.assert_event_tags(parser, [])
1604 self._feed(parser, "<element key='value'>text</element")
1605 self.assert_event_tags(parser, [])
1606 self._feed(parser, ">\n")
1607 self.assert_event_tags(parser, [('end', '{namespace}element')])
1608 self._feed(parser, "<element>text</element>tail\n")
1609 self._feed(parser, "<empty-element/>\n")
1610 self.assert_event_tags(parser, [
1611 ('end', '{namespace}element'),
1612 ('end', '{namespace}empty-element'),
1613 ])
1614 self._feed(parser, "</root>\n")
1615 self.assert_event_tags(parser, [('end', '{namespace}root')])
1616 self.assertIsNone(parser.close())
1617
1618 def test_ns_events(self):
1619 parser = ET.XMLPullParser(events=('start-ns', 'end-ns'))
1620 self._feed(parser, "<!-- comment -->\n")
1621 self._feed(parser, "<root xmlns='namespace'>\n")
1622 self.assertEqual(
1623 list(parser.read_events()),
1624 [('start-ns', ('', 'namespace'))])
1625 self._feed(parser, "<element key='value'>text</element")
1626 self._feed(parser, ">\n")
1627 self._feed(parser, "<element>text</element>tail\n")
1628 self._feed(parser, "<empty-element/>\n")
1629 self._feed(parser, "</root>\n")
1630 self.assertEqual(list(parser.read_events()), [('end-ns', None)])
1631 self.assertIsNone(parser.close())
1632
1633 def test_ns_events_start(self):
1634 parser = ET.XMLPullParser(events=('start-ns', 'start', 'end'))
1635 self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
1636 self.assert_event_tuples(parser, [
1637 ('start-ns', ('', 'abc')),
1638 ('start-ns', ('p', 'xyz')),
1639 ], max_events=2)
1640 self.assert_event_tags(parser, [
1641 ('start', '{abc}tag'),
1642 ], max_events=1)
1643
1644 self._feed(parser, "<child />\n")
1645 self.assert_event_tags(parser, [
1646 ('start', '{abc}child'),
1647 ('end', '{abc}child'),
1648 ])
1649
1650 self._feed(parser, "</tag>\n")
1651 parser.close()
1652 self.assert_event_tags(parser, [
1653 ('end', '{abc}tag'),
1654 ])
1655
1656 def test_ns_events_start_end(self):
1657 parser = ET.XMLPullParser(events=('start-ns', 'start', 'end', 'end-ns'))
1658 self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
1659 self.assert_event_tuples(parser, [
1660 ('start-ns', ('', 'abc')),
1661 ('start-ns', ('p', 'xyz')),
1662 ], max_events=2)
1663 self.assert_event_tags(parser, [
1664 ('start', '{abc}tag'),
1665 ], max_events=1)
1666
1667 self._feed(parser, "<child />\n")
1668 self.assert_event_tags(parser, [
1669 ('start', '{abc}child'),
1670 ('end', '{abc}child'),
1671 ])
1672
1673 self._feed(parser, "</tag>\n")
1674 parser.close()
1675 self.assert_event_tags(parser, [
1676 ('end', '{abc}tag'),
1677 ], max_events=1)
1678 self.assert_event_tuples(parser, [
1679 ('end-ns', None),
1680 ('end-ns', None),
1681 ])
1682
1683 def test_events(self):
1684 parser = ET.XMLPullParser(events=())
1685 self._feed(parser, "<root/>\n")
1686 self.assert_event_tags(parser, [])
1687
1688 parser = ET.XMLPullParser(events=('start', 'end'))
1689 self._feed(parser, "<!-- text here -->\n")
1690 self.assert_events(parser, [])
1691
1692 parser = ET.XMLPullParser(events=('start', 'end'))
1693 self._feed(parser, "<root>\n")
1694 self.assert_event_tags(parser, [('start', 'root')])
1695 self._feed(parser, "<element key='value'>text</element")
1696 self.assert_event_tags(parser, [('start', 'element')])
1697 self._feed(parser, ">\n")
1698 self.assert_event_tags(parser, [('end', 'element')])
1699 self._feed(parser,
1700 "<element xmlns='foo'>text<empty-element/></element>tail\n")
1701 self.assert_event_tags(parser, [
1702 ('start', '{foo}element'),
1703 ('start', '{foo}empty-element'),
1704 ('end', '{foo}empty-element'),
1705 ('end', '{foo}element'),
1706 ])
1707 self._feed(parser, "</root>")
1708 self.assertIsNone(parser.close())
1709 self.assert_event_tags(parser, [('end', 'root')])
1710
1711 parser = ET.XMLPullParser(events=('start',))
1712 self._feed(parser, "<!-- comment -->\n")
1713 self.assert_event_tags(parser, [])
1714 self._feed(parser, "<root>\n")
1715 self.assert_event_tags(parser, [('start', 'root')])
1716 self._feed(parser, "<element key='value'>text</element")
1717 self.assert_event_tags(parser, [('start', 'element')])
1718 self._feed(parser, ">\n")
1719 self.assert_event_tags(parser, [])
1720 self._feed(parser,
1721 "<element xmlns='foo'>text<empty-element/></element>tail\n")
1722 self.assert_event_tags(parser, [
1723 ('start', '{foo}element'),
1724 ('start', '{foo}empty-element'),
1725 ])
1726 self._feed(parser, "</root>")
1727 self.assertIsNone(parser.close())
1728
1729 def test_events_comment(self):
1730 parser = ET.XMLPullParser(events=('start', 'comment', 'end'))
1731 self._feed(parser, "<!-- text here -->\n")
1732 self.assert_events(parser, [('comment', (ET.Comment, ' text here '))])
1733 self._feed(parser, "<!-- more text here -->\n")
1734 self.assert_events(parser, [('comment', (ET.Comment, ' more text here '))])
1735 self._feed(parser, "<root-tag>text")
1736 self.assert_event_tags(parser, [('start', 'root-tag')])
1737 self._feed(parser, "<!-- inner comment-->\n")
1738 self.assert_events(parser, [('comment', (ET.Comment, ' inner comment'))])
1739 self._feed(parser, "</root-tag>\n")
1740 self.assert_event_tags(parser, [('end', 'root-tag')])
1741 self._feed(parser, "<!-- outer comment -->\n")
1742 self.assert_events(parser, [('comment', (ET.Comment, ' outer comment '))])
1743
1744 parser = ET.XMLPullParser(events=('comment',))
1745 self._feed(parser, "<!-- text here -->\n")
1746 self.assert_events(parser, [('comment', (ET.Comment, ' text here '))])
1747
1748 def test_events_pi(self):
1749 parser = ET.XMLPullParser(events=('start', 'pi', 'end'))
1750 self._feed(parser, "<?pitarget?>\n")
1751 self.assert_events(parser, [('pi', (ET.PI, 'pitarget'))])
1752 parser = ET.XMLPullParser(events=('pi',))
1753 self._feed(parser, "<?pitarget some text ?>\n")
1754 self.assert_events(parser, [('pi', (ET.PI, 'pitarget some text '))])
1755
1756 def test_events_sequence(self):
1757 # Test that events can be some sequence that's not just a tuple or list
1758 eventset = {'end', 'start'}
1759 parser = ET.XMLPullParser(events=eventset)
1760 self._feed(parser, "<foo>bar</foo>")
1761 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
1762
1763 class DummyIter:
1764 def __init__(self):
1765 self.events = iter(['start', 'end', 'start-ns'])
1766 def __iter__(self):
1767 return self
1768 def __next__(self):
1769 return next(self.events)
1770
1771 parser = ET.XMLPullParser(events=DummyIter())
1772 self._feed(parser, "<foo>bar</foo>")
1773 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
1774
1775 def test_unknown_event(self):
1776 with self.assertRaises(ValueError):
1777 ET.XMLPullParser(events=('start', 'end', 'bogus'))
1778 with self.assertRaisesRegex(ValueError, "unknown event 'bogus'"):
1779 ET.XMLPullParser(events=(x.decode() for x in (b'start', b'end', b'bogus')))
1780
1781 @unittest.skipIf(pyexpat.version_info < (2, 6, 0),
1782 f'Expat {pyexpat.version_info} does not '
1783 'support reparse deferral')
1784 def test_flush_reparse_deferral_enabled(self):
1785 parser = ET.XMLPullParser(events=('start', 'end'))
1786
1787 for chunk in ("<doc", ">"):
1788 parser.feed(chunk)
1789
1790 self.assert_event_tags(parser, []) # i.e. no elements started
1791 if ET is pyET:
1792 self.assertTrue(parser._parser._parser.GetReparseDeferralEnabled())
1793
1794 parser.flush()
1795
1796 self.assert_event_tags(parser, [('start', 'doc')])
1797 if ET is pyET:
1798 self.assertTrue(parser._parser._parser.GetReparseDeferralEnabled())
1799
1800 parser.feed("</doc>")
1801 parser.close()
1802
1803 self.assert_event_tags(parser, [('end', 'doc')])
1804
1805 def test_flush_reparse_deferral_disabled(self):
1806 parser = ET.XMLPullParser(events=('start', 'end'))
1807
1808 for chunk in ("<doc", ">"):
1809 parser.feed(chunk)
1810
1811 if pyexpat.version_info >= (2, 6, 0):
1812 if not ET is pyET:
1813 self.skipTest(f'XMLParser.(Get|Set)ReparseDeferralEnabled '
1814 'methods not available in C')
1815 parser._parser._parser.SetReparseDeferralEnabled(False)
1816 self.assert_event_tags(parser, []) # i.e. no elements started
1817
1818 if ET is pyET:
1819 self.assertFalse(parser._parser._parser.GetReparseDeferralEnabled())
1820
1821 parser.flush()
1822
1823 self.assert_event_tags(parser, [('start', 'doc')])
1824 if ET is pyET:
1825 self.assertFalse(parser._parser._parser.GetReparseDeferralEnabled())
1826
1827 parser.feed("</doc>")
1828 parser.close()
1829
1830 self.assert_event_tags(parser, [('end', 'doc')])
1831
1832 #
1833 # xinclude tests (samples from appendix C of the xinclude specification)
1834
1835 XINCLUDE = {}
1836
1837 XINCLUDE["C1.xml"] = """\
1838 <?xml version='1.0'?>
1839 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1840 <p>120 Mz is adequate for an average home user.</p>
1841 <xi:include href="disclaimer.xml"/>
1842 </document>
1843 """
1844
1845 XINCLUDE["disclaimer.xml"] = """\
1846 <?xml version='1.0'?>
1847 <disclaimer>
1848 <p>The opinions represented herein represent those of the individual
1849 and should not be interpreted as official policy endorsed by this
1850 organization.</p>
1851 </disclaimer>
1852 """
1853
1854 XINCLUDE["C2.xml"] = """\
1855 <?xml version='1.0'?>
1856 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1857 <p>This document has been accessed
1858 <xi:include href="count.txt" parse="text"/> times.</p>
1859 </document>
1860 """
1861
1862 XINCLUDE["count.txt"] = "324387"
1863
1864 XINCLUDE["C2b.xml"] = """\
1865 <?xml version='1.0'?>
1866 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1867 <p>This document has been <em>accessed</em>
1868 <xi:include href="count.txt" parse="text"/> times.</p>
1869 </document>
1870 """
1871
1872 XINCLUDE["C3.xml"] = """\
1873 <?xml version='1.0'?>
1874 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1875 <p>The following is the source of the "data.xml" resource:</p>
1876 <example><xi:include href="data.xml" parse="text"/></example>
1877 </document>
1878 """
1879
1880 XINCLUDE["data.xml"] = """\
1881 <?xml version='1.0'?>
1882 <data>
1883 <item><![CDATA[Brooks & Shields]]></item>
1884 </data>
1885 """
1886
1887 XINCLUDE["C5.xml"] = """\
1888 <?xml version='1.0'?>
1889 <div xmlns:xi="http://www.w3.org/2001/XInclude">
1890 <xi:include href="example.txt" parse="text">
1891 <xi:fallback>
1892 <xi:include href="fallback-example.txt" parse="text">
1893 <xi:fallback><a href="mailto:[email protected]">Report error</a></xi:fallback>
1894 </xi:include>
1895 </xi:fallback>
1896 </xi:include>
1897 </div>
1898 """
1899
1900 XINCLUDE["default.xml"] = """\
1901 <?xml version='1.0'?>
1902 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1903 <p>Example.</p>
1904 <xi:include href="{}"/>
1905 </document>
1906 """.format(html.escape(SIMPLE_XMLFILE, True))
1907
1908 XINCLUDE["include_c1_repeated.xml"] = """\
1909 <?xml version='1.0'?>
1910 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1911 <p>The following is the source code of Recursive1.xml:</p>
1912 <xi:include href="C1.xml"/>
1913 <xi:include href="C1.xml"/>
1914 <xi:include href="C1.xml"/>
1915 <xi:include href="C1.xml"/>
1916 </document>
1917 """
1918
1919 #
1920 # badly formatted xi:include tags
1921
1922 XINCLUDE_BAD = {}
1923
1924 XINCLUDE_BAD["B1.xml"] = """\
1925 <?xml version='1.0'?>
1926 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1927 <p>120 Mz is adequate for an average home user.</p>
1928 <xi:include href="disclaimer.xml" parse="BAD_TYPE"/>
1929 </document>
1930 """
1931
1932 XINCLUDE_BAD["B2.xml"] = """\
1933 <?xml version='1.0'?>
1934 <div xmlns:xi="http://www.w3.org/2001/XInclude">
1935 <xi:fallback></xi:fallback>
1936 </div>
1937 """
1938
1939 XINCLUDE["Recursive1.xml"] = """\
1940 <?xml version='1.0'?>
1941 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1942 <p>The following is the source code of Recursive2.xml:</p>
1943 <xi:include href="Recursive2.xml"/>
1944 </document>
1945 """
1946
1947 XINCLUDE["Recursive2.xml"] = """\
1948 <?xml version='1.0'?>
1949 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1950 <p>The following is the source code of Recursive3.xml:</p>
1951 <xi:include href="Recursive3.xml"/>
1952 </document>
1953 """
1954
1955 XINCLUDE["Recursive3.xml"] = """\
1956 <?xml version='1.0'?>
1957 <document xmlns:xi="http://www.w3.org/2001/XInclude">
1958 <p>The following is the source code of Recursive1.xml:</p>
1959 <xi:include href="Recursive1.xml"/>
1960 </document>
1961 """
1962
1963
1964 class XIncludeTest(unittest.TestCase):
1965
1966 def xinclude_loader(self, href, parse="xml", encoding=None):
1967 try:
1968 data = XINCLUDE[href]
1969 except KeyError:
1970 raise OSError("resource not found")
1971 if parse == "xml":
1972 data = ET.XML(data)
1973 return data
1974
1975 def none_loader(self, href, parser, encoding=None):
1976 return None
1977
1978 def _my_loader(self, href, parse):
1979 # Used to avoid a test-dependency problem where the default loader
1980 # of ElementInclude uses the pyET parser for cET tests.
1981 if parse == 'xml':
1982 with open(href, 'rb') as f:
1983 return ET.parse(f).getroot()
1984 else:
1985 return None
1986
1987 def test_xinclude_default(self):
1988 from xml.etree import ElementInclude
1989 doc = self.xinclude_loader('default.xml')
1990 ElementInclude.include(doc, self._my_loader)
1991 self.assertEqual(serialize(doc),
1992 '<document>\n'
1993 ' <p>Example.</p>\n'
1994 ' <root>\n'
1995 ' <element key="value">text</element>\n'
1996 ' <element>text</element>tail\n'
1997 ' <empty-element />\n'
1998 '</root>\n'
1999 '</document>')
2000
2001 def test_xinclude(self):
2002 from xml.etree import ElementInclude
2003
2004 # Basic inclusion example (XInclude C.1)
2005 document = self.xinclude_loader("C1.xml")
2006 ElementInclude.include(document, self.xinclude_loader)
2007 self.assertEqual(serialize(document),
2008 '<document>\n'
2009 ' <p>120 Mz is adequate for an average home user.</p>\n'
2010 ' <disclaimer>\n'
2011 ' <p>The opinions represented herein represent those of the individual\n'
2012 ' and should not be interpreted as official policy endorsed by this\n'
2013 ' organization.</p>\n'
2014 '</disclaimer>\n'
2015 '</document>') # C1
2016
2017 # Textual inclusion example (XInclude C.2)
2018 document = self.xinclude_loader("C2.xml")
2019 ElementInclude.include(document, self.xinclude_loader)
2020 self.assertEqual(serialize(document),
2021 '<document>\n'
2022 ' <p>This document has been accessed\n'
2023 ' 324387 times.</p>\n'
2024 '</document>') # C2
2025
2026 # Textual inclusion after sibling element (based on modified XInclude C.2)
2027 document = self.xinclude_loader("C2b.xml")
2028 ElementInclude.include(document, self.xinclude_loader)
2029 self.assertEqual(serialize(document),
2030 '<document>\n'
2031 ' <p>This document has been <em>accessed</em>\n'
2032 ' 324387 times.</p>\n'
2033 '</document>') # C2b
2034
2035 # Textual inclusion of XML example (XInclude C.3)
2036 document = self.xinclude_loader("C3.xml")
2037 ElementInclude.include(document, self.xinclude_loader)
2038 self.assertEqual(serialize(document),
2039 '<document>\n'
2040 ' <p>The following is the source of the "data.xml" resource:</p>\n'
2041 " <example>&lt;?xml version='1.0'?&gt;\n"
2042 '&lt;data&gt;\n'
2043 ' &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt;\n'
2044 '&lt;/data&gt;\n'
2045 '</example>\n'
2046 '</document>') # C3
2047
2048 # Fallback example (XInclude C.5)
2049 # Note! Fallback support is not yet implemented
2050 document = self.xinclude_loader("C5.xml")
2051 with self.assertRaises(OSError) as cm:
2052 ElementInclude.include(document, self.xinclude_loader)
2053 self.assertEqual(str(cm.exception), 'resource not found')
2054 self.assertEqual(serialize(document),
2055 '<div xmlns:ns0="http://www.w3.org/2001/XInclude">\n'
2056 ' <ns0:include href="example.txt" parse="text">\n'
2057 ' <ns0:fallback>\n'
2058 ' <ns0:include href="fallback-example.txt" parse="text">\n'
2059 ' <ns0:fallback><a href="mailto:[email protected]">Report error</a></ns0:fallback>\n'
2060 ' </ns0:include>\n'
2061 ' </ns0:fallback>\n'
2062 ' </ns0:include>\n'
2063 '</div>') # C5
2064
2065 def test_xinclude_repeated(self):
2066 from xml.etree import ElementInclude
2067
2068 document = self.xinclude_loader("include_c1_repeated.xml")
2069 ElementInclude.include(document, self.xinclude_loader)
2070 self.assertEqual(1+4*2, len(document.findall(".//p")))
2071
2072 def test_xinclude_failures(self):
2073 from xml.etree import ElementInclude
2074
2075 # Test failure to locate included XML file.
2076 document = ET.XML(XINCLUDE["C1.xml"])
2077 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2078 ElementInclude.include(document, loader=self.none_loader)
2079 self.assertEqual(str(cm.exception),
2080 "cannot load 'disclaimer.xml' as 'xml'")
2081
2082 # Test failure to locate included text file.
2083 document = ET.XML(XINCLUDE["C2.xml"])
2084 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2085 ElementInclude.include(document, loader=self.none_loader)
2086 self.assertEqual(str(cm.exception),
2087 "cannot load 'count.txt' as 'text'")
2088
2089 # Test bad parse type.
2090 document = ET.XML(XINCLUDE_BAD["B1.xml"])
2091 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2092 ElementInclude.include(document, loader=self.none_loader)
2093 self.assertEqual(str(cm.exception),
2094 "unknown parse type in xi:include tag ('BAD_TYPE')")
2095
2096 # Test xi:fallback outside xi:include.
2097 document = ET.XML(XINCLUDE_BAD["B2.xml"])
2098 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2099 ElementInclude.include(document, loader=self.none_loader)
2100 self.assertEqual(str(cm.exception),
2101 "xi:fallback tag must be child of xi:include "
2102 "('{http://www.w3.org/2001/XInclude}fallback')")
2103
2104 # Test infinitely recursive includes.
2105 document = self.xinclude_loader("Recursive1.xml")
2106 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2107 ElementInclude.include(document, self.xinclude_loader)
2108 self.assertEqual(str(cm.exception),
2109 "recursive include of Recursive2.xml")
2110
2111 # Test 'max_depth' limitation.
2112 document = self.xinclude_loader("Recursive1.xml")
2113 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2114 ElementInclude.include(document, self.xinclude_loader, max_depth=None)
2115 self.assertEqual(str(cm.exception),
2116 "recursive include of Recursive2.xml")
2117
2118 document = self.xinclude_loader("Recursive1.xml")
2119 with self.assertRaises(ElementInclude.LimitedRecursiveIncludeError) as cm:
2120 ElementInclude.include(document, self.xinclude_loader, max_depth=0)
2121 self.assertEqual(str(cm.exception),
2122 "maximum xinclude depth reached when including file Recursive2.xml")
2123
2124 document = self.xinclude_loader("Recursive1.xml")
2125 with self.assertRaises(ElementInclude.LimitedRecursiveIncludeError) as cm:
2126 ElementInclude.include(document, self.xinclude_loader, max_depth=1)
2127 self.assertEqual(str(cm.exception),
2128 "maximum xinclude depth reached when including file Recursive3.xml")
2129
2130 document = self.xinclude_loader("Recursive1.xml")
2131 with self.assertRaises(ElementInclude.LimitedRecursiveIncludeError) as cm:
2132 ElementInclude.include(document, self.xinclude_loader, max_depth=2)
2133 self.assertEqual(str(cm.exception),
2134 "maximum xinclude depth reached when including file Recursive1.xml")
2135
2136 document = self.xinclude_loader("Recursive1.xml")
2137 with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
2138 ElementInclude.include(document, self.xinclude_loader, max_depth=3)
2139 self.assertEqual(str(cm.exception),
2140 "recursive include of Recursive2.xml")
2141
2142
2143 # --------------------------------------------------------------------
2144 # reported bugs
2145
2146 class BugsTest(unittest.TestCase):
2147
2148 def test_bug_xmltoolkit21(self):
2149 # marshaller gives obscure errors for non-string values
2150
2151 def check(elem):
2152 with self.assertRaises(TypeError) as cm:
2153 serialize(elem)
2154 self.assertEqual(str(cm.exception),
2155 'cannot serialize 123 (type int)')
2156
2157 elem = ET.Element(123)
2158 check(elem) # tag
2159
2160 elem = ET.Element("elem")
2161 elem.text = 123
2162 check(elem) # text
2163
2164 elem = ET.Element("elem")
2165 elem.tail = 123
2166 check(elem) # tail
2167
2168 elem = ET.Element("elem")
2169 elem.set(123, "123")
2170 check(elem) # attribute key
2171
2172 elem = ET.Element("elem")
2173 elem.set("123", 123)
2174 check(elem) # attribute value
2175
2176 def test_bug_xmltoolkit25(self):
2177 # typo in ElementTree.findtext
2178
2179 elem = ET.XML(SAMPLE_XML)
2180 tree = ET.ElementTree(elem)
2181 self.assertEqual(tree.findtext("tag"), 'text')
2182 self.assertEqual(tree.findtext("section/tag"), 'subtext')
2183
2184 def test_bug_xmltoolkit28(self):
2185 # .//tag causes exceptions
2186
2187 tree = ET.XML("<doc><table><tbody/></table></doc>")
2188 self.assertEqual(summarize_list(tree.findall(".//thead")), [])
2189 self.assertEqual(summarize_list(tree.findall(".//tbody")), ['tbody'])
2190
2191 def test_bug_xmltoolkitX1(self):
2192 # dump() doesn't flush the output buffer
2193
2194 tree = ET.XML("<doc><table><tbody/></table></doc>")
2195 with support.captured_stdout() as stdout:
2196 ET.dump(tree)
2197 self.assertEqual(stdout.getvalue(), '<doc><table><tbody /></table></doc>\n')
2198
2199 def test_bug_xmltoolkit39(self):
2200 # non-ascii element and attribute names doesn't work
2201
2202 tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g />")
2203 self.assertEqual(ET.tostring(tree, "utf-8"), b'<t\xc3\xa4g />')
2204
2205 tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
2206 b"<tag \xe4ttr='v&#228;lue' />")
2207 self.assertEqual(tree.attrib, {'\xe4ttr': 'v\xe4lue'})
2208 self.assertEqual(ET.tostring(tree, "utf-8"),
2209 b'<tag \xc3\xa4ttr="v\xc3\xa4lue" />')
2210
2211 tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
2212 b'<t\xe4g>text</t\xe4g>')
2213 self.assertEqual(ET.tostring(tree, "utf-8"),
2214 b'<t\xc3\xa4g>text</t\xc3\xa4g>')
2215
2216 tree = ET.Element("t\u00e4g")
2217 self.assertEqual(ET.tostring(tree, "utf-8"), b'<t\xc3\xa4g />')
2218
2219 tree = ET.Element("tag")
2220 tree.set("\u00e4ttr", "v\u00e4lue")
2221 self.assertEqual(ET.tostring(tree, "utf-8"),
2222 b'<tag \xc3\xa4ttr="v\xc3\xa4lue" />')
2223
2224 def test_bug_xmltoolkit54(self):
2225 # problems handling internally defined entities
2226
2227 e = ET.XML("<!DOCTYPE doc [<!ENTITY ldots '&#x8230;'>]>"
2228 '<doc>&ldots;</doc>')
2229 self.assertEqual(serialize(e, encoding="us-ascii"),
2230 b'<doc>&#33328;</doc>')
2231 self.assertEqual(serialize(e), '<doc>\u8230</doc>')
2232
2233 def test_bug_xmltoolkit55(self):
2234 # make sure we're reporting the first error, not the last
2235
2236 with self.assertRaises(ET.ParseError) as cm:
2237 ET.XML(b"<!DOCTYPE doc SYSTEM 'doc.dtd'>"
2238 b'<doc>&ldots;&ndots;&rdots;</doc>')
2239 self.assertEqual(str(cm.exception),
2240 'undefined entity &ldots;: line 1, column 36')
2241
2242 def test_bug_xmltoolkit60(self):
2243 # Handle crash in stream source.
2244
2245 class ExceptionFile:
2246 def read(self, x):
2247 raise OSError
2248
2249 self.assertRaises(OSError, ET.parse, ExceptionFile())
2250
2251 def test_bug_xmltoolkit62(self):
2252 # Don't crash when using custom entities.
2253
2254 ENTITIES = {'rsquo': '\u2019', 'lsquo': '\u2018'}
2255 parser = ET.XMLParser()
2256 parser.entity.update(ENTITIES)
2257 parser.feed("""<?xml version="1.0" encoding="UTF-8"?>
2258 <!DOCTYPE patent-application-publication SYSTEM "pap-v15-2001-01-31.dtd" []>
2259 <patent-application-publication>
2260 <subdoc-abstract>
2261 <paragraph id="A-0001" lvl="0">A new cultivar of Begonia plant named &lsquo;BCT9801BEG&rsquo;.</paragraph>
2262 </subdoc-abstract>
2263 </patent-application-publication>""")
2264 t = parser.close()
2265 self.assertEqual(t.find('.//paragraph').text,
2266 'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.')
2267
2268 @unittest.skipIf(sys.gettrace(), "Skips under coverage.")
2269 def test_bug_xmltoolkit63(self):
2270 # Check reference leak.
2271 def xmltoolkit63():
2272 tree = ET.TreeBuilder()
2273 tree.start("tag", {})
2274 tree.data("text")
2275 tree.end("tag")
2276
2277 xmltoolkit63()
2278 count = sys.getrefcount(None)
2279 for i in range(1000):
2280 xmltoolkit63()
2281 self.assertEqual(sys.getrefcount(None), count)
2282
2283 def test_bug_200708_newline(self):
2284 # Preserve newlines in attributes.
2285
2286 e = ET.Element('SomeTag', text="def _f():\n return 3\n")
2287 self.assertEqual(ET.tostring(e),
2288 b'<SomeTag text="def _f():&#10; return 3&#10;" />')
2289 self.assertEqual(ET.XML(ET.tostring(e)).get("text"),
2290 'def _f():\n return 3\n')
2291 self.assertEqual(ET.tostring(ET.XML(ET.tostring(e))),
2292 b'<SomeTag text="def _f():&#10; return 3&#10;" />')
2293
2294 def test_bug_200708_close(self):
2295 # Test default builder.
2296 parser = ET.XMLParser() # default
2297 parser.feed("<element>some text</element>")
2298 self.assertEqual(parser.close().tag, 'element')
2299
2300 # Test custom builder.
2301 class EchoTarget:
2302 def close(self):
2303 return ET.Element("element") # simulate root
2304 parser = ET.XMLParser(target=EchoTarget())
2305 parser.feed("<element>some text</element>")
2306 self.assertEqual(parser.close().tag, 'element')
2307
2308 def test_bug_200709_default_namespace(self):
2309 e = ET.Element("{default}elem")
2310 s = ET.SubElement(e, "{default}elem")
2311 self.assertEqual(serialize(e, default_namespace="default"), # 1
2312 '<elem xmlns="default"><elem /></elem>')
2313
2314 e = ET.Element("{default}elem")
2315 s = ET.SubElement(e, "{default}elem")
2316 s = ET.SubElement(e, "{not-default}elem")
2317 self.assertEqual(serialize(e, default_namespace="default"), # 2
2318 '<elem xmlns="default" xmlns:ns1="not-default">'
2319 '<elem />'
2320 '<ns1:elem />'
2321 '</elem>')
2322
2323 e = ET.Element("{default}elem")
2324 s = ET.SubElement(e, "{default}elem")
2325 s = ET.SubElement(e, "elem") # unprefixed name
2326 with self.assertRaises(ValueError) as cm:
2327 serialize(e, default_namespace="default") # 3
2328 self.assertEqual(str(cm.exception),
2329 'cannot use non-qualified names with default_namespace option')
2330
2331 def test_bug_200709_register_namespace(self):
2332 e = ET.Element("{http://namespace.invalid/does/not/exist/}title")
2333 self.assertEqual(ET.tostring(e),
2334 b'<ns0:title xmlns:ns0="http://namespace.invalid/does/not/exist/" />')
2335 ET.register_namespace("foo", "http://namespace.invalid/does/not/exist/")
2336 e = ET.Element("{http://namespace.invalid/does/not/exist/}title")
2337 self.assertEqual(ET.tostring(e),
2338 b'<foo:title xmlns:foo="http://namespace.invalid/does/not/exist/" />')
2339
2340 # And the Dublin Core namespace is in the default list:
2341
2342 e = ET.Element("{http://purl.org/dc/elements/1.1/}title")
2343 self.assertEqual(ET.tostring(e),
2344 b'<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/" />')
2345
2346 def test_bug_200709_element_comment(self):
2347 # Not sure if this can be fixed, really (since the serializer needs
2348 # ET.Comment, not cET.comment).
2349
2350 a = ET.Element('a')
2351 a.append(ET.Comment('foo'))
2352 self.assertEqual(a[0].tag, ET.Comment)
2353
2354 a = ET.Element('a')
2355 a.append(ET.PI('foo'))
2356 self.assertEqual(a[0].tag, ET.PI)
2357
2358 def test_bug_200709_element_insert(self):
2359 a = ET.Element('a')
2360 b = ET.SubElement(a, 'b')
2361 c = ET.SubElement(a, 'c')
2362 d = ET.Element('d')
2363 a.insert(0, d)
2364 self.assertEqual(summarize_list(a), ['d', 'b', 'c'])
2365 a.insert(-1, d)
2366 self.assertEqual(summarize_list(a), ['d', 'b', 'd', 'c'])
2367
2368 def test_bug_200709_iter_comment(self):
2369 a = ET.Element('a')
2370 b = ET.SubElement(a, 'b')
2371 comment_b = ET.Comment("TEST-b")
2372 b.append(comment_b)
2373 self.assertEqual(summarize_list(a.iter(ET.Comment)), [ET.Comment])
2374
2375 # --------------------------------------------------------------------
2376 # reported on bugs.python.org
2377
2378 def test_bug_1534630(self):
2379 bob = ET.TreeBuilder()
2380 e = bob.data("data")
2381 e = bob.start("tag", {})
2382 e = bob.end("tag")
2383 e = bob.close()
2384 self.assertEqual(serialize(e), '<tag />')
2385
2386 def test_issue6233(self):
2387 e = ET.XML(b"<?xml version='1.0' encoding='utf-8'?>"
2388 b'<body>t\xc3\xa3g</body>')
2389 self.assertEqual(ET.tostring(e, 'ascii'),
2390 b"<?xml version='1.0' encoding='ascii'?>\n"
2391 b'<body>t&#227;g</body>')
2392 e = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
2393 b'<body>t\xe3g</body>')
2394 self.assertEqual(ET.tostring(e, 'ascii'),
2395 b"<?xml version='1.0' encoding='ascii'?>\n"
2396 b'<body>t&#227;g</body>')
2397
2398 def test_issue6565(self):
2399 elem = ET.XML("<body><tag/></body>")
2400 self.assertEqual(summarize_list(elem), ['tag'])
2401 newelem = ET.XML(SAMPLE_XML)
2402 elem[:] = newelem[:]
2403 self.assertEqual(summarize_list(elem), ['tag', 'tag', 'section'])
2404
2405 def test_issue10777(self):
2406 # Registering a namespace twice caused a "dictionary changed size during
2407 # iteration" bug.
2408
2409 ET.register_namespace('test10777', 'http://myuri/')
2410 ET.register_namespace('test10777', 'http://myuri/')
2411
2412 def test_lost_text(self):
2413 # Issue #25902: Borrowed text can disappear
2414 class Text:
2415 def __bool__(self):
2416 e.text = 'changed'
2417 return True
2418
2419 e = ET.Element('tag')
2420 e.text = Text()
2421 i = e.itertext()
2422 t = next(i)
2423 self.assertIsInstance(t, Text)
2424 self.assertIsInstance(e.text, str)
2425 self.assertEqual(e.text, 'changed')
2426
2427 def test_lost_tail(self):
2428 # Issue #25902: Borrowed tail can disappear
2429 class Text:
2430 def __bool__(self):
2431 e[0].tail = 'changed'
2432 return True
2433
2434 e = ET.Element('root')
2435 e.append(ET.Element('tag'))
2436 e[0].tail = Text()
2437 i = e.itertext()
2438 t = next(i)
2439 self.assertIsInstance(t, Text)
2440 self.assertIsInstance(e[0].tail, str)
2441 self.assertEqual(e[0].tail, 'changed')
2442
2443 def test_lost_elem(self):
2444 # Issue #25902: Borrowed element can disappear
2445 class Tag:
2446 def __eq__(self, other):
2447 e[0] = ET.Element('changed')
2448 next(i)
2449 return True
2450
2451 e = ET.Element('root')
2452 e.append(ET.Element(Tag()))
2453 e.append(ET.Element('tag'))
2454 i = e.iter('tag')
2455 try:
2456 t = next(i)
2457 except ValueError:
2458 self.skipTest('generators are not reentrant')
2459 self.assertIsInstance(t.tag, Tag)
2460 self.assertIsInstance(e[0].tag, str)
2461 self.assertEqual(e[0].tag, 'changed')
2462
2463 def check_expat224_utf8_bug(self, text):
2464 xml = b'<a b="%s"/>' % text
2465 root = ET.XML(xml)
2466 self.assertEqual(root.get('b'), text.decode('utf-8'))
2467
2468 def test_expat224_utf8_bug(self):
2469 # bpo-31170: Expat 2.2.3 had a bug in its UTF-8 decoder.
2470 # Check that Expat 2.2.4 fixed the bug.
2471 #
2472 # Test buffer bounds at odd and even positions.
2473
2474 text = b'\xc3\xa0' * 1024
2475 self.check_expat224_utf8_bug(text)
2476
2477 text = b'x' + b'\xc3\xa0' * 1024
2478 self.check_expat224_utf8_bug(text)
2479
2480 def test_expat224_utf8_bug_file(self):
2481 with open(UTF8_BUG_XMLFILE, 'rb') as fp:
2482 raw = fp.read()
2483 root = ET.fromstring(raw)
2484 xmlattr = root.get('b')
2485
2486 # "Parse" manually the XML file to extract the value of the 'b'
2487 # attribute of the <a b='xxx' /> XML element
2488 text = raw.decode('utf-8').strip()
2489 text = text.replace('\r\n', ' ')
2490 text = text[6:-4]
2491 self.assertEqual(root.get('b'), text)
2492
2493 def test_39495_treebuilder_start(self):
2494 self.assertRaises(TypeError, ET.TreeBuilder().start, "tag")
2495 self.assertRaises(TypeError, ET.TreeBuilder().start, "tag", None)
2496
2497 def test_issue123213_correct_extend_exception(self):
2498 # Does not hide the internal exception when extending the element
2499 self.assertRaises(ZeroDivisionError, ET.Element('tag').extend,
2500 (1/0 for i in range(2)))
2501
2502 # Still raises the TypeError when extending with a non-iterable
2503 self.assertRaises(TypeError, ET.Element('tag').extend, None)
2504
2505 # Preserves the TypeError message when extending with a generator
2506 def f():
2507 raise TypeError("mymessage")
2508
2509 self.assertRaisesRegex(
2510 TypeError, 'mymessage',
2511 ET.Element('tag').extend, (f() for i in range(2)))
2512
2513
2514
2515 # --------------------------------------------------------------------
2516
2517
2518 class BasicElementTest(ElementTestCase, unittest.TestCase):
2519
2520 def test___init__(self):
2521 tag = "foo"
2522 attrib = { "zix": "wyp" }
2523
2524 element_foo = ET.Element(tag, attrib)
2525
2526 # traits of an element
2527 self.assertIsInstance(element_foo, ET.Element)
2528 self.assertIn("tag", dir(element_foo))
2529 self.assertIn("attrib", dir(element_foo))
2530 self.assertIn("text", dir(element_foo))
2531 self.assertIn("tail", dir(element_foo))
2532
2533 # string attributes have expected values
2534 self.assertEqual(element_foo.tag, tag)
2535 self.assertIsNone(element_foo.text)
2536 self.assertIsNone(element_foo.tail)
2537
2538 # attrib is a copy
2539 self.assertIsNot(element_foo.attrib, attrib)
2540 self.assertEqual(element_foo.attrib, attrib)
2541
2542 # attrib isn't linked
2543 attrib["bar"] = "baz"
2544 self.assertIsNot(element_foo.attrib, attrib)
2545 self.assertNotEqual(element_foo.attrib, attrib)
2546
2547 def test___copy__(self):
2548 element_foo = ET.Element("foo", { "zix": "wyp" })
2549 element_foo.append(ET.Element("bar", { "baz": "qix" }))
2550
2551 element_foo2 = copy.copy(element_foo)
2552
2553 # elements are not the same
2554 self.assertIsNot(element_foo2, element_foo)
2555
2556 # string attributes are equal
2557 self.assertEqual(element_foo2.tag, element_foo.tag)
2558 self.assertEqual(element_foo2.text, element_foo.text)
2559 self.assertEqual(element_foo2.tail, element_foo.tail)
2560
2561 # number of children is the same
2562 self.assertEqual(len(element_foo2), len(element_foo))
2563
2564 # children are the same
2565 for (child1, child2) in itertools.zip_longest(element_foo, element_foo2):
2566 self.assertIs(child1, child2)
2567
2568 # attrib is a copy
2569 self.assertEqual(element_foo2.attrib, element_foo.attrib)
2570
2571 def test___deepcopy__(self):
2572 element_foo = ET.Element("foo", { "zix": "wyp" })
2573 element_foo.append(ET.Element("bar", { "baz": "qix" }))
2574
2575 element_foo2 = copy.deepcopy(element_foo)
2576
2577 # elements are not the same
2578 self.assertIsNot(element_foo2, element_foo)
2579
2580 # string attributes are equal
2581 self.assertEqual(element_foo2.tag, element_foo.tag)
2582 self.assertEqual(element_foo2.text, element_foo.text)
2583 self.assertEqual(element_foo2.tail, element_foo.tail)
2584
2585 # number of children is the same
2586 self.assertEqual(len(element_foo2), len(element_foo))
2587
2588 # children are not the same
2589 for (child1, child2) in itertools.zip_longest(element_foo, element_foo2):
2590 self.assertIsNot(child1, child2)
2591
2592 # attrib is a copy
2593 self.assertIsNot(element_foo2.attrib, element_foo.attrib)
2594 self.assertEqual(element_foo2.attrib, element_foo.attrib)
2595
2596 # attrib isn't linked
2597 element_foo.attrib["bar"] = "baz"
2598 self.assertIsNot(element_foo2.attrib, element_foo.attrib)
2599 self.assertNotEqual(element_foo2.attrib, element_foo.attrib)
2600
2601 def test_augmentation_type_errors(self):
2602 e = ET.Element('joe')
2603 self.assertRaises(TypeError, e.append, 'b')
2604 self.assertRaises(TypeError, e.extend, [ET.Element('bar'), 'foo'])
2605 self.assertRaises(TypeError, e.insert, 0, 'foo')
2606 e[:] = [ET.Element('bar')]
2607 with self.assertRaises(TypeError):
2608 e[0] = 'foo'
2609 with self.assertRaises(TypeError):
2610 e[:] = [ET.Element('bar'), 'foo']
2611
2612 if hasattr(e, '__setstate__'):
2613 state = {
2614 'tag': 'tag',
2615 '_children': [None], # non-Element
2616 'attrib': 'attr',
2617 'tail': 'tail',
2618 'text': 'text',
2619 }
2620 self.assertRaises(TypeError, e.__setstate__, state)
2621
2622 if hasattr(e, '__deepcopy__'):
2623 class E(ET.Element):
2624 def __deepcopy__(self, memo):
2625 return None # non-Element
2626 e[:] = [E('bar')]
2627 self.assertRaises(TypeError, copy.deepcopy, e)
2628
2629 def test_cyclic_gc(self):
2630 class Dummy:
2631 pass
2632
2633 # Test the shortest cycle: d->element->d
2634 d = Dummy()
2635 d.dummyref = ET.Element('joe', attr=d)
2636 wref = weakref.ref(d)
2637 del d
2638 gc_collect()
2639 self.assertIsNone(wref())
2640
2641 # A longer cycle: d->e->e2->d
2642 e = ET.Element('joe')
2643 d = Dummy()
2644 d.dummyref = e
2645 wref = weakref.ref(d)
2646 e2 = ET.SubElement(e, 'foo', attr=d)
2647 del d, e, e2
2648 gc_collect()
2649 self.assertIsNone(wref())
2650
2651 # A cycle between Element objects as children of one another
2652 # e1->e2->e3->e1
2653 e1 = ET.Element('e1')
2654 e2 = ET.Element('e2')
2655 e3 = ET.Element('e3')
2656 e3.append(e1)
2657 e2.append(e3)
2658 e1.append(e2)
2659 wref = weakref.ref(e1)
2660 del e1, e2, e3
2661 gc_collect()
2662 self.assertIsNone(wref())
2663
2664 def test_weakref(self):
2665 flag = False
2666 def wref_cb(w):
2667 nonlocal flag
2668 flag = True
2669 e = ET.Element('e')
2670 wref = weakref.ref(e, wref_cb)
2671 self.assertEqual(wref().tag, 'e')
2672 del e
2673 gc_collect() # For PyPy or other GCs.
2674 self.assertEqual(flag, True)
2675 self.assertEqual(wref(), None)
2676
2677 def test_get_keyword_args(self):
2678 e1 = ET.Element('foo' , x=1, y=2, z=3)
2679 self.assertEqual(e1.get('x', default=7), 1)
2680 self.assertEqual(e1.get('w', default=7), 7)
2681
2682 def test_pickle(self):
2683 # issue #16076: the C implementation wasn't pickleable.
2684 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
2685 for dumper, loader in product(self.modules, repeat=2):
2686 e = dumper.Element('foo', bar=42)
2687 e.text = "text goes here"
2688 e.tail = "opposite of head"
2689 dumper.SubElement(e, 'child').append(dumper.Element('grandchild'))
2690 e.append(dumper.Element('child'))
2691 e.findall('.//grandchild')[0].set('attr', 'other value')
2692
2693 e2 = self.pickleRoundTrip(e, 'xml.etree.ElementTree',
2694 dumper, loader, proto)
2695
2696 self.assertEqual(e2.tag, 'foo')
2697 self.assertEqual(e2.attrib['bar'], 42)
2698 self.assertEqual(len(e2), 2)
2699 self.assertEqualElements(e, e2)
2700
2701 def test_pickle_issue18997(self):
2702 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
2703 for dumper, loader in product(self.modules, repeat=2):
2704 XMLTEXT = """<?xml version="1.0"?>
2705 <group><dogs>4</dogs>
2706 </group>"""
2707 e1 = dumper.fromstring(XMLTEXT)
2708 self.assertEqual(e1.__getstate__()['tag'], 'group')
2709 e2 = self.pickleRoundTrip(e1, 'xml.etree.ElementTree',
2710 dumper, loader, proto)
2711 self.assertEqual(e2.tag, 'group')
2712 self.assertEqual(e2[0].tag, 'dogs')
2713
2714
2715 class BadElementTest(ElementTestCase, unittest.TestCase):
2716
2717 def test_extend_mutable_list(self):
2718 class X:
2719 @property
2720 def __class__(self):
2721 L[:] = [ET.Element('baz')]
2722 return ET.Element
2723 L = [X()]
2724 e = ET.Element('foo')
2725 try:
2726 e.extend(L)
2727 except TypeError:
2728 pass
2729
2730 class Y(X, ET.Element):
2731 pass
2732 L = [Y('x')]
2733 e = ET.Element('foo')
2734 e.extend(L)
2735
2736 def test_extend_mutable_list2(self):
2737 class X:
2738 @property
2739 def __class__(self):
2740 del L[:]
2741 return ET.Element
2742 L = [X(), ET.Element('baz')]
2743 e = ET.Element('foo')
2744 try:
2745 e.extend(L)
2746 except TypeError:
2747 pass
2748
2749 class Y(X, ET.Element):
2750 pass
2751 L = [Y('bar'), ET.Element('baz')]
2752 e = ET.Element('foo')
2753 e.extend(L)
2754
2755 def test_remove_with_clear_assume_missing(self):
2756 # gh-126033: Check that a concurrent clear() for an assumed-to-be
2757 # missing element does not make the interpreter crash.
2758 self.do_test_remove_with_clear(raises=True)
2759
2760 def test_remove_with_clear_assume_existing(self):
2761 # gh-126033: Check that a concurrent clear() for an assumed-to-be
2762 # existing element does not make the interpreter crash.
2763 self.do_test_remove_with_clear(raises=False)
2764
2765 def do_test_remove_with_clear(self, *, raises):
2766
2767 # Until the discrepency between "del root[:]" and "root.clear()" is
2768 # resolved, we need to keep two tests. Previously, using "del root[:]"
2769 # did not crash with the reproducer of gh-126033 while "root.clear()"
2770 # did.
2771
2772 class E(ET.Element):
2773 """Local class to be able to mock E.__eq__ for introspection."""
2774
2775 class X(E):
2776 def __eq__(self, o):
2777 del root[:]
2778 return not raises
2779
2780 class Y(E):
2781 def __eq__(self, o):
2782 root.clear()
2783 return not raises
2784
2785 if raises:
2786 get_checker_context = lambda: self.assertRaises(ValueError)
2787 else:
2788 get_checker_context = nullcontext
2789
2790 self.assertIs(E.__eq__, object.__eq__)
2791
2792 for Z, side_effect in [(X, 'del root[:]'), (Y, 'root.clear()')]:
2793 self.enterContext(self.subTest(side_effect=side_effect))
2794
2795 # test removing R() from [U()]
2796 for R, U, description in [
2797 (E, Z, "remove missing E() from [Z()]"),
2798 (Z, E, "remove missing Z() from [E()]"),
2799 (Z, Z, "remove missing Z() from [Z()]"),
2800 ]:
2801 with self.subTest(description):
2802 root = E('top')
2803 root.extend([U('one')])
2804 with get_checker_context():
2805 root.remove(R('missing'))
2806
2807 # test removing R() from [U(), V()]
2808 cases = self.cases_for_remove_missing_with_mutations(E, Z)
2809 for R, U, V, description in cases:
2810 with self.subTest(description):
2811 root = E('top')
2812 root.extend([U('one'), V('two')])
2813 with get_checker_context():
2814 root.remove(R('missing'))
2815
2816 # Test removing root[0] from [Z()].
2817 #
2818 # Since we call root.remove() with root[0], Z.__eq__()
2819 # will not be called (we branch on the fast Py_EQ path).
2820 with self.subTest("remove root[0] from [Z()]"):
2821 root = E('top')
2822 root.append(Z('rem'))
2823 with equal_wrapper(E) as f, equal_wrapper(Z) as g:
2824 root.remove(root[0])
2825 f.assert_not_called()
2826 g.assert_not_called()
2827
2828 # Test removing root[1] (of type R) from [U(), R()].
2829 is_special = is_python_implementation() and raises and Z is Y
2830 if is_python_implementation() and raises and Z is Y:
2831 # In pure Python, using root.clear() sets the children
2832 # list to [] without calling list.clear().
2833 #
2834 # For this reason, the call to root.remove() first
2835 # checks root[0] and sets the children list to []
2836 # since either root[0] or root[1] is an evil element.
2837 #
2838 # Since checking root[1] still uses the old reference
2839 # to the children list, PyObject_RichCompareBool() branches
2840 # to the fast Py_EQ path and Y.__eq__() is called exactly
2841 # once (when checking root[0]).
2842 continue
2843 else:
2844 cases = self.cases_for_remove_existing_with_mutations(E, Z)
2845 for R, U, description in cases:
2846 with self.subTest(description):
2847 root = E('top')
2848 root.extend([U('one'), R('rem')])
2849 with get_checker_context():
2850 root.remove(root[1])
2851
2852 def test_remove_with_mutate_root_assume_missing(self):
2853 # gh-126033: Check that a concurrent mutation for an assumed-to-be
2854 # missing element does not make the interpreter crash.
2855 self.do_test_remove_with_mutate_root(raises=True)
2856
2857 def test_remove_with_mutate_root_assume_existing(self):
2858 # gh-126033: Check that a concurrent mutation for an assumed-to-be
2859 # existing element does not make the interpreter crash.
2860 self.do_test_remove_with_mutate_root(raises=False)
2861
2862 def do_test_remove_with_mutate_root(self, *, raises):
2863 E = ET.Element
2864
2865 class Z(E):
2866 def __eq__(self, o):
2867 del root[0]
2868 return not raises
2869
2870 if raises:
2871 get_checker_context = lambda: self.assertRaises(ValueError)
2872 else:
2873 get_checker_context = nullcontext
2874
2875 # test removing R() from [U(), V()]
2876 cases = self.cases_for_remove_missing_with_mutations(E, Z)
2877 for R, U, V, description in cases:
2878 with self.subTest(description):
2879 root = E('top')
2880 root.extend([U('one'), V('two')])
2881 with get_checker_context():
2882 root.remove(R('missing'))
2883
2884 # test removing root[1] (of type R) from [U(), R()]
2885 cases = self.cases_for_remove_existing_with_mutations(E, Z)
2886 for R, U, description in cases:
2887 with self.subTest(description):
2888 root = E('top')
2889 root.extend([U('one'), R('rem')])
2890 with get_checker_context():
2891 root.remove(root[1])
2892
2893 def cases_for_remove_missing_with_mutations(self, E, Z):
2894 # Cases for removing R() from [U(), V()].
2895 # The case U = V = R = E is not interesting as there is no mutation.
2896 for U, V in [(E, Z), (Z, E), (Z, Z)]:
2897 description = (f"remove missing {E.__name__}() from "
2898 f"[{U.__name__}(), {V.__name__}()]")
2899 yield E, U, V, description
2900
2901 for U, V in [(E, E), (E, Z), (Z, E), (Z, Z)]:
2902 description = (f"remove missing {Z.__name__}() from "
2903 f"[{U.__name__}(), {V.__name__}()]")
2904 yield Z, U, V, description
2905
2906 def cases_for_remove_existing_with_mutations(self, E, Z):
2907 # Cases for removing root[1] (of type R) from [U(), R()].
2908 # The case U = R = E is not interesting as there is no mutation.
2909 for U, R, description in [
2910 (E, Z, "remove root[1] from [E(), Z()]"),
2911 (Z, E, "remove root[1] from [Z(), E()]"),
2912 (Z, Z, "remove root[1] from [Z(), Z()]"),
2913 ]:
2914 description = (f"remove root[1] (of type {R.__name__}) "
2915 f"from [{U.__name__}(), {R.__name__}()]")
2916 yield R, U, description
2917
2918 @support.infinite_recursion(25)
2919 def test_recursive_repr(self):
2920 # Issue #25455
2921 e = ET.Element('foo')
2922 with swap_attr(e, 'tag', e):
2923 with self.assertRaises(RuntimeError):
2924 repr(e) # Should not crash
2925
2926 def test_element_get_text(self):
2927 # Issue #27863
2928 class X(str):
2929 def __del__(self):
2930 try:
2931 elem.text
2932 except NameError:
2933 pass
2934
2935 b = ET.TreeBuilder()
2936 b.start('tag', {})
2937 b.data('ABCD')
2938 b.data(X('EFGH'))
2939 b.data('IJKL')
2940 b.end('tag')
2941
2942 elem = b.close()
2943 self.assertEqual(elem.text, 'ABCDEFGHIJKL')
2944
2945 def test_element_get_tail(self):
2946 # Issue #27863
2947 class X(str):
2948 def __del__(self):
2949 try:
2950 elem[0].tail
2951 except NameError:
2952 pass
2953
2954 b = ET.TreeBuilder()
2955 b.start('root', {})
2956 b.start('tag', {})
2957 b.end('tag')
2958 b.data('ABCD')
2959 b.data(X('EFGH'))
2960 b.data('IJKL')
2961 b.end('root')
2962
2963 elem = b.close()
2964 self.assertEqual(elem[0].tail, 'ABCDEFGHIJKL')
2965
2966 def test_subscr_with_clear(self):
2967 # See https://github.com/python/cpython/issues/143200.
2968 self.do_test_subscr_with_mutating_slice(use_clear_method=True)
2969
2970 def test_subscr_with_delete(self):
2971 # See https://github.com/python/cpython/issues/72050.
2972 self.do_test_subscr_with_mutating_slice(use_clear_method=False)
2973
2974 def do_test_subscr_with_mutating_slice(self, *, use_clear_method):
2975 class X:
2976 def __init__(self, i=0):
2977 self.i = i
2978 def __index__(self):
2979 if use_clear_method:
2980 e.clear()
2981 else:
2982 del e[:]
2983 return self.i
2984
2985 for s in self.get_mutating_slices(X, 10):
2986 with self.subTest(s):
2987 e = ET.Element('elem')
2988 e.extend([ET.Element(f'c{i}') for i in range(10)])
2989 e[s] # shouldn't crash
2990
2991 def test_ass_subscr_with_mutating_slice(self):
2992 # See https://github.com/python/cpython/issues/72050
2993 # and https://github.com/python/cpython/issues/143200.
2994
2995 class X:
2996 def __init__(self, i=0):
2997 self.i = i
2998 def __index__(self):
2999 e[:] = []
3000 return self.i
3001
3002 for s in self.get_mutating_slices(X, 10):
3003 with self.subTest(s):
3004 e = ET.Element('elem')
3005 e.extend([ET.Element(f'c{i}') for i in range(10)])
3006 e[s] = [] # shouldn't crash
3007
3008 def get_mutating_slices(self, index_class, n_children):
3009 self.assertGreaterEqual(n_children, 10)
3010 return [
3011 slice(index_class(), None, None),
3012 slice(index_class(2), None, None),
3013 slice(None, index_class(), None),
3014 slice(None, index_class(2), None),
3015 slice(0, 2, index_class(1)),
3016 slice(0, 2, index_class(2)),
3017 slice(0, n_children, index_class(1)),
3018 slice(0, n_children, index_class(2)),
3019 slice(0, 2 * n_children, index_class(1)),
3020 slice(0, 2 * n_children, index_class(2)),
3021 ]
3022
3023 def test_ass_subscr_with_mutating_iterable_value(self):
3024 class V:
3025 def __iter__(self):
3026 e.clear()
3027 return iter([ET.Element('a'), ET.Element('b')])
3028
3029 e = ET.Element('elem')
3030 e.extend([ET.Element(f'c{i}') for i in range(10)])
3031 e[:] = V()
3032
3033 def test_treebuilder_start(self):
3034 # Issue #27863
3035 def element_factory(x, y):
3036 return []
3037 b = ET.TreeBuilder(element_factory=element_factory)
3038
3039 b.start('tag', {})
3040 b.data('ABCD')
3041 self.assertRaises(AttributeError, b.start, 'tag2', {})
3042 del b
3043 gc_collect()
3044
3045 def test_treebuilder_end(self):
3046 # Issue #27863
3047 def element_factory(x, y):
3048 return []
3049 b = ET.TreeBuilder(element_factory=element_factory)
3050
3051 b.start('tag', {})
3052 b.data('ABCD')
3053 self.assertRaises(AttributeError, b.end, 'tag')
3054 del b
3055 gc_collect()
3056
3057 def test_deepcopy_clear(self):
3058 # Prevent crashes when __deepcopy__() clears the children list.
3059 # See https://github.com/python/cpython/issues/133009.
3060 class X(ET.Element):
3061 def __deepcopy__(self, memo):
3062 root.clear()
3063 return self
3064
3065 root = ET.Element('a')
3066 evil = X('x')
3067 root.extend([evil, ET.Element('y')])
3068 if is_python_implementation():
3069 # Mutating a list over which we iterate raises an error.
3070 self.assertRaises(RuntimeError, copy.deepcopy, root)
3071 else:
3072 c = copy.deepcopy(root)
3073 # In the C implementation, we can still copy the evil element.
3074 self.assertListEqual(list(c), [evil])
3075
3076 def test_deepcopy_grow(self):
3077 # Prevent crashes when __deepcopy__() mutates the children list.
3078 # See https://github.com/python/cpython/issues/133009.
3079 a = ET.Element('a')
3080 b = ET.Element('b')
3081 c = ET.Element('c')
3082
3083 class X(ET.Element):
3084 def __deepcopy__(self, memo):
3085 root.append(a)
3086 root.append(b)
3087 return self
3088
3089 root = ET.Element('top')
3090 evil1, evil2 = X('1'), X('2')
3091 root.extend([evil1, c, evil2])
3092 children = list(copy.deepcopy(root))
3093 # mock deep copies
3094 self.assertIs(children[0], evil1)
3095 self.assertIs(children[2], evil2)
3096 # true deep copies
3097 self.assertEqual(children[1].tag, c.tag)
3098 self.assertEqual([c.tag for c in children[3:]],
3099 [a.tag, b.tag, a.tag, b.tag])
3100
3101 @support.skip_if_unlimited_stack_size
3102 @support.skip_emscripten_stack_overflow()
3103 @support.skip_wasi_stack_overflow()
3104 def test_deeply_nested_deepcopy(self):
3105 # This should raise a RecursionError and not crash.
3106 # See https://github.com/python/cpython/issues/148801.
3107 root = cur = ET.Element('s')
3108 for _ in range(500_000):
3109 cur = ET.SubElement(cur, 'u')
3110 with support.infinite_recursion():
3111 with self.assertRaises(RecursionError):
3112 copy.deepcopy(root)
3113
3114
3115 class MutationDeleteElementPath(str):
3116 def __new__(cls, elem, *args):
3117 self = str.__new__(cls, *args)
3118 self.elem = elem
3119 return self
3120
3121 def __eq__(self, o):
3122 del self.elem[:]
3123 return True
3124
3125 __hash__ = str.__hash__
3126
3127
3128 class MutationClearElementPath(str):
3129 def __new__(cls, elem, *args):
3130 self = str.__new__(cls, *args)
3131 self.elem = elem
3132 return self
3133
3134 def __eq__(self, o):
3135 self.elem.clear()
3136 return True
3137
3138 __hash__ = str.__hash__
3139
3140
3141 class BadElementPath(str):
3142 def __eq__(self, o):
3143 raise 1/0
3144
3145 __hash__ = str.__hash__
3146
3147
3148 class BadElementPathTest(ElementTestCase, unittest.TestCase):
3149 def setUp(self):
3150 super().setUp()
3151 from xml.etree import ElementPath
3152 self.path_cache = ElementPath._cache
3153 ElementPath._cache = {}
3154
3155 def tearDown(self):
3156 from xml.etree import ElementPath
3157 ElementPath._cache = self.path_cache
3158 super().tearDown()
3159
3160 def test_find_with_mutating(self):
3161 for cls in [MutationDeleteElementPath, MutationClearElementPath]:
3162 with self.subTest(cls):
3163 e = ET.Element('foo')
3164 e.extend([ET.Element('bar')])
3165 e.find(cls(e, 'x'))
3166
3167 def test_find_with_error(self):
3168 e = ET.Element('foo')
3169 e.extend([ET.Element('bar')])
3170 try:
3171 e.find(BadElementPath('x'))
3172 except ZeroDivisionError:
3173 pass
3174
3175 def test_findtext_with_mutating(self):
3176 for cls in [MutationDeleteElementPath, MutationClearElementPath]:
3177 with self.subTest(cls):
3178 e = ET.Element('foo')
3179 e.extend([ET.Element('bar')])
3180 e.findtext(cls(e, 'x'))
3181
3182 def test_findtext_with_mutating_non_none_text(self):
3183 for cls in [MutationDeleteElementPath, MutationClearElementPath]:
3184 with self.subTest(cls):
3185 e = ET.Element('foo')
3186 child = ET.Element('bar')
3187 child.text = str(object())
3188 e.append(child)
3189 del child
3190 repr(e.findtext(cls(e, 'x')))
3191
3192 def test_findtext_with_error(self):
3193 e = ET.Element('foo')
3194 e.extend([ET.Element('bar')])
3195 try:
3196 e.findtext(BadElementPath('x'))
3197 except ZeroDivisionError:
3198 pass
3199
3200 def test_findtext_with_falsey_text_attribute(self):
3201 root_elem = ET.Element('foo')
3202 sub_elem = ET.SubElement(root_elem, 'bar')
3203 falsey = ["", 0, False, [], (), {}]
3204 for val in falsey:
3205 sub_elem.text = val
3206 self.assertEqual(root_elem.findtext('./bar'), val)
3207
3208 def test_findtext_with_none_text_attribute(self):
3209 root_elem = ET.Element('foo')
3210 sub_elem = ET.SubElement(root_elem, 'bar')
3211 sub_elem.text = None
3212 self.assertEqual(root_elem.findtext('./bar'), '')
3213
3214 def test_findall_with_mutating(self):
3215 for cls in [MutationDeleteElementPath, MutationClearElementPath]:
3216 with self.subTest(cls):
3217 e = ET.Element('foo')
3218 e.extend([ET.Element('bar')])
3219 e.findall(cls(e, 'x'))
3220
3221 def test_findall_with_error(self):
3222 e = ET.Element('foo')
3223 e.extend([ET.Element('bar')])
3224 try:
3225 e.findall(BadElementPath('x'))
3226 except ZeroDivisionError:
3227 pass
3228
3229
3230 class ElementTreeTypeTest(unittest.TestCase):
3231 def test_istype(self):
3232 self.assertIsInstance(ET.ParseError, type)
3233 self.assertIsInstance(ET.QName, type)
3234 self.assertIsInstance(ET.ElementTree, type)
3235 self.assertIsInstance(ET.Element, type)
3236 self.assertIsInstance(ET.TreeBuilder, type)
3237 self.assertIsInstance(ET.XMLParser, type)
3238
3239 def test_Element_subclass_trivial(self):
3240 class MyElement(ET.Element):
3241 pass
3242
3243 mye = MyElement('foo')
3244 self.assertIsInstance(mye, ET.Element)
3245 self.assertIsInstance(mye, MyElement)
3246 self.assertEqual(mye.tag, 'foo')
3247
3248 # test that attribute assignment works (issue 14849)
3249 mye.text = "joe"
3250 self.assertEqual(mye.text, "joe")
3251
3252 def test_Element_subclass_constructor(self):
3253 class MyElement(ET.Element):
3254 def __init__(self, tag, attrib={}, **extra):
3255 super(MyElement, self).__init__(tag + '__', attrib, **extra)
3256
3257 mye = MyElement('foo', {'a': 1, 'b': 2}, c=3, d=4)
3258 self.assertEqual(mye.tag, 'foo__')
3259 self.assertEqual(sorted(mye.items()),
3260 [('a', 1), ('b', 2), ('c', 3), ('d', 4)])
3261
3262 def test_Element_subclass_new_method(self):
3263 class MyElement(ET.Element):
3264 def newmethod(self):
3265 return self.tag
3266
3267 mye = MyElement('joe')
3268 self.assertEqual(mye.newmethod(), 'joe')
3269
3270 def test_Element_subclass_find(self):
3271 class MyElement(ET.Element):
3272 pass
3273
3274 e = ET.Element('foo')
3275 e.text = 'text'
3276 sub = MyElement('bar')
3277 sub.text = 'subtext'
3278 e.append(sub)
3279 self.assertEqual(e.findtext('bar'), 'subtext')
3280 self.assertEqual(e.find('bar').tag, 'bar')
3281 found = list(e.findall('bar'))
3282 self.assertEqual(len(found), 1, found)
3283 self.assertEqual(found[0].tag, 'bar')
3284
3285
3286 class ElementFindTest(unittest.TestCase):
3287 def test_find_simple(self):
3288 e = ET.XML(SAMPLE_XML)
3289 self.assertEqual(e.find('tag').tag, 'tag')
3290 self.assertEqual(e.find('section/tag').tag, 'tag')
3291 self.assertEqual(e.find('./tag').tag, 'tag')
3292
3293 e[2] = ET.XML(SAMPLE_SECTION)
3294 self.assertEqual(e.find('section/nexttag').tag, 'nexttag')
3295
3296 self.assertEqual(e.findtext('./tag'), 'text')
3297 self.assertEqual(e.findtext('section/tag'), 'subtext')
3298
3299 # section/nexttag is found but has no text
3300 self.assertEqual(e.findtext('section/nexttag'), '')
3301 self.assertEqual(e.findtext('section/nexttag', 'default'), '')
3302
3303 # tog doesn't exist and 'default' kicks in
3304 self.assertIsNone(e.findtext('tog'))
3305 self.assertEqual(e.findtext('tog', 'default'), 'default')
3306
3307 # Issue #16922
3308 self.assertEqual(ET.XML('<tag><empty /></tag>').findtext('empty'), '')
3309
3310 def test_find_xpath(self):
3311 LINEAR_XML = '''
3312 <body>
3313 <tag class='a'/>
3314 <tag class='b'/>
3315 <tag class='c'/>
3316 <tag class='d'/>
3317 </body>'''
3318 e = ET.XML(LINEAR_XML)
3319
3320 # Test for numeric indexing and last()
3321 self.assertEqual(e.find('./tag[1]').attrib['class'], 'a')
3322 self.assertEqual(e.find('./tag[2]').attrib['class'], 'b')
3323 self.assertEqual(e.find('./tag[last()]').attrib['class'], 'd')
3324 self.assertEqual(e.find('./tag[last()-1]').attrib['class'], 'c')
3325 self.assertEqual(e.find('./tag[last()-2]').attrib['class'], 'b')
3326
3327 self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[0]')
3328 self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[-1]')
3329 self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()-0]')
3330 self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()+1]')
3331
3332 def test_findall(self):
3333 e = ET.XML(SAMPLE_XML)
3334 e[2] = ET.XML(SAMPLE_SECTION)
3335 self.assertEqual(summarize_list(e.findall('.')), ['body'])
3336 self.assertEqual(summarize_list(e.findall('tag')), ['tag', 'tag'])
3337 self.assertEqual(summarize_list(e.findall('tog')), [])
3338 self.assertEqual(summarize_list(e.findall('tog/foo')), [])
3339 self.assertEqual(summarize_list(e.findall('*')),
3340 ['tag', 'tag', 'section'])
3341 self.assertEqual(summarize_list(e.findall('.//tag')),
3342 ['tag'] * 4)
3343 self.assertEqual(summarize_list(e.findall('section/tag')), ['tag'])
3344 self.assertEqual(summarize_list(e.findall('section//tag')), ['tag'] * 2)
3345 self.assertEqual(summarize_list(e.findall('section/*')),
3346 ['tag', 'nexttag', 'nextsection'])
3347 self.assertEqual(summarize_list(e.findall('section//*')),
3348 ['tag', 'nexttag', 'nextsection', 'tag'])
3349 self.assertEqual(summarize_list(e.findall('section/.//*')),
3350 ['tag', 'nexttag', 'nextsection', 'tag'])
3351 self.assertEqual(summarize_list(e.findall('*/*')),
3352 ['tag', 'nexttag', 'nextsection'])
3353 self.assertEqual(summarize_list(e.findall('*//*')),
3354 ['tag', 'nexttag', 'nextsection', 'tag'])
3355 self.assertEqual(summarize_list(e.findall('*/tag')), ['tag'])
3356 self.assertEqual(summarize_list(e.findall('*/./tag')), ['tag'])
3357 self.assertEqual(summarize_list(e.findall('./tag')), ['tag'] * 2)
3358 self.assertEqual(summarize_list(e.findall('././tag')), ['tag'] * 2)
3359
3360 self.assertEqual(summarize_list(e.findall('.//tag[@class]')),
3361 ['tag'] * 3)
3362 self.assertEqual(summarize_list(e.findall('.//tag[@class="a"]')),
3363 ['tag'])
3364 self.assertEqual(summarize_list(e.findall('.//tag[@class!="a"]')),
3365 ['tag'] * 2)
3366 self.assertEqual(summarize_list(e.findall('.//tag[@class="b"]')),
3367 ['tag'] * 2)
3368 self.assertEqual(summarize_list(e.findall('.//tag[@class!="b"]')),
3369 ['tag'])
3370 self.assertEqual(summarize_list(e.findall('.//tag[@id]')),
3371 ['tag'])
3372 self.assertEqual(summarize_list(e.findall('.//section[tag]')),
3373 ['section'])
3374 self.assertEqual(summarize_list(e.findall('.//section[element]')), [])
3375 self.assertEqual(summarize_list(e.findall('../tag')), [])
3376 self.assertEqual(summarize_list(e.findall('section/../tag')),
3377 ['tag'] * 2)
3378 self.assertEqual(e.findall('section//'), e.findall('section//*'))
3379
3380 self.assertEqual(summarize_list(e.findall(".//section[tag='subtext']")),
3381 ['section'])
3382 self.assertEqual(summarize_list(e.findall(".//section[tag ='subtext']")),
3383 ['section'])
3384 self.assertEqual(summarize_list(e.findall(".//section[tag= 'subtext']")),
3385 ['section'])
3386 self.assertEqual(summarize_list(e.findall(".//section[tag = 'subtext']")),
3387 ['section'])
3388 self.assertEqual(summarize_list(e.findall(".//section[ tag = 'subtext' ]")),
3389 ['section'])
3390
3391 # Negations of above tests. They match nothing because the sole section
3392 # tag has subtext.
3393 self.assertEqual(summarize_list(e.findall(".//section[tag!='subtext']")),
3394 [])
3395 self.assertEqual(summarize_list(e.findall(".//section[tag !='subtext']")),
3396 [])
3397 self.assertEqual(summarize_list(e.findall(".//section[tag!= 'subtext']")),
3398 [])
3399 self.assertEqual(summarize_list(e.findall(".//section[tag != 'subtext']")),
3400 [])
3401 self.assertEqual(summarize_list(e.findall(".//section[ tag != 'subtext' ]")),
3402 [])
3403
3404 self.assertEqual(summarize_list(e.findall(".//tag[.='subtext']")),
3405 ['tag'])
3406 self.assertEqual(summarize_list(e.findall(".//tag[. ='subtext']")),
3407 ['tag'])
3408 self.assertEqual(summarize_list(e.findall('.//tag[.= "subtext"]')),
3409 ['tag'])
3410 self.assertEqual(summarize_list(e.findall('.//tag[ . = "subtext" ]')),
3411 ['tag'])
3412 self.assertEqual(summarize_list(e.findall(".//tag[. = 'subtext']")),
3413 ['tag'])
3414 self.assertEqual(summarize_list(e.findall(".//tag[. = 'subtext ']")),
3415 [])
3416 self.assertEqual(summarize_list(e.findall(".//tag[.= ' subtext']")),
3417 [])
3418
3419 # Negations of above tests.
3420 # Matches everything but the tag containing subtext
3421 self.assertEqual(summarize_list(e.findall(".//tag[.!='subtext']")),
3422 ['tag'] * 3)
3423 self.assertEqual(summarize_list(e.findall(".//tag[. !='subtext']")),
3424 ['tag'] * 3)
3425 self.assertEqual(summarize_list(e.findall('.//tag[.!= "subtext"]')),
3426 ['tag'] * 3)
3427 self.assertEqual(summarize_list(e.findall('.//tag[ . != "subtext" ]')),
3428 ['tag'] * 3)
3429 self.assertEqual(summarize_list(e.findall(".//tag[. != 'subtext']")),
3430 ['tag'] * 3)
3431 # Matches all tags.
3432 self.assertEqual(summarize_list(e.findall(".//tag[. != 'subtext ']")),
3433 ['tag'] * 4)
3434 self.assertEqual(summarize_list(e.findall(".//tag[.!= ' subtext']")),
3435 ['tag'] * 4)
3436
3437 # duplicate section => 2x tag matches
3438 e[1] = e[2]
3439 self.assertEqual(summarize_list(e.findall(".//section[tag = 'subtext']")),
3440 ['section', 'section'])
3441 self.assertEqual(summarize_list(e.findall(".//tag[. = 'subtext']")),
3442 ['tag', 'tag'])
3443
3444 def test_test_find_with_ns(self):
3445 e = ET.XML(SAMPLE_XML_NS)
3446 self.assertEqual(summarize_list(e.findall('tag')), [])
3447 self.assertEqual(
3448 summarize_list(e.findall("{http://effbot.org/ns}tag")),
3449 ['{http://effbot.org/ns}tag'] * 2)
3450 self.assertEqual(
3451 summarize_list(e.findall(".//{http://effbot.org/ns}tag")),
3452 ['{http://effbot.org/ns}tag'] * 3)
3453
3454 def test_findall_different_nsmaps(self):
3455 root = ET.XML('''
3456 <a xmlns:x="X" xmlns:y="Y">
3457 <x:b><c/></x:b>
3458 <b/>
3459 <c><x:b/><b/></c><y:b/>
3460 </a>''')
3461 nsmap = {'xx': 'X'}
3462 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2)
3463 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2)
3464 nsmap = {'xx': 'Y'}
3465 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1)
3466 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2)
3467 nsmap = {'xx': 'X', '': 'Y'}
3468 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2)
3469 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 1)
3470
3471 def test_findall_wildcard(self):
3472 root = ET.XML('''
3473 <a xmlns:x="X" xmlns:y="Y">
3474 <x:b><c/></x:b>
3475 <b/>
3476 <c><x:b/><b/></c><y:b/>
3477 </a>''')
3478 root.append(ET.Comment('test'))
3479
3480 self.assertEqual(summarize_list(root.findall("{*}b")),
3481 ['{X}b', 'b', '{Y}b'])
3482 self.assertEqual(summarize_list(root.findall("{*}c")),
3483 ['c'])
3484 self.assertEqual(summarize_list(root.findall("{X}*")),
3485 ['{X}b'])
3486 self.assertEqual(summarize_list(root.findall("{Y}*")),
3487 ['{Y}b'])
3488 self.assertEqual(summarize_list(root.findall("{}*")),
3489 ['b', 'c'])
3490 self.assertEqual(summarize_list(root.findall("{}b")), # only for consistency
3491 ['b'])
3492 self.assertEqual(summarize_list(root.findall("{}b")),
3493 summarize_list(root.findall("b")))
3494 self.assertEqual(summarize_list(root.findall("{*}*")),
3495 ['{X}b', 'b', 'c', '{Y}b'])
3496 # This is an unfortunate difference, but that's how find('*') works.
3497 self.assertEqual(summarize_list(root.findall("{*}*") + [root[-1]]),
3498 summarize_list(root.findall("*")))
3499
3500 self.assertEqual(summarize_list(root.findall(".//{*}b")),
3501 ['{X}b', 'b', '{X}b', 'b', '{Y}b'])
3502 self.assertEqual(summarize_list(root.findall(".//{*}c")),
3503 ['c', 'c'])
3504 self.assertEqual(summarize_list(root.findall(".//{X}*")),
3505 ['{X}b', '{X}b'])
3506 self.assertEqual(summarize_list(root.findall(".//{Y}*")),
3507 ['{Y}b'])
3508 self.assertEqual(summarize_list(root.findall(".//{}*")),
3509 ['c', 'b', 'c', 'b'])
3510 self.assertEqual(summarize_list(root.findall(".//{}b")), # only for consistency
3511 ['b', 'b'])
3512 self.assertEqual(summarize_list(root.findall(".//{}b")),
3513 summarize_list(root.findall(".//b")))
3514
3515 def test_bad_find(self):
3516 e = ET.XML(SAMPLE_XML)
3517 with self.assertRaisesRegex(SyntaxError, 'cannot use absolute path'):
3518 e.findall('/tag')
3519
3520 def test_find_through_ElementTree(self):
3521 e = ET.XML(SAMPLE_XML)
3522 self.assertEqual(ET.ElementTree(e).find('tag').tag, 'tag')
3523 self.assertEqual(ET.ElementTree(e).findtext('tag'), 'text')
3524 self.assertEqual(summarize_list(ET.ElementTree(e).findall('tag')),
3525 ['tag'] * 2)
3526 # this produces a warning
3527 msg = ("This search is broken in 1.3 and earlier, and will be fixed "
3528 "in a future version. If you rely on the current behaviour, "
3529 "change it to '.+'")
3530 with self.assertWarnsRegex(FutureWarning, msg):
3531 it = ET.ElementTree(e).findall('//tag')
3532 self.assertEqual(summarize_list(it), ['tag'] * 3)
3533
3534
3535 class ElementIterTest(unittest.TestCase):
3536 def _ilist(self, elem, tag=None):
3537 return summarize_list(elem.iter(tag))
3538
3539 def test_basic(self):
3540 doc = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")
3541 self.assertEqual(self._ilist(doc), ['html', 'body', 'i'])
3542 self.assertEqual(self._ilist(doc.find('body')), ['body', 'i'])
3543 self.assertEqual(next(doc.iter()).tag, 'html')
3544 self.assertEqual(''.join(doc.itertext()), 'this is a paragraph...')
3545 self.assertEqual(''.join(doc.find('body').itertext()),
3546 'this is a paragraph.')
3547 self.assertEqual(next(doc.itertext()), 'this is a ')
3548
3549 # iterparse should return an iterator
3550 sourcefile = serialize(doc, to_string=False)
3551 self.assertEqual(next(ET.iterparse(sourcefile))[0], 'end')
3552
3553 # With an explicit parser too (issue #9708)
3554 sourcefile = serialize(doc, to_string=False)
3555 parser = ET.XMLParser(target=ET.TreeBuilder())
3556 self.assertEqual(next(ET.iterparse(sourcefile, parser=parser))[0], 'end')
3557
3558 tree = ET.ElementTree(None)
3559 self.assertRaises(AttributeError, tree.iter)
3560
3561 # Issue #16913
3562 doc = ET.XML("<root>a&amp;<sub>b&amp;</sub>c&amp;</root>")
3563 self.assertEqual(''.join(doc.itertext()), 'a&b&c&')
3564
3565 def test_corners(self):
3566 # single root, no subelements
3567 a = ET.Element('a')
3568 self.assertEqual(self._ilist(a), ['a'])
3569
3570 # one child
3571 b = ET.SubElement(a, 'b')
3572 self.assertEqual(self._ilist(a), ['a', 'b'])
3573
3574 # one child and one grandchild
3575 c = ET.SubElement(b, 'c')
3576 self.assertEqual(self._ilist(a), ['a', 'b', 'c'])
3577
3578 # two children, only first with grandchild
3579 d = ET.SubElement(a, 'd')
3580 self.assertEqual(self._ilist(a), ['a', 'b', 'c', 'd'])
3581
3582 # replace first child by second
3583 a[0] = a[1]
3584 del a[1]
3585 self.assertEqual(self._ilist(a), ['a', 'd'])
3586
3587 def test_iter_by_tag(self):
3588 doc = ET.XML('''
3589 <document>
3590 <house>
3591 <room>bedroom1</room>
3592 <room>bedroom2</room>
3593 </house>
3594 <shed>nothing here
3595 </shed>
3596 <house>
3597 <room>bedroom8</room>
3598 </house>
3599 </document>''')
3600
3601 self.assertEqual(self._ilist(doc, 'room'), ['room'] * 3)
3602 self.assertEqual(self._ilist(doc, 'house'), ['house'] * 2)
3603
3604 # test that iter also accepts 'tag' as a keyword arg
3605 self.assertEqual(
3606 summarize_list(doc.iter(tag='room')),
3607 ['room'] * 3)
3608
3609 # make sure both tag=None and tag='*' return all tags
3610 all_tags = ['document', 'house', 'room', 'room',
3611 'shed', 'house', 'room']
3612 self.assertEqual(summarize_list(doc.iter()), all_tags)
3613 self.assertEqual(self._ilist(doc), all_tags)
3614 self.assertEqual(self._ilist(doc, '*'), all_tags)
3615
3616 def test_copy(self):
3617 a = ET.Element('a')
3618 it = a.iter()
3619 with self.assertRaises(TypeError):
3620 copy.copy(it)
3621
3622 def test_pickle(self):
3623 a = ET.Element('a')
3624 it = a.iter()
3625 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
3626 with self.assertRaises((TypeError, pickle.PicklingError)):
3627 pickle.dumps(it, proto)
3628
3629
3630 class TreeBuilderTest(unittest.TestCase):
3631 sample1 = ('<!DOCTYPE html PUBLIC'
3632 ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
3633 ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
3634 '<html>text<div>subtext</div>tail</html>')
3635
3636 sample2 = '''<toplevel>sometext</toplevel>'''
3637
3638 def _check_sample1_element(self, e):
3639 self.assertEqual(e.tag, 'html')
3640 self.assertEqual(e.text, 'text')
3641 self.assertEqual(e.tail, None)
3642 self.assertEqual(e.attrib, {})
3643 children = list(e)
3644 self.assertEqual(len(children), 1)
3645 child = children[0]
3646 self.assertEqual(child.tag, 'div')
3647 self.assertEqual(child.text, 'subtext')
3648 self.assertEqual(child.tail, 'tail')
3649 self.assertEqual(child.attrib, {})
3650
3651 def test_dummy_builder(self):
3652 class BaseDummyBuilder:
3653 def close(self):
3654 return 42
3655
3656 class DummyBuilder(BaseDummyBuilder):
3657 data = start = end = lambda *a: None
3658
3659 parser = ET.XMLParser(target=DummyBuilder())
3660 parser.feed(self.sample1)
3661 self.assertEqual(parser.close(), 42)
3662
3663 parser = ET.XMLParser(target=BaseDummyBuilder())
3664 parser.feed(self.sample1)
3665 self.assertEqual(parser.close(), 42)
3666
3667 parser = ET.XMLParser(target=object())
3668 parser.feed(self.sample1)
3669 self.assertIsNone(parser.close())
3670
3671 def test_treebuilder_comment(self):
3672 b = ET.TreeBuilder()
3673 self.assertEqual(b.comment('ctext').tag, ET.Comment)
3674 self.assertEqual(b.comment('ctext').text, 'ctext')
3675
3676 b = ET.TreeBuilder(comment_factory=ET.Comment)
3677 self.assertEqual(b.comment('ctext').tag, ET.Comment)
3678 self.assertEqual(b.comment('ctext').text, 'ctext')
3679
3680 b = ET.TreeBuilder(comment_factory=len)
3681 self.assertEqual(b.comment('ctext'), len('ctext'))
3682
3683 def test_treebuilder_pi(self):
3684 b = ET.TreeBuilder()
3685 self.assertEqual(b.pi('target', None).tag, ET.PI)
3686 self.assertEqual(b.pi('target', None).text, 'target')
3687
3688 b = ET.TreeBuilder(pi_factory=ET.PI)
3689 self.assertEqual(b.pi('target').tag, ET.PI)
3690 self.assertEqual(b.pi('target').text, "target")
3691 self.assertEqual(b.pi('pitarget', ' text ').tag, ET.PI)
3692 self.assertEqual(b.pi('pitarget', ' text ').text, "pitarget text ")
3693
3694 b = ET.TreeBuilder(pi_factory=lambda target, text: (len(target), text))
3695 self.assertEqual(b.pi('target'), (len('target'), None))
3696 self.assertEqual(b.pi('pitarget', ' text '), (len('pitarget'), ' text '))
3697
3698 def test_late_tail(self):
3699 # Issue #37399: The tail of an ignored comment could overwrite the text before it.
3700 class TreeBuilderSubclass(ET.TreeBuilder):
3701 pass
3702
3703 xml = "<a>text<!-- comment -->tail</a>"
3704 a = ET.fromstring(xml)
3705 self.assertEqual(a.text, "texttail")
3706
3707 parser = ET.XMLParser(target=TreeBuilderSubclass())
3708 parser.feed(xml)
3709 a = parser.close()
3710 self.assertEqual(a.text, "texttail")
3711
3712 xml = "<a>text<?pi data?>tail</a>"
3713 a = ET.fromstring(xml)
3714 self.assertEqual(a.text, "texttail")
3715
3716 xml = "<a>text<?pi data?>tail</a>"
3717 parser = ET.XMLParser(target=TreeBuilderSubclass())
3718 parser.feed(xml)
3719 a = parser.close()
3720 self.assertEqual(a.text, "texttail")
3721
3722 def test_late_tail_mix_pi_comments(self):
3723 # Issue #37399: The tail of an ignored comment could overwrite the text before it.
3724 # Test appending tails to comments/pis.
3725 class TreeBuilderSubclass(ET.TreeBuilder):
3726 pass
3727
3728 xml = "<a>text<?pi1?> <!-- comment -->\n<?pi2?>tail</a>"
3729 parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True))
3730 parser.feed(xml)
3731 a = parser.close()
3732 self.assertEqual(a[0].text, ' comment ')
3733 self.assertEqual(a[0].tail, '\ntail')
3734 self.assertEqual(a.text, "text ")
3735
3736 parser = ET.XMLParser(target=TreeBuilderSubclass(insert_comments=True))
3737 parser.feed(xml)
3738 a = parser.close()
3739 self.assertEqual(a[0].text, ' comment ')
3740 self.assertEqual(a[0].tail, '\ntail')
3741 self.assertEqual(a.text, "text ")
3742
3743 xml = "<a>text<!-- comment -->\n<?pi data?>tail</a>"
3744 parser = ET.XMLParser(target=ET.TreeBuilder(insert_pis=True))
3745 parser.feed(xml)
3746 a = parser.close()
3747 self.assertEqual(a[0].text, 'pi data')
3748 self.assertEqual(a[0].tail, 'tail')
3749 self.assertEqual(a.text, "text\n")
3750
3751 parser = ET.XMLParser(target=TreeBuilderSubclass(insert_pis=True))
3752 parser.feed(xml)
3753 a = parser.close()
3754 self.assertEqual(a[0].text, 'pi data')
3755 self.assertEqual(a[0].tail, 'tail')
3756 self.assertEqual(a.text, "text\n")
3757
3758 def test_treebuilder_elementfactory_none(self):
3759 parser = ET.XMLParser(target=ET.TreeBuilder(element_factory=None))
3760 parser.feed(self.sample1)
3761 e = parser.close()
3762 self._check_sample1_element(e)
3763
3764 def test_subclass(self):
3765 class MyTreeBuilder(ET.TreeBuilder):
3766 def foobar(self, x):
3767 return x * 2
3768
3769 tb = MyTreeBuilder()
3770 self.assertEqual(tb.foobar(10), 20)
3771
3772 parser = ET.XMLParser(target=tb)
3773 parser.feed(self.sample1)
3774
3775 e = parser.close()
3776 self._check_sample1_element(e)
3777
3778 def test_subclass_comment_pi(self):
3779 class MyTreeBuilder(ET.TreeBuilder):
3780 def foobar(self, x):
3781 return x * 2
3782
3783 tb = MyTreeBuilder(comment_factory=ET.Comment, pi_factory=ET.PI)
3784 self.assertEqual(tb.foobar(10), 20)
3785
3786 parser = ET.XMLParser(target=tb)
3787 parser.feed(self.sample1)
3788 parser.feed('<!-- a comment--><?and a pi?>')
3789
3790 e = parser.close()
3791 self._check_sample1_element(e)
3792
3793 def test_element_factory(self):
3794 lst = []
3795 def myfactory(tag, attrib):
3796 nonlocal lst
3797 lst.append(tag)
3798 return ET.Element(tag, attrib)
3799
3800 tb = ET.TreeBuilder(element_factory=myfactory)
3801 parser = ET.XMLParser(target=tb)
3802 parser.feed(self.sample2)
3803 parser.close()
3804
3805 self.assertEqual(lst, ['toplevel'])
3806
3807 def _check_element_factory_class(self, cls):
3808 tb = ET.TreeBuilder(element_factory=cls)
3809
3810 parser = ET.XMLParser(target=tb)
3811 parser.feed(self.sample1)
3812 e = parser.close()
3813 self.assertIsInstance(e, cls)
3814 self._check_sample1_element(e)
3815
3816 def test_element_factory_subclass(self):
3817 class MyElement(ET.Element):
3818 pass
3819 self._check_element_factory_class(MyElement)
3820
3821 def test_element_factory_pure_python_subclass(self):
3822 # Mimic SimpleTAL's behaviour (issue #16089): both versions of
3823 # TreeBuilder should be able to cope with a subclass of the
3824 # pure Python Element class.
3825 base = ET._Element_Py
3826 # Not from a C extension
3827 self.assertEqual(base.__module__, 'xml.etree.ElementTree')
3828 # Force some multiple inheritance with a C class to make things
3829 # more interesting.
3830 class MyElement(base, ValueError):
3831 pass
3832 self._check_element_factory_class(MyElement)
3833
3834 def test_doctype(self):
3835 class DoctypeParser:
3836 _doctype = None
3837
3838 def doctype(self, name, pubid, system):
3839 self._doctype = (name, pubid, system)
3840
3841 def close(self):
3842 return self._doctype
3843
3844 parser = ET.XMLParser(target=DoctypeParser())
3845 parser.feed(self.sample1)
3846
3847 self.assertEqual(parser.close(),
3848 ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
3849 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'))
3850
3851 def test_builder_lookup_errors(self):
3852 class RaisingBuilder:
3853 def __init__(self, raise_in=None, what=ValueError):
3854 self.raise_in = raise_in
3855 self.what = what
3856
3857 def __getattr__(self, name):
3858 if name == self.raise_in:
3859 raise self.what(self.raise_in)
3860 def handle(*args):
3861 pass
3862 return handle
3863
3864 ET.XMLParser(target=RaisingBuilder())
3865 # cET also checks for 'close' and 'doctype', PyET does it only at need
3866 for event in ('start', 'data', 'end', 'comment', 'pi'):
3867 with self.assertRaisesRegex(ValueError, event):
3868 ET.XMLParser(target=RaisingBuilder(event))
3869
3870 ET.XMLParser(target=RaisingBuilder(what=AttributeError))
3871 for event in ('start', 'data', 'end', 'comment', 'pi'):
3872 parser = ET.XMLParser(target=RaisingBuilder(event, what=AttributeError))
3873 parser.feed(self.sample1)
3874 self.assertIsNone(parser.close())
3875
3876
3877 class XMLParserTest(unittest.TestCase):
3878 sample1 = b'<file><line>22</line></file>'
3879 sample2 = (b'<!DOCTYPE html PUBLIC'
3880 b' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
3881 b' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
3882 b'<html>text</html>')
3883 sample3 = ('<?xml version="1.0" encoding="iso-8859-1"?>\n'
3884 '<money value="$\xa3\u20ac\U0001017b">$\xa3\u20ac\U0001017b</money>')
3885
3886 def _check_sample_element(self, e):
3887 self.assertEqual(e.tag, 'file')
3888 self.assertEqual(e[0].tag, 'line')
3889 self.assertEqual(e[0].text, '22')
3890
3891 def test_constructor_args(self):
3892 parser2 = ET.XMLParser(encoding='utf-8',
3893 target=ET.TreeBuilder())
3894 parser2.feed(self.sample1)
3895 self._check_sample_element(parser2.close())
3896
3897 def test_subclass(self):
3898 class MyParser(ET.XMLParser):
3899 pass
3900 parser = MyParser()
3901 parser.feed(self.sample1)
3902 self._check_sample_element(parser.close())
3903
3904 def test_doctype_warning(self):
3905 with warnings.catch_warnings():
3906 warnings.simplefilter('error', DeprecationWarning)
3907 parser = ET.XMLParser()
3908 parser.feed(self.sample2)
3909 parser.close()
3910
3911 def test_subclass_doctype(self):
3912 _doctype = None
3913 class MyParserWithDoctype(ET.XMLParser):
3914 def doctype(self, *args, **kwargs):
3915 nonlocal _doctype
3916 _doctype = (args, kwargs)
3917
3918 parser = MyParserWithDoctype()
3919 with self.assertWarnsRegex(RuntimeWarning, 'doctype'):
3920 parser.feed(self.sample2)
3921 parser.close()
3922 self.assertIsNone(_doctype)
3923
3924 _doctype = _doctype2 = None
3925 with warnings.catch_warnings():
3926 warnings.simplefilter('error', DeprecationWarning)
3927 warnings.simplefilter('error', RuntimeWarning)
3928 class DoctypeParser:
3929 def doctype(self, name, pubid, system):
3930 nonlocal _doctype2
3931 _doctype2 = (name, pubid, system)
3932
3933 parser = MyParserWithDoctype(target=DoctypeParser())
3934 parser.feed(self.sample2)
3935 parser.close()
3936 self.assertIsNone(_doctype)
3937 self.assertEqual(_doctype2,
3938 ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
3939 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'))
3940
3941 def test_inherited_doctype(self):
3942 '''Ensure that ordinary usage is not deprecated (Issue 19176)'''
3943 with warnings.catch_warnings():
3944 warnings.simplefilter('error', DeprecationWarning)
3945 warnings.simplefilter('error', RuntimeWarning)
3946 class MyParserWithoutDoctype(ET.XMLParser):
3947 pass
3948 parser = MyParserWithoutDoctype()
3949 parser.feed(self.sample2)
3950 parser.close()
3951
3952 def test_parse_string(self):
3953 parser = ET.XMLParser(target=ET.TreeBuilder())
3954 parser.feed(self.sample3)
3955 e = parser.close()
3956 self.assertEqual(e.tag, 'money')
3957 self.assertEqual(e.attrib['value'], '$\xa3\u20ac\U0001017b')
3958 self.assertEqual(e.text, '$\xa3\u20ac\U0001017b')
3959
3960
3961 class NamespaceParseTest(unittest.TestCase):
3962 def test_find_with_namespace(self):
3963 nsmap = {'h': 'hello', 'f': 'foo'}
3964 doc = ET.fromstring(SAMPLE_XML_NS_ELEMS)
3965
3966 self.assertEqual(len(doc.findall('{hello}table', nsmap)), 1)
3967 self.assertEqual(len(doc.findall('.//{hello}td', nsmap)), 2)
3968 self.assertEqual(len(doc.findall('.//{foo}name', nsmap)), 1)
3969
3970
3971 class ElementSlicingTest(unittest.TestCase):
3972 def _elem_tags(self, elemlist):
3973 return [e.tag for e in elemlist]
3974
3975 def _subelem_tags(self, elem):
3976 return self._elem_tags(list(elem))
3977
3978 def _make_elem_with_children(self, numchildren):
3979 """Create an Element with a tag 'a', with the given amount of children
3980 named 'a0', 'a1' ... and so on.
3981
3982 """
3983 e = ET.Element('a')
3984 for i in range(numchildren):
3985 ET.SubElement(e, 'a%s' % i)
3986 return e
3987
3988 def test_getslice_single_index(self):
3989 e = self._make_elem_with_children(10)
3990
3991 self.assertEqual(e[1].tag, 'a1')
3992 self.assertEqual(e[-2].tag, 'a8')
3993
3994 self.assertRaises(IndexError, lambda: e[12])
3995 self.assertRaises(IndexError, lambda: e[-12])
3996
3997 def test_getslice_range(self):
3998 e = self._make_elem_with_children(6)
3999
4000 self.assertEqual(self._elem_tags(e[3:]), ['a3', 'a4', 'a5'])
4001 self.assertEqual(self._elem_tags(e[3:6]), ['a3', 'a4', 'a5'])
4002 self.assertEqual(self._elem_tags(e[3:16]), ['a3', 'a4', 'a5'])
4003 self.assertEqual(self._elem_tags(e[3:5]), ['a3', 'a4'])
4004 self.assertEqual(self._elem_tags(e[3:-1]), ['a3', 'a4'])
4005 self.assertEqual(self._elem_tags(e[:2]), ['a0', 'a1'])
4006
4007 def test_getslice_steps(self):
4008 e = self._make_elem_with_children(10)
4009
4010 self.assertEqual(self._elem_tags(e[8:10:1]), ['a8', 'a9'])
4011 self.assertEqual(self._elem_tags(e[::3]), ['a0', 'a3', 'a6', 'a9'])
4012 self.assertEqual(self._elem_tags(e[::8]), ['a0', 'a8'])
4013 self.assertEqual(self._elem_tags(e[1::8]), ['a1', 'a9'])
4014 self.assertEqual(self._elem_tags(e[3::sys.maxsize]), ['a3'])
4015 self.assertEqual(self._elem_tags(e[3::sys.maxsize<<64]), ['a3'])
4016
4017 def test_getslice_negative_steps(self):
4018 e = self._make_elem_with_children(4)
4019
4020 self.assertEqual(self._elem_tags(e[::-1]), ['a3', 'a2', 'a1', 'a0'])
4021 self.assertEqual(self._elem_tags(e[::-2]), ['a3', 'a1'])
4022 self.assertEqual(self._elem_tags(e[3::-sys.maxsize]), ['a3'])
4023 self.assertEqual(self._elem_tags(e[3::-sys.maxsize-1]), ['a3'])
4024 self.assertEqual(self._elem_tags(e[3::-sys.maxsize<<64]), ['a3'])
4025
4026 def test_delslice(self):
4027 e = self._make_elem_with_children(4)
4028 del e[0:2]
4029 self.assertEqual(self._subelem_tags(e), ['a2', 'a3'])
4030
4031 e = self._make_elem_with_children(4)
4032 del e[0:]
4033 self.assertEqual(self._subelem_tags(e), [])
4034
4035 e = self._make_elem_with_children(4)
4036 del e[::-1]
4037 self.assertEqual(self._subelem_tags(e), [])
4038
4039 e = self._make_elem_with_children(4)
4040 del e[::-2]
4041 self.assertEqual(self._subelem_tags(e), ['a0', 'a2'])
4042
4043 e = self._make_elem_with_children(4)
4044 del e[1::2]
4045 self.assertEqual(self._subelem_tags(e), ['a0', 'a2'])
4046
4047 e = self._make_elem_with_children(2)
4048 del e[::2]
4049 self.assertEqual(self._subelem_tags(e), ['a1'])
4050
4051 def test_setslice_single_index(self):
4052 e = self._make_elem_with_children(4)
4053 e[1] = ET.Element('b')
4054 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4055
4056 e[-2] = ET.Element('c')
4057 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
4058
4059 with self.assertRaises(IndexError):
4060 e[5] = ET.Element('d')
4061 with self.assertRaises(IndexError):
4062 e[-5] = ET.Element('d')
4063 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
4064
4065 def test_setslice_range(self):
4066 e = self._make_elem_with_children(4)
4067 e[1:3] = [ET.Element('b%s' % i) for i in range(2)]
4068 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'a3'])
4069
4070 e = self._make_elem_with_children(4)
4071 e[1:3] = [ET.Element('b')]
4072 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a3'])
4073
4074 e = self._make_elem_with_children(4)
4075 e[1:3] = [ET.Element('b%s' % i) for i in range(3)]
4076 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'b2', 'a3'])
4077
4078 def test_setslice_steps(self):
4079 e = self._make_elem_with_children(6)
4080 e[1:5:2] = [ET.Element('b%s' % i) for i in range(2)]
4081 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'a2', 'b1', 'a4', 'a5'])
4082
4083 e = self._make_elem_with_children(6)
4084 with self.assertRaises(ValueError):
4085 e[1:5:2] = [ET.Element('b')]
4086 with self.assertRaises(ValueError):
4087 e[1:5:2] = [ET.Element('b%s' % i) for i in range(3)]
4088 with self.assertRaises(ValueError):
4089 e[1:5:2] = []
4090 self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3', 'a4', 'a5'])
4091
4092 e = self._make_elem_with_children(4)
4093 e[1::sys.maxsize] = [ET.Element('b')]
4094 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4095 e[1::sys.maxsize<<64] = [ET.Element('c')]
4096 self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
4097
4098 def test_setslice_negative_steps(self):
4099 e = self._make_elem_with_children(4)
4100 e[2:0:-1] = [ET.Element('b%s' % i) for i in range(2)]
4101 self.assertEqual(self._subelem_tags(e), ['a0', 'b1', 'b0', 'a3'])
4102
4103 e = self._make_elem_with_children(4)
4104 with self.assertRaises(ValueError):
4105 e[2:0:-1] = [ET.Element('b')]
4106 with self.assertRaises(ValueError):
4107 e[2:0:-1] = [ET.Element('b%s' % i) for i in range(3)]
4108 with self.assertRaises(ValueError):
4109 e[2:0:-1] = []
4110 self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3'])
4111
4112 e = self._make_elem_with_children(4)
4113 e[1::-sys.maxsize] = [ET.Element('b')]
4114 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4115 e[1::-sys.maxsize-1] = [ET.Element('c')]
4116 self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
4117 e[1::-sys.maxsize<<64] = [ET.Element('d')]
4118 self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3'])
4119
4120 def test_issue123213_setslice_exception(self):
4121 e = ET.Element('tag')
4122 # Does not hide the internal exception when assigning to the element
4123 with self.assertRaises(ZeroDivisionError):
4124 e[:1] = (1/0 for i in range(2))
4125
4126 # Still raises the TypeError when assigning with a non-iterable
4127 with self.assertRaises(TypeError):
4128 e[:1] = None
4129
4130 # Preserve the original TypeError message when assigning.
4131 def f():
4132 raise TypeError("mymessage")
4133
4134 with self.assertRaisesRegex(TypeError, 'mymessage'):
4135 e[:1] = (f() for i in range(2))
4136
4137 class IOTest(unittest.TestCase):
4138 def test_encoding(self):
4139 # Test encoding issues.
4140 elem = ET.Element("tag")
4141 elem.text = "abc"
4142 self.assertEqual(serialize(elem), '<tag>abc</tag>')
4143 for enc in ("utf-8", "us-ascii"):
4144 with self.subTest(enc):
4145 self.assertEqual(serialize(elem, encoding=enc),
4146 b'<tag>abc</tag>')
4147 self.assertEqual(serialize(elem, encoding=enc.upper()),
4148 b'<tag>abc</tag>')
4149 for enc in ("iso-8859-1", "utf-16", "utf-32"):
4150 with self.subTest(enc):
4151 self.assertEqual(serialize(elem, encoding=enc),
4152 ("<?xml version='1.0' encoding='%s'?>\n"
4153 "<tag>abc</tag>" % enc).encode(enc))
4154 upper = enc.upper()
4155 self.assertEqual(serialize(elem, encoding=upper),
4156 ("<?xml version='1.0' encoding='%s'?>\n"
4157 "<tag>abc</tag>" % upper).encode(enc))
4158
4159 elem = ET.Element("tag")
4160 elem.text = "<&\"\'>"
4161 self.assertEqual(serialize(elem), '<tag>&lt;&amp;"\'&gt;</tag>')
4162 self.assertEqual(serialize(elem, encoding="utf-8"),
4163 b'<tag>&lt;&amp;"\'&gt;</tag>')
4164 self.assertEqual(serialize(elem, encoding="us-ascii"),
4165 b'<tag>&lt;&amp;"\'&gt;</tag>')
4166 for enc in ("iso-8859-1", "utf-16", "utf-32"):
4167 self.assertEqual(serialize(elem, encoding=enc),
4168 ("<?xml version='1.0' encoding='%s'?>\n"
4169 "<tag>&lt;&amp;\"'&gt;</tag>" % enc).encode(enc))
4170
4171 elem = ET.Element("tag")
4172 elem.attrib["key"] = "<&\"\'>"
4173 self.assertEqual(serialize(elem), '<tag key="&lt;&amp;&quot;\'&gt;" />')
4174 self.assertEqual(serialize(elem, encoding="utf-8"),
4175 b'<tag key="&lt;&amp;&quot;\'&gt;" />')
4176 self.assertEqual(serialize(elem, encoding="us-ascii"),
4177 b'<tag key="&lt;&amp;&quot;\'&gt;" />')
4178 for enc in ("iso-8859-1", "utf-16", "utf-32"):
4179 self.assertEqual(serialize(elem, encoding=enc),
4180 ("<?xml version='1.0' encoding='%s'?>\n"
4181 "<tag key=\"&lt;&amp;&quot;'&gt;\" />" % enc).encode(enc))
4182
4183 elem = ET.Element("tag")
4184 elem.text = '\xe5\xf6\xf6<>'
4185 self.assertEqual(serialize(elem), '<tag>\xe5\xf6\xf6&lt;&gt;</tag>')
4186 self.assertEqual(serialize(elem, encoding="utf-8"),
4187 b'<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>')
4188 self.assertEqual(serialize(elem, encoding="us-ascii"),
4189 b'<tag>&#229;&#246;&#246;&lt;&gt;</tag>')
4190 for enc in ("iso-8859-1", "utf-16", "utf-32"):
4191 self.assertEqual(serialize(elem, encoding=enc),
4192 ("<?xml version='1.0' encoding='%s'?>\n"
4193 "<tag>åöö&lt;&gt;</tag>" % enc).encode(enc))
4194
4195 elem = ET.Element("tag")
4196 elem.attrib["key"] = '\xe5\xf6\xf6<>'
4197 self.assertEqual(serialize(elem), '<tag key="\xe5\xf6\xf6&lt;&gt;" />')
4198 self.assertEqual(serialize(elem, encoding="utf-8"),
4199 b'<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;" />')
4200 self.assertEqual(serialize(elem, encoding="us-ascii"),
4201 b'<tag key="&#229;&#246;&#246;&lt;&gt;" />')
4202 for enc in ("iso-8859-1", "utf-16", "utf-16le", "utf-16be", "utf-32"):
4203 self.assertEqual(serialize(elem, encoding=enc),
4204 ("<?xml version='1.0' encoding='%s'?>\n"
4205 "<tag key=\"åöö&lt;&gt;\" />" % enc).encode(enc))
4206
4207 def test_write_to_filename(self):
4208 self.addCleanup(os_helper.unlink, TESTFN)
4209 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4210 tree.write(TESTFN)
4211 with open(TESTFN, 'rb') as f:
4212 self.assertEqual(f.read(), b'''<site>&#248;</site>''')
4213
4214 def test_write_to_filename_with_encoding(self):
4215 self.addCleanup(os_helper.unlink, TESTFN)
4216 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4217 tree.write(TESTFN, encoding='utf-8')
4218 with open(TESTFN, 'rb') as f:
4219 self.assertEqual(f.read(), b'''<site>\xc3\xb8</site>''')
4220
4221 tree.write(TESTFN, encoding='ISO-8859-1')
4222 with open(TESTFN, 'rb') as f:
4223 self.assertEqual(f.read(), convlinesep(
4224 b'''<?xml version='1.0' encoding='ISO-8859-1'?>\n'''
4225 b'''<site>\xf8</site>'''))
4226
4227 def test_write_to_filename_as_unicode(self):
4228 self.addCleanup(os_helper.unlink, TESTFN)
4229 with open(TESTFN, 'w') as f:
4230 encoding = f.encoding
4231 os_helper.unlink(TESTFN)
4232
4233 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4234 tree.write(TESTFN, encoding='unicode')
4235 with open(TESTFN, 'rb') as f:
4236 self.assertEqual(f.read(), b"<site>\xc3\xb8</site>")
4237
4238 def test_write_to_text_file(self):
4239 self.addCleanup(os_helper.unlink, TESTFN)
4240 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4241 with open(TESTFN, 'w', encoding='utf-8') as f:
4242 tree.write(f, encoding='unicode')
4243 self.assertFalse(f.closed)
4244 with open(TESTFN, 'rb') as f:
4245 self.assertEqual(f.read(), b'''<site>\xc3\xb8</site>''')
4246
4247 with open(TESTFN, 'w', encoding='ascii', errors='xmlcharrefreplace') as f:
4248 tree.write(f, encoding='unicode')
4249 self.assertFalse(f.closed)
4250 with open(TESTFN, 'rb') as f:
4251 self.assertEqual(f.read(), b'''<site>&#248;</site>''')
4252
4253 with open(TESTFN, 'w', encoding='ISO-8859-1') as f:
4254 tree.write(f, encoding='unicode')
4255 self.assertFalse(f.closed)
4256 with open(TESTFN, 'rb') as f:
4257 self.assertEqual(f.read(), b'''<site>\xf8</site>''')
4258
4259 def test_write_to_binary_file(self):
4260 self.addCleanup(os_helper.unlink, TESTFN)
4261 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4262 with open(TESTFN, 'wb') as f:
4263 tree.write(f)
4264 self.assertFalse(f.closed)
4265 with open(TESTFN, 'rb') as f:
4266 self.assertEqual(f.read(), b'''<site>&#248;</site>''')
4267
4268 def test_write_to_binary_file_with_encoding(self):
4269 self.addCleanup(os_helper.unlink, TESTFN)
4270 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4271 with open(TESTFN, 'wb') as f:
4272 tree.write(f, encoding='utf-8')
4273 self.assertFalse(f.closed)
4274 with open(TESTFN, 'rb') as f:
4275 self.assertEqual(f.read(), b'''<site>\xc3\xb8</site>''')
4276
4277 with open(TESTFN, 'wb') as f:
4278 tree.write(f, encoding='ISO-8859-1')
4279 self.assertFalse(f.closed)
4280 with open(TESTFN, 'rb') as f:
4281 self.assertEqual(f.read(),
4282 b'''<?xml version='1.0' encoding='ISO-8859-1'?>\n'''
4283 b'''<site>\xf8</site>''')
4284
4285 def test_write_to_binary_file_with_bom(self):
4286 self.addCleanup(os_helper.unlink, TESTFN)
4287 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4288 # test BOM writing to buffered file
4289 with open(TESTFN, 'wb') as f:
4290 tree.write(f, encoding='utf-16')
4291 self.assertFalse(f.closed)
4292 with open(TESTFN, 'rb') as f:
4293 self.assertEqual(f.read(),
4294 '''<?xml version='1.0' encoding='utf-16'?>\n'''
4295 '''<site>\xf8</site>'''.encode("utf-16"))
4296 # test BOM writing to non-buffered file
4297 with open(TESTFN, 'wb', buffering=0) as f:
4298 tree.write(f, encoding='utf-16')
4299 self.assertFalse(f.closed)
4300 with open(TESTFN, 'rb') as f:
4301 self.assertEqual(f.read(),
4302 '''<?xml version='1.0' encoding='utf-16'?>\n'''
4303 '''<site>\xf8</site>'''.encode("utf-16"))
4304
4305 def test_read_from_stringio(self):
4306 tree = ET.ElementTree()
4307 stream = io.StringIO('''<?xml version="1.0"?><site></site>''')
4308 tree.parse(stream)
4309 self.assertEqual(tree.getroot().tag, 'site')
4310
4311 def test_write_to_stringio(self):
4312 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4313 stream = io.StringIO()
4314 tree.write(stream, encoding='unicode')
4315 self.assertEqual(stream.getvalue(), '''<site>\xf8</site>''')
4316
4317 def test_read_from_bytesio(self):
4318 tree = ET.ElementTree()
4319 raw = io.BytesIO(b'''<?xml version="1.0"?><site></site>''')
4320 tree.parse(raw)
4321 self.assertEqual(tree.getroot().tag, 'site')
4322
4323 def test_write_to_bytesio(self):
4324 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4325 raw = io.BytesIO()
4326 tree.write(raw)
4327 self.assertEqual(raw.getvalue(), b'''<site>&#248;</site>''')
4328
4329 class dummy:
4330 pass
4331
4332 def test_read_from_user_text_reader(self):
4333 stream = io.StringIO('''<?xml version="1.0"?><site></site>''')
4334 reader = self.dummy()
4335 reader.read = stream.read
4336 tree = ET.ElementTree()
4337 tree.parse(reader)
4338 self.assertEqual(tree.getroot().tag, 'site')
4339
4340 def test_write_to_user_text_writer(self):
4341 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4342 stream = io.StringIO()
4343 writer = self.dummy()
4344 writer.write = stream.write
4345 tree.write(writer, encoding='unicode')
4346 self.assertEqual(stream.getvalue(), '''<site>\xf8</site>''')
4347
4348 def test_read_from_user_binary_reader(self):
4349 raw = io.BytesIO(b'''<?xml version="1.0"?><site></site>''')
4350 reader = self.dummy()
4351 reader.read = raw.read
4352 tree = ET.ElementTree()
4353 tree.parse(reader)
4354 self.assertEqual(tree.getroot().tag, 'site')
4355 tree = ET.ElementTree()
4356
4357 def test_write_to_user_binary_writer(self):
4358 tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
4359 raw = io.BytesIO()
4360 writer = self.dummy()
4361 writer.write = raw.write
4362 tree.write(writer)
4363 self.assertEqual(raw.getvalue(), b'''<site>&#248;</site>''')
4364
4365 def test_write_to_user_binary_writer_with_bom(self):
4366 tree = ET.ElementTree(ET.XML('''<site />'''))
4367 raw = io.BytesIO()
4368 writer = self.dummy()
4369 writer.write = raw.write
4370 writer.seekable = lambda: True
4371 writer.tell = raw.tell
4372 tree.write(writer, encoding="utf-16")
4373 self.assertEqual(raw.getvalue(),
4374 '''<?xml version='1.0' encoding='utf-16'?>\n'''
4375 '''<site />'''.encode("utf-16"))
4376
4377 def test_tostringlist_invariant(self):
4378 root = ET.fromstring('<tag>foo</tag>')
4379 self.assertEqual(
4380 ET.tostring(root, 'unicode'),
4381 ''.join(ET.tostringlist(root, 'unicode')))
4382 self.assertEqual(
4383 ET.tostring(root, 'utf-16'),
4384 b''.join(ET.tostringlist(root, 'utf-16')))
4385
4386 def test_short_empty_elements(self):
4387 root = ET.fromstring('<tag>a<x />b<y></y>c</tag>')
4388 self.assertEqual(
4389 ET.tostring(root, 'unicode'),
4390 '<tag>a<x />b<y />c</tag>')
4391 self.assertEqual(
4392 ET.tostring(root, 'unicode', short_empty_elements=True),
4393 '<tag>a<x />b<y />c</tag>')
4394 self.assertEqual(
4395 ET.tostring(root, 'unicode', short_empty_elements=False),
4396 '<tag>a<x></x>b<y></y>c</tag>')
4397
4398
4399 class ParseErrorTest(unittest.TestCase):
4400 def test_subclass(self):
4401 self.assertIsInstance(ET.ParseError(), SyntaxError)
4402
4403 def _get_error(self, s):
4404 try:
4405 ET.fromstring(s)
4406 except ET.ParseError as e:
4407 return e
4408
4409 def test_error_position(self):
4410 self.assertEqual(self._get_error('foo').position, (1, 0))
4411 self.assertEqual(self._get_error('<tag>&foo;</tag>').position, (1, 5))
4412 self.assertEqual(self._get_error('foobar<').position, (1, 6))
4413
4414 def test_error_code(self):
4415 import xml.parsers.expat.errors as ERRORS
4416 self.assertEqual(self._get_error('foo').code,
4417 ERRORS.codes[ERRORS.XML_ERROR_SYNTAX])
4418
4419
4420 class KeywordArgsTest(unittest.TestCase):
4421 # Test various issues with keyword arguments passed to ET.Element
4422 # constructor and methods
4423 def test_issue14818(self):
4424 x = ET.XML("<a>foo</a>")
4425 self.assertEqual(x.find('a', None),
4426 x.find(path='a', namespaces=None))
4427 self.assertEqual(x.findtext('a', None, None),
4428 x.findtext(path='a', default=None, namespaces=None))
4429 self.assertEqual(x.findall('a', None),
4430 x.findall(path='a', namespaces=None))
4431 self.assertEqual(list(x.iterfind('a', None)),
4432 list(x.iterfind(path='a', namespaces=None)))
4433
4434 self.assertEqual(ET.Element('a').attrib, {})
4435 elements = [
4436 ET.Element('a', dict(href="#", id="foo")),
4437 ET.Element('a', attrib=dict(href="#", id="foo")),
4438 ET.Element('a', dict(href="#"), id="foo"),
4439 ET.Element('a', href="#", id="foo"),
4440 ET.Element('a', dict(href="#", id="foo"), href="#", id="foo"),
4441 ]
4442 for e in elements:
4443 self.assertEqual(e.tag, 'a')
4444 self.assertEqual(e.attrib, dict(href="#", id="foo"))
4445
4446 e2 = ET.SubElement(elements[0], 'foobar', attrib={'key1': 'value1'})
4447 self.assertEqual(e2.attrib['key1'], 'value1')
4448
4449 with self.assertRaisesRegex(TypeError, 'must be dict, not str'):
4450 ET.Element('a', "I'm not a dict")
4451 with self.assertRaisesRegex(TypeError, 'must be dict, not str'):
4452 ET.Element('a', attrib="I'm not a dict")
4453
4454 # --------------------------------------------------------------------
4455
4456 class NoAcceleratorTest(unittest.TestCase):
4457 @classmethod
4458 def setUpClass(cls):
4459 if ET is not pyET:
4460 raise unittest.SkipTest('only for the Python version')
4461
4462 # Test that the C accelerator was not imported for pyET
4463 def test_correct_import_pyET(self):
4464 # The type of methods defined in Python code is types.FunctionType,
4465 # while the type of methods defined inside _elementtree is
4466 # <class 'wrapper_descriptor'>
4467 self.assertIsInstance(pyET.Element.__init__, types.FunctionType)
4468 self.assertIsInstance(pyET.XMLParser.__init__, types.FunctionType)
4469
4470 # --------------------------------------------------------------------
4471
4472 class BoolTest(unittest.TestCase):
4473 def test_warning(self):
4474 e = ET.fromstring('<a style="new"></a>')
4475 msg = (
4476 r"Testing an element's truth value will always return True in "
4477 r"future versions. "
4478 r"Use specific 'len\(elem\)' or 'elem is not None' test instead.")
4479 with self.assertWarnsRegex(DeprecationWarning, msg):
4480 result = bool(e)
4481 # Emulate prior behavior for now
4482 self.assertIs(result, False)
4483
4484 # Element with children
4485 ET.SubElement(e, 'b')
4486 with self.assertWarnsRegex(DeprecationWarning, msg):
4487 new_result = bool(e)
4488 self.assertIs(new_result, True)
4489
4490 # --------------------------------------------------------------------
4491
4492 def c14n_roundtrip(xml, **options):
4493 return pyET.canonicalize(xml, **options)
4494
4495
4496 class C14NTest(unittest.TestCase):
4497 maxDiff = None
4498
4499 #
4500 # simple roundtrip tests (from c14n.py)
4501
4502 def test_simple_roundtrip(self):
4503 # Basics
4504 self.assertEqual(c14n_roundtrip("<doc/>"), '<doc></doc>')
4505 self.assertEqual(c14n_roundtrip("<doc xmlns='uri'/>"), # FIXME
4506 '<doc xmlns="uri"></doc>')
4507 self.assertEqual(c14n_roundtrip("<prefix:doc xmlns:prefix='uri'/>"),
4508 '<prefix:doc xmlns:prefix="uri"></prefix:doc>')
4509 self.assertEqual(c14n_roundtrip("<doc xmlns:prefix='uri'><prefix:bar/></doc>"),
4510 '<doc><prefix:bar xmlns:prefix="uri"></prefix:bar></doc>')
4511 self.assertEqual(c14n_roundtrip("<elem xmlns:wsu='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/' />"),
4512 '<elem></elem>')
4513
4514 # C14N spec
4515 self.assertEqual(c14n_roundtrip("<doc>Hello, world!<!-- Comment 1 --></doc>"),
4516 '<doc>Hello, world!</doc>')
4517 self.assertEqual(c14n_roundtrip("<value>&#x32;</value>"),
4518 '<value>2</value>')
4519 self.assertEqual(c14n_roundtrip('<compute><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></compute>'),
4520 '<compute>value&gt;"0" &amp;&amp; value&lt;"10" ?"valid":"error"</compute>')
4521 self.assertEqual(c14n_roundtrip('''<compute expr='value>"0" &amp;&amp; value&lt;"10" ?"valid":"error"'>valid</compute>'''),
4522 '<compute expr="value>&quot;0&quot; &amp;&amp; value&lt;&quot;10&quot; ?&quot;valid&quot;:&quot;error&quot;">valid</compute>')
4523 self.assertEqual(c14n_roundtrip("<norm attr=' &apos; &#x20;&#13;&#xa;&#9; &apos; '/>"),
4524 '<norm attr=" \' &#xD;&#xA;&#x9; \' "></norm>')
4525 self.assertEqual(c14n_roundtrip("<normNames attr=' A &#x20;&#13;&#xa;&#9; B '/>"),
4526 '<normNames attr=" A &#xD;&#xA;&#x9; B "></normNames>')
4527 self.assertEqual(c14n_roundtrip("<normId id=' &apos; &#x20;&#13;&#xa;&#9; &apos; '/>"),
4528 '<normId id=" \' &#xD;&#xA;&#x9; \' "></normId>')
4529
4530 # fragments from PJ's tests
4531 #self.assertEqual(c14n_roundtrip("<doc xmlns:x='http://example.com/x' xmlns='http://example.com/default'><b y:a1='1' xmlns='http://example.com/default' a3='3' xmlns:y='http://example.com/y' y:a2='2'/></doc>"),
4532 #'<doc xmlns:x="http://example.com/x"><b xmlns:y="http://example.com/y" a3="3" y:a1="1" y:a2="2"></b></doc>')
4533
4534 # Namespace issues
4535 xml = '<X xmlns="http://nps/a"><Y targets="abc,xyz"></Y></X>'
4536 self.assertEqual(c14n_roundtrip(xml), xml)
4537 xml = '<X xmlns="http://nps/a"><Y xmlns="http://nsp/b" targets="abc,xyz"></Y></X>'
4538 self.assertEqual(c14n_roundtrip(xml), xml)
4539 xml = '<X xmlns="http://nps/a"><Y xmlns:b="http://nsp/b" b:targets="abc,xyz"></Y></X>'
4540 self.assertEqual(c14n_roundtrip(xml), xml)
4541
4542 def test_c14n_exclusion(self):
4543 xml = textwrap.dedent("""\
4544 <root xmlns:x="http://example.com/x">
4545 <a x:attr="attrx">
4546 <b>abtext</b>
4547 </a>
4548 <b>btext</b>
4549 <c>
4550 <x:d>dtext</x:d>
4551 </c>
4552 </root>
4553 """)
4554 self.assertEqual(
4555 c14n_roundtrip(xml, strip_text=True),
4556 '<root>'
4557 '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>'
4558 '<b>btext</b>'
4559 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4560 '</root>')
4561 self.assertEqual(
4562 c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr']),
4563 '<root>'
4564 '<a><b>abtext</b></a>'
4565 '<b>btext</b>'
4566 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4567 '</root>')
4568 self.assertEqual(
4569 c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d']),
4570 '<root>'
4571 '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>'
4572 '<b>btext</b>'
4573 '<c></c>'
4574 '</root>')
4575 self.assertEqual(
4576 c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr'],
4577 exclude_tags=['{http://example.com/x}d']),
4578 '<root>'
4579 '<a><b>abtext</b></a>'
4580 '<b>btext</b>'
4581 '<c></c>'
4582 '</root>')
4583 self.assertEqual(
4584 c14n_roundtrip(xml, strip_text=True, exclude_tags=['a', 'b']),
4585 '<root>'
4586 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4587 '</root>')
4588 self.assertEqual(
4589 c14n_roundtrip(xml, exclude_tags=['a', 'b']),
4590 '<root>\n'
4591 ' \n'
4592 ' \n'
4593 ' <c>\n'
4594 ' <x:d xmlns:x="http://example.com/x">dtext</x:d>\n'
4595 ' </c>\n'
4596 '</root>')
4597 self.assertEqual(
4598 c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d', 'b']),
4599 '<root>'
4600 '<a xmlns:x="http://example.com/x" x:attr="attrx"></a>'
4601 '<c></c>'
4602 '</root>')
4603 self.assertEqual(
4604 c14n_roundtrip(xml, exclude_tags=['{http://example.com/x}d', 'b']),
4605 '<root>\n'
4606 ' <a xmlns:x="http://example.com/x" x:attr="attrx">\n'
4607 ' \n'
4608 ' </a>\n'
4609 ' \n'
4610 ' <c>\n'
4611 ' \n'
4612 ' </c>\n'
4613 '</root>')
4614
4615 #
4616 # basic method=c14n tests from the c14n 2.0 specification. uses
4617 # test files under xmltestdata/c14n-20.
4618
4619 # note that this uses generated C14N versions of the standard ET.write
4620 # output, not roundtripped C14N (see above).
4621
4622 def test_xml_c14n2(self):
4623 datadir = findfile("c14n-20", subdir="xmltestdata")
4624 full_path = partial(os.path.join, datadir)
4625
4626 files = [filename[:-4] for filename in sorted(os.listdir(datadir))
4627 if filename.endswith('.xml')]
4628 input_files = [
4629 filename for filename in files
4630 if filename.startswith('in')
4631 ]
4632 configs = {
4633 filename: {
4634 # <c14n2:PrefixRewrite>sequential</c14n2:PrefixRewrite>
4635 option.tag.split('}')[-1]: ((option.text or '').strip(), option)
4636 for option in ET.parse(full_path(filename) + ".xml").getroot()
4637 }
4638 for filename in files
4639 if filename.startswith('c14n')
4640 }
4641
4642 tests = {
4643 input_file: [
4644 (filename, configs[filename.rsplit('_', 1)[-1]])
4645 for filename in files
4646 if filename.startswith(f'out_{input_file}_')
4647 and filename.rsplit('_', 1)[-1] in configs
4648 ]
4649 for input_file in input_files
4650 }
4651
4652 # Make sure we found all test cases.
4653 self.assertEqual(30, len([
4654 output_file for output_files in tests.values()
4655 for output_file in output_files]))
4656
4657 def get_option(config, option_name, default=None):
4658 return config.get(option_name, (default, ()))[0]
4659
4660 for input_file, output_files in tests.items():
4661 for output_file, config in output_files:
4662 keep_comments = get_option(
4663 config, 'IgnoreComments') == 'true' # no, it's right :)
4664 strip_text = get_option(
4665 config, 'TrimTextNodes') == 'true'
4666 rewrite_prefixes = get_option(
4667 config, 'PrefixRewrite') == 'sequential'
4668 if 'QNameAware' in config:
4669 qattrs = [
4670 f"{{{el.get('NS')}}}{el.get('Name')}"
4671 for el in config['QNameAware'][1].findall(
4672 '{http://www.w3.org/2010/xml-c14n2}QualifiedAttr')
4673 ]
4674 qtags = [
4675 f"{{{el.get('NS')}}}{el.get('Name')}"
4676 for el in config['QNameAware'][1].findall(
4677 '{http://www.w3.org/2010/xml-c14n2}Element')
4678 ]
4679 else:
4680 qtags = qattrs = None
4681
4682 # Build subtest description from config.
4683 config_descr = ','.join(
4684 f"{name}={value or ','.join(c.tag.split('}')[-1] for c in children)}"
4685 for name, (value, children) in sorted(config.items())
4686 )
4687
4688 with self.subTest(f"{output_file}({config_descr})"):
4689 if input_file == 'inNsRedecl' and not rewrite_prefixes:
4690 self.skipTest(
4691 f"Redeclared namespace handling is not supported in {output_file}")
4692 if input_file == 'inNsSuperfluous' and not rewrite_prefixes:
4693 self.skipTest(
4694 f"Redeclared namespace handling is not supported in {output_file}")
4695 if 'QNameAware' in config and config['QNameAware'][1].find(
4696 '{http://www.w3.org/2010/xml-c14n2}XPathElement') is not None:
4697 self.skipTest(
4698 f"QName rewriting in XPath text is not supported in {output_file}")
4699
4700 f = full_path(input_file + ".xml")
4701 if input_file == 'inC14N5':
4702 # Hack: avoid setting up external entity resolution in the parser.
4703 with open(full_path('world.txt'), 'rb') as entity_file:
4704 with open(f, 'rb') as f:
4705 f = io.BytesIO(f.read().replace(b'&ent2;', entity_file.read()))
4706
4707 text = ET.canonicalize(
4708 from_file=f,
4709 with_comments=keep_comments,
4710 strip_text=strip_text,
4711 rewrite_prefixes=rewrite_prefixes,
4712 qname_aware_tags=qtags, qname_aware_attrs=qattrs)
4713
4714 with open(full_path(output_file + ".xml"), 'r', encoding='utf8') as f:
4715 expected = f.read()
4716 if input_file == 'inC14N3':
4717 # FIXME: cET resolves default attributes but ET does not!
4718 expected = expected.replace(' attr="default"', '')
4719 text = text.replace(' attr="default"', '')
4720 self.assertEqual(expected, text)
4721
4722 # --------------------------------------------------------------------
4723
4724 def setUpModule(module=None):
4725 # When invoked without a module, runs the Python ET tests by loading pyET.
4726 # Otherwise, uses the given module as the ET.
4727 global pyET
4728 pyET = import_fresh_module('xml.etree.ElementTree',
4729 blocked=['_elementtree'])
4730 if module is None:
4731 module = pyET
4732
4733 global ET
4734 ET = module
4735
4736 # don't interfere with subsequent tests
4737 def cleanup():
4738 global ET, pyET
4739 ET = pyET = None
4740 unittest.addModuleCleanup(cleanup)
4741
4742 # Provide default namespace mapping and path cache.
4743 from xml.etree import ElementPath
4744 nsmap = ET.register_namespace._namespace_map
4745 # Copy the default namespace mapping
4746 nsmap_copy = nsmap.copy()
4747 unittest.addModuleCleanup(nsmap.update, nsmap_copy)
4748 unittest.addModuleCleanup(nsmap.clear)
4749
4750 # Copy the path cache (should be empty)
4751 path_cache = ElementPath._cache
4752 unittest.addModuleCleanup(setattr, ElementPath, "_cache", path_cache)
4753 ElementPath._cache = path_cache.copy()
4754
4755 # Align the Comment/PI factories.
4756 if hasattr(ET, '_set_factories'):
4757 old_factories = ET._set_factories(ET.Comment, ET.PI)
4758 unittest.addModuleCleanup(ET._set_factories, *old_factories)
4759
4760
4761 if __name__ == '__main__':
4762 unittest.main()