1
2
3 """
4 Tests for the ElementTree API
5
6 Only test cases that apply equally well to etree and ElementTree
7 belong here. Note that there is a second test module called test_io.py
8 for IO related test cases.
9 """
10
11 from __future__ import absolute_import
12
13 import copy
14 import io
15 import operator
16 import os
17 import re
18 import sys
19 import textwrap
20 import unittest
21 from contextlib import contextmanager
22 from functools import wraps, partial
23 from itertools import islice
24
25 from .common_imports import (
26 BytesIO, etree, HelperTestCase,
27 ElementTree, cElementTree, ET_VERSION, CET_VERSION,
28 filter_by_version, fileInTestDir, canonicalize, tmpfile,
29 _str, _bytes, unicode, next, IS_PYTHON2
30 )
31
32 if cElementTree is not None and (CET_VERSION <= (1,0,7) or sys.version_info[0] >= 3):
33 cElementTree = None
34
35 if ElementTree is not None:
36 print("Comparing with ElementTree %s" % getattr(ElementTree, "VERSION", "?"))
37
38 if cElementTree is not None:
39 print("Comparing with cElementTree %s" % getattr(cElementTree, "VERSION", "?"))
43 def wrap(method):
44 @wraps(method)
45 def testfunc(self, *args):
46 if self.etree is not etree and sys.version_info < version:
47 raise unittest.SkipTest("requires ET in Python %s" % '.'.join(map(str, version)))
48 return method(self, *args)
49 return testfunc
50 return wrap
51
54 etree = None
55 required_versions_ET = {}
56 required_versions_cET = {}
57
65
66 try:
67 HelperTestCase.assertRegex
68 except AttributeError:
70 return self.assertRegexpMatches(*args, **kwargs)
71
72 @et_needs_pyversion(3, 6)
74
75
76 def check_string(string):
77 len(string)
78 for char in string:
79 self.assertEqual(len(char), 1,
80 msg="expected one-character string, got %r" % char)
81 new_string = string + ""
82 new_string = string + " "
83 string[:0]
84
85 def check_mapping(mapping):
86 len(mapping)
87 keys = mapping.keys()
88 items = mapping.items()
89 for key in keys:
90 item = mapping[key]
91 mapping["key"] = "value"
92 self.assertEqual(mapping["key"], "value",
93 msg="expected value string, got %r" % mapping["key"])
94
95 def check_element(element):
96 self.assertTrue(self.etree.iselement(element), msg="not an element")
97 direlem = dir(element)
98 for attr in 'tag', 'attrib', 'text', 'tail':
99 self.assertTrue(hasattr(element, attr),
100 msg='no %s member' % attr)
101 self.assertIn(attr, direlem,
102 msg='no %s visible by dir' % attr)
103
104 check_string(element.tag)
105 check_mapping(element.attrib)
106 if element.text is not None:
107 check_string(element.text)
108 if element.tail is not None:
109 check_string(element.tail)
110 for elem in element:
111 check_element(elem)
112
113 element = self.etree.Element("tag")
114 check_element(element)
115 tree = self.etree.ElementTree(element)
116 check_element(tree.getroot())
117 element = self.etree.Element(u"t\xe4g", key="value")
118 tree = self.etree.ElementTree(element)
119
120
121 element = self.etree.Element("tag", key="value")
122
123
124
125 def check_method(method):
126 self.assertTrue(hasattr(method, '__call__'),
127 msg="%s not callable" % method)
128
129 check_method(element.append)
130 check_method(element.extend)
131 check_method(element.insert)
132 check_method(element.remove)
133 check_method(element.getchildren)
134 check_method(element.find)
135 check_method(element.iterfind)
136 check_method(element.findall)
137 check_method(element.findtext)
138 check_method(element.clear)
139 check_method(element.get)
140 check_method(element.set)
141 check_method(element.keys)
142 check_method(element.items)
143 check_method(element.iter)
144 check_method(element.itertext)
145 check_method(element.getiterator)
146
147
148
149 def check_iter(it):
150 check_method(it.next if IS_PYTHON2 else it.__next__)
151
152 check_iter(element.iterfind("tag"))
153 check_iter(element.iterfind("*"))
154 check_iter(tree.iterfind("tag"))
155 check_iter(tree.iterfind("*"))
156
157
158
159
160
161 self.assertEqual(self.etree.PI, self.etree.ProcessingInstruction)
162
164 for i in range(10):
165 e = self.etree.Element('foo')
166 self.assertEqual(e.tag, 'foo')
167 self.assertEqual(e.text, None)
168 self.assertEqual(e.tail, None)
169
182
183
193
206
208 Element = self.etree.Element
209 SubElement = self.etree.SubElement
210
211 root1 = Element('root')
212 SubElement(root1, 'one')
213 self.assertTrue(root1[0] in root1)
214
215 root2 = Element('root')
216 SubElement(root2, 'two')
217 SubElement(root2, 'three')
218 self.assertTrue(root2[0] in root2)
219 self.assertTrue(root2[1] in root2)
220
221 self.assertFalse(root1[0] in root2)
222 self.assertFalse(root2[0] in root1)
223 self.assertFalse(None in root2)
224
226 ElementTree = self.etree.ElementTree
227
228 f = BytesIO('<doc>Test<one>One</one></doc>')
229 doc = ElementTree(file=f)
230 root = doc.getroot()
231 self.assertEqual(1, len(root))
232 self.assertEqual('one', root[0].tag)
233 self.assertRaises(IndexError, operator.getitem, root, 1)
234
236 ElementTree = self.etree.ElementTree
237
238 f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
239 doc = ElementTree(file=f)
240 root = doc.getroot()
241 self.assertEqual(3, len(root))
242 self.assertEqual('one', root[0].tag)
243 self.assertEqual('two', root[1].tag)
244 self.assertEqual('three', root[2].tag)
245
247 ElementTree = self.etree.ElementTree
248
249 f = BytesIO('<doc>Test</doc>')
250 doc = ElementTree(file=f)
251 root = doc.getroot()
252 self.assertEqual(0, len(root))
253
255 Element = self.etree.Element
256 SubElement = self.etree.SubElement
257 a = Element('a')
258 b = SubElement(a, 'b')
259 c = SubElement(a, 'c')
260 d = SubElement(a, 'd')
261 self.assertEqual(d, a[-1])
262 self.assertEqual(c, a[-2])
263 self.assertEqual(b, a[-3])
264 self.assertRaises(IndexError, operator.getitem, a, -4)
265 a[-1] = e = Element('e')
266 self.assertEqual(e, a[-1])
267 del a[-1]
268 self.assertEqual(2, len(a))
269
279
280 - def test_text(self):
281 ElementTree = self.etree.ElementTree
282
283 f = BytesIO('<doc>This is a text</doc>')
284 doc = ElementTree(file=f)
285 root = doc.getroot()
286 self.assertEqual('This is a text', root.text)
287
288 - def test_text_empty(self):
289 ElementTree = self.etree.ElementTree
290
291 f = BytesIO('<doc></doc>')
292 doc = ElementTree(file=f)
293 root = doc.getroot()
294 self.assertEqual(None, root.text)
295
296 - def test_text_other(self):
297 ElementTree = self.etree.ElementTree
298
299 f = BytesIO('<doc><one>One</one></doc>')
300 doc = ElementTree(file=f)
301 root = doc.getroot()
302 self.assertEqual(None, root.text)
303 self.assertEqual('One', root[0].text)
304
306 ElementTree = self.etree.ElementTree
307
308 f = BytesIO('<doc>This is > than a text</doc>')
309 doc = ElementTree(file=f)
310 root = doc.getroot()
311 self.assertEqual('This is > than a text', root.text)
312
314 Element = self.etree.Element
315
316 a = Element("a")
317 a.text = "<>&"
318 self.assertXML(_bytes('<a><>&</a>'),
319 a)
320
322 tostring = self.etree.tostring
323 Element = self.etree.Element
324
325 a = Element("a")
326 a.text = "<>&"
327 self.assertEqual(_bytes('<a><>&</a>'),
328 tostring(a))
329
331 Element = self.etree.Element
332
333 class strTest(str):
334 pass
335
336 a = Element("a")
337 a.text = strTest("text")
338 self.assertXML(_bytes('<a>text</a>'),
339 a)
340
352
359
360 a = Element("a")
361 SubElement(a, "t").tail = strTest("tail")
362 self.assertXML(_bytes('<a><t></t>tail</a>'),
363 a)
364
366
367 XML = self.etree.XML
368
369 root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>'))
370 self.assertEqual(1, len(root))
371 self.assertEqual('This is ', root.text)
372 self.assertEqual(None, root.tail)
373 self.assertEqual('mixed', root[0].text)
374 self.assertEqual(' content.', root[0].tail)
375
376 del root[0].tail
377
378 self.assertEqual(1, len(root))
379 self.assertEqual('This is ', root.text)
380 self.assertEqual(None, root.tail)
381 self.assertEqual('mixed', root[0].text)
382 self.assertEqual(None, root[0].tail)
383
384 root[0].tail = "TAIL"
385
386 self.assertEqual(1, len(root))
387 self.assertEqual('This is ', root.text)
388 self.assertEqual(None, root.tail)
389 self.assertEqual('mixed', root[0].text)
390 self.assertEqual('TAIL', root[0].tail)
391
401
411
422
433
444
455
466
476
487
489 Element = self.etree.Element
490 SubElement = self.etree.SubElement
491
492 attribNS = '{http://foo/bar}x'
493
494 parent = Element('parent')
495 parent.set(attribNS, 'a')
496 child = SubElement(parent, 'child')
497 child.set(attribNS, 'b')
498
499 self.assertEqual('a', parent.get(attribNS))
500 self.assertEqual('b', child.get(attribNS))
501
502 parent.clear()
503 self.assertEqual(None, parent.get(attribNS))
504 self.assertEqual('b', child.get(attribNS))
505
519
526
530
534
538
540 XML = self.etree.XML
541
542 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
543 items = list(root.attrib.items())
544 items.sort()
545 self.assertEqual(
546 [('alpha', 'Alpha'), ('beta', 'Beta')],
547 items)
548
549 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
550
551 items = list(root.attrib.items())
552 items.sort()
553 self.assertEqual(
554 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
555 items)
556
558 XML = self.etree.XML
559
560 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
561 items = list(root.attrib.items())
562 items.sort()
563 self.assertEqual(
564 [('alpha', 'Alpha'), ('beta', 'Beta')],
565 items)
566
567 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
568
569 items = list(root.attrib.items())
570 items.sort()
571 self.assertEqual(
572 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
573 items)
574
576 XML = self.etree.XML
577
578 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
579 items = list(root.attrib.items())
580 items.sort()
581 self.assertEqual(
582 [('alpha', 'Alpha'), ('beta', 'Beta')],
583 items)
584
585 root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items()))
586
587 items = list(root.attrib.items())
588 items.sort()
589 self.assertEqual(
590 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
591 items)
592
594 XML = self.etree.XML
595
596 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
597 items = list(root.attrib.items())
598 items.sort()
599 self.assertEqual(
600 [('alpha', 'Alpha'), ('beta', 'Beta')],
601 items)
602
603 other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>'))
604 root.attrib.update(other.attrib)
605
606 items = list(root.attrib.items())
607 items.sort()
608 self.assertEqual(
609 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
610 items)
611
619
627
629 XML = self.etree.XML
630
631 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
632 items = list(root.items())
633 items.sort()
634 self.assertEqual(
635 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
636 items)
637
639 XML = self.etree.XML
640
641 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
642 keys = list(root.keys())
643 keys.sort()
644 self.assertEqual(['bar', '{http://ns.codespeak.net/test}baz'],
645 keys)
646
654
663
676
678 XML = self.etree.XML
679
680 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
681 items = list(root.attrib.items())
682 items.sort()
683 self.assertEqual(
684 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
685 items)
686
688 XML = self.etree.XML
689
690 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
691 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
692
693 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
694 try:
695 self.assertEqual(expected, str(root.attrib))
696 except AssertionError:
697 self.assertEqual(alternative, str(root.attrib))
698
700 XML = self.etree.XML
701
702 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
703 self.assertEqual(
704 True, 'bar' in root.attrib)
705 self.assertEqual(
706 False, 'baz' in root.attrib)
707 self.assertEqual(
708 False, 'hah' in root.attrib)
709 self.assertEqual(
710 True,
711 '{http://ns.codespeak.net/test}baz' in root.attrib)
712
719
729
731 XML = self.etree.XML
732
733 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />'))
734 result = []
735 for key in root.attrib:
736 result.append(key)
737 result.sort()
738 self.assertEqual(['alpha', 'beta', 'gamma'], result)
739
749
751 Element = self.etree.Element
752
753 a = Element('a')
754 a.attrib['{http://a/}foo'] = 'Foo'
755 a.attrib['{http://a/}bar'] = 'Bar'
756 self.assertEqual(None, a.get('foo'))
757 self.assertEqual('Foo', a.get('{http://a/}foo'))
758 self.assertEqual('Foo', a.attrib['{http://a/}foo'])
759
760 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
761 self.assertEqual('Foo', a.attrib['{http://a/}foo'])
762
763 del a.attrib['{http://a/}foo']
764 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
765
767 XML = self.etree.XML
768
769 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />'))
770
771 self.assertEqual('Foo', a.attrib['foo'])
772 self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
773
774 del a.attrib['foo']
775 self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
776 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
777 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
778
779 del a.attrib['{http://a/}foo']
780 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
781 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
782
783 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />'))
784
785 self.assertEqual('Foo', a.attrib['foo'])
786 self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
787
788 del a.attrib['foo']
789 self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
790 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
791
792 del a.attrib['{http://a/}foo']
793 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
794 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
795
802
804 XMLID = self.etree.XMLID
805 XML = self.etree.XML
806 xml_text = _bytes('''
807 <document>
808 <h1 id="chapter1">...</h1>
809 <p id="note1" class="note">...</p>
810 <p>Regular paragraph.</p>
811 <p xml:id="xmlid">XML:ID paragraph.</p>
812 <p id="warn1" class="warning">...</p>
813 </document>
814 ''')
815
816 root, dic = XMLID(xml_text)
817 root2 = XML(xml_text)
818 self.assertEqual(self._writeElement(root),
819 self._writeElement(root2))
820 expected = {
821 "chapter1" : root[0],
822 "note1" : root[1],
823 "warn1" : root[4]
824 }
825 self.assertEqual(dic, expected)
826
833
834 required_versions_ET['test_fromstringlist'] = (1,3)
842
843 required_versions_ET['test_fromstringlist_characters'] = (1,3)
850
851 required_versions_ET['test_fromstringlist_single'] = (1,3)
858
882
884 XML = self.etree.XML
885
886 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
887 result = []
888 for el in root:
889 result.append(el.tag)
890 self.assertEqual(['one', 'two', 'three'], result)
891
900
902 XML = self.etree.XML
903
904 root = XML(_bytes('<doc>Text</doc>'))
905 result = []
906 for el in root:
907 result.append(el.tag)
908 self.assertEqual([], result)
909
916
923
925 XML = self.etree.XML
926 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
927 result = []
928 for el in reversed(root):
929 result.append(el.tag)
930 self.assertEqual(['three', 'two', 'one'], result)
931
944
946 XML = self.etree.XML
947
948 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
949 result = []
950 for el in root:
951 result.append(el.tag)
952 del root[-1]
953 self.assertEqual(['one', 'two'], result)
954
956 XML = self.etree.XML
957
958 root = XML(_bytes('<doc><one/><two/></doc>'))
959 result = []
960 for el0 in root:
961 result.append(el0.tag)
962 for el1 in root:
963 result.append(el1.tag)
964 self.assertEqual(['one','one', 'two', 'two', 'one', 'two'], result)
965
966 required_versions_ET['test_itertext'] = (1,3)
967 - def test_itertext(self):
968
969 XML = self.etree.XML
970 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
971
972 text = list(root.itertext())
973 self.assertEqual(["RTEXT", "ATAIL", "CTEXT", "CTAIL"],
974 text)
975
976 required_versions_ET['test_itertext_child'] = (1,3)
978
979 XML = self.etree.XML
980 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
981
982 text = list(root[2].itertext())
983 self.assertEqual(["CTEXT"],
984 text)
985
995
997 XML = self.etree.XML
998 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
999 self.assertEqual(len(list(root.findall(".//{X}b"))), 2)
1000 self.assertEqual(len(list(root.findall(".//b"))), 3)
1001 self.assertEqual(len(list(root.findall("b"))), 2)
1002
1003 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
1005 def summarize_list(l):
1006 return [el.tag for el in l]
1007
1008 root = self.etree.XML('''
1009 <a xmlns:x="X" xmlns:y="Y">
1010 <x:b><c/></x:b>
1011 <b/>
1012 <c><x:b/><b/></c><y:b/>
1013 </a>''')
1014 root.append(self.etree.Comment('test'))
1015
1016 self.assertEqual(summarize_list(root.findall("{*}b")),
1017 ['{X}b', 'b', '{Y}b'])
1018 self.assertEqual(summarize_list(root.findall("{*}c")),
1019 ['c'])
1020 self.assertEqual(summarize_list(root.findall("{X}*")),
1021 ['{X}b'])
1022 self.assertEqual(summarize_list(root.findall("{Y}*")),
1023 ['{Y}b'])
1024 self.assertEqual(summarize_list(root.findall("{}*")),
1025 ['b', 'c'])
1026 self.assertEqual(summarize_list(root.findall("{}b")),
1027 ['b'])
1028 self.assertEqual(summarize_list(root.findall("{}b")),
1029 summarize_list(root.findall("b")))
1030 self.assertEqual(summarize_list(root.findall("{*}*")),
1031 ['{X}b', 'b', 'c', '{Y}b'])
1032 self.assertEqual(summarize_list(root.findall("{*}*")
1033 + ([] if self.etree is etree else [root[-1]])),
1034 summarize_list(root.findall("*")))
1035
1036 self.assertEqual(summarize_list(root.findall(".//{*}b")),
1037 ['{X}b', 'b', '{X}b', 'b', '{Y}b'])
1038 self.assertEqual(summarize_list(root.findall(".//{*}c")),
1039 ['c', 'c'])
1040 self.assertEqual(summarize_list(root.findall(".//{X}*")),
1041 ['{X}b', '{X}b'])
1042 self.assertEqual(summarize_list(root.findall(".//{Y}*")),
1043 ['{Y}b'])
1044 self.assertEqual(summarize_list(root.findall(".//{}*")),
1045 ['c', 'b', 'c', 'b'])
1046 self.assertEqual(summarize_list(root.findall(".//{}b")),
1047 ['b', 'b'])
1048
1055
1062
1064 Element = self.etree.Element
1065
1066 el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, baz='Baz')
1067 self.assertEqual('Foo', el.attrib['foo'])
1068 self.assertEqual('Bar', el.attrib['bar'])
1069 self.assertEqual('Baz', el.attrib['baz'])
1070
1072 Element = self.etree.Element
1073
1074 el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, bar='Baz')
1075 self.assertEqual('Foo', el.attrib['foo'])
1076 self.assertEqual('Baz', el.attrib['bar'])
1077
1079 Element = self.etree.Element
1080
1081 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
1082 self.assertEqual('Foo', el.attrib['{ns1}foo'])
1083 self.assertEqual('Bar', el.attrib['{ns2}bar'])
1084
1093
1102
1116
1117 required_versions_ET['test_write_method_html'] = (1,3)
1136
1137 required_versions_ET['test_write_method_text'] = (1,3)
1139 ElementTree = self.etree.ElementTree
1140 Element = self.etree.Element
1141 SubElement = self.etree.SubElement
1142
1143 a = Element('a')
1144 a.text = "A"
1145 a.tail = "tail"
1146 b = SubElement(a, 'b')
1147 b.text = "B"
1148 b.tail = "TAIL"
1149 c = SubElement(a, 'c')
1150 c.text = "C"
1151
1152 tree = ElementTree(element=a)
1153 f = BytesIO()
1154 tree.write(f, method="text")
1155 data = f.getvalue()
1156
1157 self.assertEqual(_bytes('ABTAILCtail'),
1158 data)
1159
1167
1168
1169
1178
1179
1191
1214
1215 - def test_set_text(self):
1216 Element = self.etree.Element
1217 SubElement = self.etree.SubElement
1218
1219 a = Element('a')
1220 b = SubElement(a, 'b')
1221 a.text = 'hoi'
1222 self.assertEqual(
1223 'hoi',
1224 a.text)
1225 self.assertEqual(
1226 'b',
1227 a[0].tag)
1228
1229 - def test_set_text2(self):
1230 Element = self.etree.Element
1231 SubElement = self.etree.SubElement
1232
1233 a = Element('a')
1234 a.text = 'hoi'
1235 b = SubElement(a ,'b')
1236 self.assertEqual(
1237 'hoi',
1238 a.text)
1239 self.assertEqual(
1240 'b',
1241 a[0].tag)
1242
1244 Element = self.etree.Element
1245
1246 a = Element('a')
1247
1248 a.text = 'foo'
1249 a.text = None
1250
1251 self.assertEqual(
1252 None,
1253 a.text)
1254 self.assertXML(_bytes('<a></a>'), a)
1255
1257 Element = self.etree.Element
1258
1259 a = Element('a')
1260 self.assertEqual(None, a.text)
1261
1262 a.text = ''
1263 self.assertEqual('', a.text)
1264 self.assertXML(_bytes('<a></a>'), a)
1265
1280
1290
1302
1312
1313 required_versions_ET['test_extend'] = (1,3)
1315 root = self.etree.Element('foo')
1316 for i in range(3):
1317 element = self.etree.SubElement(root, 'a%s' % i)
1318 element.text = "text%d" % i
1319 element.tail = "tail%d" % i
1320
1321 elements = []
1322 for i in range(3):
1323 new_element = self.etree.Element("test%s" % i)
1324 new_element.text = "TEXT%s" % i
1325 new_element.tail = "TAIL%s" % i
1326 elements.append(new_element)
1327
1328 root.extend(elements)
1329
1330 self.assertEqual(
1331 ["a0", "a1", "a2", "test0", "test1", "test2"],
1332 [ el.tag for el in root ])
1333 self.assertEqual(
1334 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
1335 [ el.text for el in root ])
1336 self.assertEqual(
1337 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
1338 [ el.tail for el in root ])
1339
1349
1350
1351 required_versions_ET['test_comment_text'] = (1,3)
1372
1373
1374 required_versions_ET['test_comment_whitespace'] = (1,3)
1387
1399
1411
1423
1425 ProcessingInstruction = self.etree.ProcessingInstruction
1426 pi = ProcessingInstruction('foo')
1427 self.assertEqual({}, pi.attrib)
1428 self.assertEqual([], list(pi.keys()))
1429 self.assertEqual([], list(pi.items()))
1430 self.assertEqual(None, pi.get('hoi'))
1431 self.assertEqual(0, len(pi))
1432
1433 for i in pi:
1434 pass
1435
1451
1469
1479
1488
1503
1520
1538
1557
1563
1564 a = Element("a")
1565 a.tag = strTest("TAG")
1566 self.assertXML(_bytes('<TAG></TAG>'),
1567 a)
1568
1598
1600 Element = self.etree.Element
1601 SubElement = self.etree.SubElement
1602
1603 a = Element('a')
1604 b = SubElement(a, 'b')
1605 bs = SubElement(b, 'bs')
1606 c = SubElement(a, 'c')
1607 cs = SubElement(c, 'cs')
1608
1609 el = a[0]
1610 self.assertXML(
1611 _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
1612 a)
1613 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1614 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1615
1616 del a[0]
1617 self.assertXML(
1618 _bytes('<a><c><cs></cs></c></a>'),
1619 a)
1620 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1621 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1622
1623 a.insert(0, el)
1624 self.assertXML(
1625 _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
1626 a)
1627 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1628 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1629
1648
1667
1669 XML = self.etree.XML
1670 a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
1671 b, c = a
1672
1673 a[:] = []
1674
1675 self.assertEqual("B2", b.tail)
1676 self.assertEqual("C2", c.tail)
1677
1679 XML = self.etree.XML
1680 root = XML(_bytes(
1681 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>'))
1682 root[:] = root.findall('.//puh')
1683
1684
1685 result = self.etree.tostring(root)
1686 foo = self.etree.fromstring(result)
1687
1688 self.assertEqual('puh', foo[0].tag)
1689 self.assertEqual('{http://huhu}bump1', foo[0][0].tag)
1690 self.assertEqual('{http://huhu}bump2', foo[0][1].tag)
1691
1701
1714
1716 Element = self.etree.Element
1717
1718 a = Element('a')
1719 a.text = 'foo'
1720 a.tail = 'bar'
1721 a.set('hoi', 'dag')
1722 a.clear()
1723 self.assertEqual(None, a.text)
1724 self.assertEqual(None, a.tail)
1725 self.assertEqual(None, a.get('hoi'))
1726 self.assertEqual('a', a.tag)
1727
1729 Element = self.etree.Element
1730 SubElement = self.etree.SubElement
1731
1732 a = Element('a')
1733 a.text = 'foo'
1734 a.tail = 'bar'
1735 a.set('hoi', 'dag')
1736 b = SubElement(a, 'b')
1737 c = SubElement(b, 'c')
1738 a.clear()
1739 self.assertEqual(None, a.text)
1740 self.assertEqual(None, a.tail)
1741 self.assertEqual(None, a.get('hoi'))
1742 self.assertEqual('a', a.tag)
1743 self.assertEqual(0, len(a))
1744 self.assertXML(_bytes('<a></a>'),
1745 a)
1746 self.assertXML(_bytes('<b><c></c></b>'),
1747 b)
1748
1758
1785
1787
1788 Element = self.etree.Element
1789 SubElement = self.etree.SubElement
1790
1791
1792 import uuid
1793 names = dict((k, 'tag-' + str(uuid.uuid4())) for k in 'abcde')
1794
1795 a = Element(names['a'])
1796 b = SubElement(a, names['b'])
1797 c = SubElement(a, names['c'])
1798 d = Element(names['d'])
1799 a.insert(0, d)
1800
1801 self.assertEqual(
1802 d,
1803 a[0])
1804
1805 self.assertXML(
1806 _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(c)s></%(c)s></%(a)s>' % names),
1807 a)
1808
1809 e = Element(names['e'])
1810 a.insert(2, e)
1811 self.assertEqual(
1812 e,
1813 a[2])
1814 self.assertXML(
1815 _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(e)s></%(e)s><%(c)s></%(c)s></%(a)s>' % names),
1816 a)
1817
1833
1850
1865
1881
1897
1908
1921
1935
1957
1966
1967 required_versions_ET['test_iter'] = (1,3)
1969 Element = self.etree.Element
1970 SubElement = self.etree.SubElement
1971
1972 a = Element('a')
1973 b = SubElement(a, 'b')
1974 c = SubElement(a, 'c')
1975 d = SubElement(b, 'd')
1976 e = SubElement(c, 'e')
1977
1978 self.assertEqual(
1979 [a, b, d, c, e],
1980 list(a.iter()))
1981 self.assertEqual(
1982 [d],
1983 list(d.iter()))
1984
2012
2014 Element = self.etree.Element
2015 SubElement = self.etree.SubElement
2016
2017 a = Element('a')
2018 b = SubElement(a, 'b')
2019 c = SubElement(a, 'c')
2020 d = SubElement(b, 'd')
2021 e = SubElement(c, 'e')
2022
2023 self.assertEqual(
2024 [a, b, d, c, e],
2025 list(a.getiterator()))
2026 self.assertEqual(
2027 [d],
2028 list(d.getiterator()))
2029
2049
2070
2084
2109
2134
2136 Element = self.etree.Element
2137 SubElement = self.etree.SubElement
2138
2139 a = Element('a')
2140 a.text = 'a'
2141 b = SubElement(a, 'b')
2142 b.text = 'b'
2143 b.tail = 'b1'
2144 c = SubElement(a, 'c')
2145 c.text = 'c'
2146 c.tail = 'c1'
2147 d = SubElement(b, 'd')
2148 d.text = 'd'
2149 d.tail = 'd1'
2150 e = SubElement(c, 'e')
2151 e.text = 'e'
2152 e.tail = 'e1'
2153
2154 self.assertEqual(
2155 [a, b, d, c, e],
2156 list(a.getiterator()))
2157
2158
2159
2160
2162 Element = self.etree.Element
2163 SubElement = self.etree.SubElement
2164
2165 a = Element('a')
2166 a.text = 'a'
2167 b = SubElement(a, 'b')
2168 b.text = 'b'
2169 b.tail = 'b1'
2170 c = SubElement(a, 'c')
2171 c.text = 'c'
2172 c.tail = 'c1'
2173 d = SubElement(b, 'd')
2174 d.text = 'd'
2175 d.tail = 'd1'
2176 e = SubElement(c, 'e')
2177 e.text = 'e'
2178 e.tail = 'e1'
2179
2180 self.assertEqual(
2181 [a],
2182 list(a.getiterator('a')))
2183 a2 = SubElement(e, 'a')
2184 self.assertEqual(
2185 [a, a2],
2186 list(a.getiterator('a')))
2187 self.assertEqual(
2188 [a2],
2189 list(e.getiterator('a')))
2190
2192 Element = self.etree.Element
2193 SubElement = self.etree.SubElement
2194
2195 a = Element('a')
2196 b = SubElement(a, 'b')
2197 c = SubElement(a, 'c')
2198 d = SubElement(a, 'd')
2199
2200 self.assertEqual(
2201 [b, c],
2202 a[0:2])
2203 self.assertEqual(
2204 [b, c, d],
2205 a[:])
2206 self.assertEqual(
2207 [b, c, d],
2208 a[:10])
2209 self.assertEqual(
2210 [b],
2211 a[0:1])
2212 self.assertEqual(
2213 [],
2214 a[10:12])
2215
2217 Element = self.etree.Element
2218 SubElement = self.etree.SubElement
2219
2220 a = Element('a')
2221 b = SubElement(a, 'b')
2222 c = SubElement(a, 'c')
2223 d = SubElement(a, 'd')
2224
2225 self.assertEqual(
2226 [d],
2227 a[-1:])
2228 self.assertEqual(
2229 [c, d],
2230 a[-2:])
2231 self.assertEqual(
2232 [c],
2233 a[-2:-1])
2234 self.assertEqual(
2235 [b, c],
2236 a[-3:-1])
2237 self.assertEqual(
2238 [b, c],
2239 a[-3:2])
2240
2242 Element = self.etree.Element
2243 SubElement = self.etree.SubElement
2244
2245 a = Element('a')
2246 b = SubElement(a, 'b')
2247 c = SubElement(a, 'c')
2248 d = SubElement(a, 'd')
2249 e = SubElement(a, 'e')
2250
2251 self.assertEqual(
2252 [e,d,c,b],
2253 a[::-1])
2254 self.assertEqual(
2255 [b,d],
2256 a[::2])
2257 self.assertEqual(
2258 [e,c],
2259 a[::-2])
2260 self.assertEqual(
2261 [d,c],
2262 a[-2:0:-1])
2263 self.assertEqual(
2264 [e],
2265 a[:1:-2])
2266
2268 ElementTree = self.etree.ElementTree
2269
2270 f = BytesIO('<a><b>B</b>B1<c>C</c>C1</a>')
2271 doc = ElementTree(file=f)
2272 a = doc.getroot()
2273 b = a[0]
2274 c = a[1]
2275 self.assertEqual(
2276 [b, c],
2277 a[:])
2278 self.assertEqual(
2279 [b],
2280 a[0:1])
2281 self.assertEqual(
2282 [c],
2283 a[1:])
2284
2308
2323
2338
2353
2368
2383
2398
2408
2410 ElementTree = self.etree.ElementTree
2411 f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
2412 doc = ElementTree(file=f)
2413 a = doc.getroot()
2414 b, c, d, e = a
2415 del a[1:3]
2416 self.assertXML(
2417 _bytes('<a><b></b>B2<e></e>E2</a>'),
2418 a)
2419 self.assertEqual("B2", b.tail)
2420 self.assertEqual("C2", c.tail)
2421 self.assertEqual("D2", d.tail)
2422 self.assertEqual("E2", e.tail)
2423
2425 XML = self.etree.XML
2426 a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
2427 b, c = a
2428
2429 del a[:]
2430
2431 self.assertEqual("B2", b.tail)
2432 self.assertEqual("C2", c.tail)
2433
2444
2446 Element = self.etree.Element
2447 SubElement = self.etree.SubElement
2448
2449 a = Element('a')
2450 b = SubElement(a, 'b')
2451 c = SubElement(a, 'c')
2452 d = SubElement(a, 'd')
2453
2454 e = Element('e')
2455 f = Element('f')
2456 g = Element('g')
2457
2458 s = [e, f, g]
2459 a[1:2] = s
2460 self.assertEqual(
2461 [b, e, f, g, d],
2462 list(a))
2463
2481
2497
2512
2527
2529 Element = self.etree.Element
2530 SubElement = self.etree.SubElement
2531
2532 a = Element('{ns}a')
2533 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
2534 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
2535 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
2536
2537 s = [d, c, b]
2538 a[:] = s
2539 self.assertEqual(
2540 [d, c, b],
2541 list(a))
2542 self.assertEqual(
2543 ['{ns}d', '{ns}c', '{ns}b'],
2544 [ child.tag for child in a ])
2545
2546 self.assertEqual(
2547 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
2548 [ list(child.attrib.keys()) for child in a ])
2549
2551 Element = self.etree.Element
2552 SubElement = self.etree.SubElement
2553
2554 a = Element('{ns}a')
2555 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
2556 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
2557 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
2558
2559 s = [d, c, b]
2560 a[:] = s
2561 self.assertEqual(
2562 [d, c, b],
2563 list(a))
2564 self.assertEqual(
2565 ['{ns3}d', '{ns2}c', '{ns1}b'],
2566 [ child.tag for child in a ])
2567
2568 self.assertEqual(
2569 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
2570 [ list(child.attrib.keys()) for child in a ])
2571
2573 Element = self.etree.Element
2574 SubElement = self.etree.SubElement
2575
2576 a = Element('a')
2577 b = SubElement(a, 'b')
2578 c = SubElement(a, 'c')
2579
2580 e = Element('e')
2581 f = Element('f')
2582 g = Element('g')
2583 h = Element('h')
2584
2585 s = [e, f]
2586 a[99:] = s
2587 self.assertEqual(
2588 [b, c, e, f],
2589 list(a))
2590
2591 s = [g, h]
2592 a[:0] = s
2593 self.assertEqual(
2594 [g, h, b, c, e, f],
2595 list(a))
2596
2598 Element = self.etree.Element
2599 SubElement = self.etree.SubElement
2600
2601 a = Element('a')
2602 b = SubElement(a, 'b')
2603 c = SubElement(a, 'c')
2604 d = SubElement(a, 'd')
2605
2606 e = Element('e')
2607 f = Element('f')
2608 g = Element('g')
2609
2610 s = [e, f, g]
2611 a[3:] = s
2612 self.assertEqual(
2613 [b, c, d, e, f, g],
2614 list(a))
2615
2638
2655
2672
2689
2702
2712
2728
2747
2758
2760 ElementTree = self.etree.ElementTree
2761 ns = 'http://xml.infrae.com/1'
2762 ns2 = 'http://xml.infrae.com/2'
2763 f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2764 t = ElementTree(file=f)
2765 a = t.getroot()
2766 self.assertEqual('{%s}a' % ns,
2767 a.tag)
2768 self.assertEqual('{%s}b' % ns,
2769 a[0].tag)
2770 self.assertEqual('{%s}b' % ns2,
2771 a[1].tag)
2772
2774 Element = self.etree.Element
2775 SubElement = self.etree.SubElement
2776 ns = 'http://xml.infrae.com/1'
2777 ns2 = 'http://xml.infrae.com/2'
2778 a = Element('{%s}a' % ns)
2779 b = SubElement(a, '{%s}b' % ns2)
2780 c = SubElement(a, '{%s}c' % ns)
2781 self.assertEqual('{%s}a' % ns,
2782 a.tag)
2783 self.assertEqual('{%s}b' % ns2,
2784 b.tag)
2785 self.assertEqual('{%s}c' % ns,
2786 c.tag)
2787 self.assertEqual('{%s}a' % ns,
2788 a.tag)
2789 self.assertEqual('{%s}b' % ns2,
2790 b.tag)
2791 self.assertEqual('{%s}c' % ns,
2792 c.tag)
2793
2811
2813 Element = self.etree.Element
2814 ns = 'http://xml.infrae.com/1'
2815 ns2 = 'http://xml.infrae.com/2'
2816 a = Element('a')
2817 a.set('{%s}foo' % ns, 'Foo')
2818 a.set('{%s}bar' % ns2, 'Bar')
2819 self.assertEqual(
2820 'Foo',
2821 a.get('{%s}foo' % ns))
2822 self.assertEqual(
2823 'Bar',
2824 a.get('{%s}bar' % ns2))
2825 try:
2826 self.assertXML(
2827 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)),
2828 a)
2829 except AssertionError:
2830 self.assertXML(
2831 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)),
2832 a)
2833
2835 Element = self.etree.Element
2836 one = self.etree.fromstring(
2837 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
2838 baz = one[0][0]
2839
2840 two = Element('root')
2841 two.append(baz)
2842
2843
2844 del one, baz
2845 self.assertEqual('{http://a.b.c}baz', two[0].tag)
2846
2856
2866
2877
2890
2892 Element = self.etree.Element
2893
2894 root = Element('element')
2895
2896 subelement = Element('subelement',
2897 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2898 self.assertEqual(1, len(subelement.attrib))
2899 self.assertEqual(
2900 "foo",
2901 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2902
2903 root.append(subelement)
2904 self.assertEqual(1, len(subelement.attrib))
2905 self.assertEqual(
2906 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()),
2907 list(subelement.attrib.items()))
2908 self.assertEqual(
2909 "foo",
2910 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2911
2923
2939
2957
2958 required_versions_ET['test_register_namespace'] = (1,3)
2976
2988
3002
3016
3017 required_versions_ET['test_tostring_method_html'] = (1,3)
3031
3032 required_versions_ET['test_tostring_method_text'] = (1,3)
3034 tostring = self.etree.tostring
3035 Element = self.etree.Element
3036 SubElement = self.etree.SubElement
3037
3038 a = Element('a')
3039 a.text = "A"
3040 a.tail = "tail"
3041 b = SubElement(a, 'b')
3042 b.text = "B"
3043 b.tail = "TAIL"
3044 c = SubElement(a, 'c')
3045 c.text = "C"
3046
3047 self.assertEqual(_bytes('ABTAILCtail'),
3048 tostring(a, method="text"))
3049
3051 iterparse = self.etree.iterparse
3052 f = BytesIO('<a><b></b><c/></a>')
3053
3054 iterator = iterparse(f)
3055 self.assertEqual(None,
3056 iterator.root)
3057 events = list(iterator)
3058 root = iterator.root
3059 self.assertEqual(
3060 [('end', root[0]), ('end', root[1]), ('end', root)],
3061 events)
3062
3073
3084
3086 iterparse = self.etree.iterparse
3087 f = BytesIO('<a><b></b><c/></a>')
3088
3089 iterator = iterparse(f, events=('start',))
3090 events = list(iterator)
3091 root = iterator.root
3092 self.assertEqual(
3093 [('start', root), ('start', root[0]), ('start', root[1])],
3094 events)
3095
3097 iterparse = self.etree.iterparse
3098 f = BytesIO('<a><b></b><c/></a>')
3099
3100 iterator = iterparse(f, events=('start','end'))
3101 events = list(iterator)
3102 root = iterator.root
3103 self.assertEqual(
3104 [('start', root), ('start', root[0]), ('end', root[0]),
3105 ('start', root[1]), ('end', root[1]), ('end', root)],
3106 events)
3107
3119
3121 iterparse = self.etree.iterparse
3122 CHILD_COUNT = 12345
3123 f = BytesIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
3124
3125 i = 0
3126 for key in iterparse(f):
3127 event, element = key
3128 i += 1
3129 self.assertEqual(i, CHILD_COUNT + 1)
3130
3132 iterparse = self.etree.iterparse
3133 f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>')
3134
3135 attr_name = '{http://testns/}bla'
3136 events = []
3137 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
3138 for event, elem in iterator:
3139 events.append(event)
3140 if event == 'start':
3141 if elem.tag != '{http://ns1/}a':
3142 elem.set(attr_name, 'value')
3143
3144 self.assertEqual(
3145 ['start-ns', 'start', 'start', 'start-ns', 'start',
3146 'end', 'end-ns', 'end', 'end', 'end-ns'],
3147 events)
3148
3149 root = iterator.root
3150 self.assertEqual(
3151 None,
3152 root.get(attr_name))
3153 self.assertEqual(
3154 'value',
3155 root[0].get(attr_name))
3156
3158 iterparse = self.etree.iterparse
3159 f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>')
3160
3161 attr_name = '{http://testns/}bla'
3162 events = []
3163 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
3164 for event, elem in iterator:
3165 events.append(event)
3166 if event == 'start':
3167 if elem.tag != '{http://ns1/}a':
3168 elem.set(attr_name, 'value')
3169
3170 self.assertEqual(
3171 ['start-ns', 'start', 'start', 'start-ns', 'start',
3172 'end', 'end-ns', 'end', 'end', 'end-ns'],
3173 events)
3174
3175 root = iterator.root
3176 self.assertEqual(
3177 None,
3178 root.get(attr_name))
3179 self.assertEqual(
3180 'value',
3181 root[0].get(attr_name))
3182
3193
3206
3208 tostring = self.etree.tostring
3209 f = BytesIO('<root><![CDATA[test]]></root>')
3210 context = self.etree.iterparse(f)
3211 content = [ el.text for event,el in context ]
3212
3213 self.assertEqual(['test'], content)
3214 self.assertEqual(_bytes('<root>test</root>'),
3215 tostring(context.root))
3216
3224
3228
3232
3233 required_versions_ET['test_parse_error'] = (1,3)
3235
3236 parse = self.etree.parse
3237 f = BytesIO('<a><b></c></b></a>')
3238 self.assertRaises(SyntaxError, parse, f)
3239 f.close()
3240
3241 required_versions_ET['test_parse_error_from_file'] = (1,3)
3248
3258
3268
3276
3283
3292
3305
3313
3323
3340
3341 required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3)
3356
3357 required_versions_ET['test_parse_encoding_8bit_override'] = (1,3)
3374
3376
3377 XML = self.etree.XML
3378 test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') +
3379 _str('<a>Søk på nettet</a>'))
3380 self.assertRaises(SyntaxError, XML, test_utf)
3381
3396
3405
3414
3425
3437
3450
3464
3466 utext = _str('Søk på nettet')
3467 uxml = _str('<p>%s</p>') % utext
3468 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
3469 isoxml = prologue + uxml.encode('iso-8859-1')
3470 tree = self.etree.XML(isoxml)
3471 self.assertEqual(utext, tree.text)
3472
3474 utext = _str('Søk på nettet')
3475 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') +
3476 _str('<p>%s</p>') % utext)
3477 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1")
3478 xml = bom + uxml.encode("utf-8")
3479 tree = etree.XML(xml)
3480 self.assertEqual(utext, tree.text)
3481
3483 utext = _str('Søk på nettet')
3484 uxml = _str('<p>%s</p>') % utext
3485 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
3486 isoxml = prologue + uxml.encode('iso-8859-1')
3487 el = self.etree.parse(BytesIO(isoxml)).getroot()
3488 self.assertEqual(utext, el.text)
3489
3503
3505 Element = self.etree.Element
3506
3507 a = Element('a')
3508 a.text = 'Foo'
3509
3510 b = copy.deepcopy(a)
3511 self.assertEqual('Foo', b.text)
3512
3513 b.text = 'Bar'
3514 self.assertEqual('Bar', b.text)
3515 self.assertEqual('Foo', a.text)
3516
3517 del a
3518 self.assertEqual('Bar', b.text)
3519
3521 Element = self.etree.Element
3522
3523 a = Element('a')
3524 a.tail = 'Foo'
3525
3526 b = copy.deepcopy(a)
3527 self.assertEqual('Foo', b.tail)
3528
3529 b.tail = 'Bar'
3530 self.assertEqual('Bar', b.tail)
3531 self.assertEqual('Foo', a.tail)
3532
3533 del a
3534 self.assertEqual('Bar', b.tail)
3535
3537 Element = self.etree.Element
3538 SubElement = self.etree.SubElement
3539
3540 root = Element('root')
3541 a = SubElement(root, 'a')
3542 a.text = 'FooText'
3543 a.tail = 'FooTail'
3544
3545 b = copy.deepcopy(a)
3546 self.assertEqual('FooText', b.text)
3547 self.assertEqual('FooTail', b.tail)
3548
3549 b.text = 'BarText'
3550 b.tail = 'BarTail'
3551 self.assertEqual('BarTail', b.tail)
3552 self.assertEqual('FooTail', a.tail)
3553 self.assertEqual('BarText', b.text)
3554 self.assertEqual('FooText', a.text)
3555
3556 del a
3557 self.assertEqual('BarTail', b.tail)
3558 self.assertEqual('BarText', b.text)
3559
3561 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns">
3562 <parent><node t:foo="bar" /></parent>
3563 </doc>'''))
3564 self.assertEqual(
3565 root[0][0].get('{tns}foo'),
3566 copy.deepcopy(root[0])[0].get('{tns}foo') )
3567 self.assertEqual(
3568 root[0][0].get('{tns}foo'),
3569 copy.deepcopy(root[0][0]).get('{tns}foo') )
3570
3585
3597
3610
3611
3624
3626
3627 etree = self.etree
3628 e = etree.Element('foo')
3629 self.assertEqual(False, bool(e))
3630 etree.SubElement(e, 'bar')
3631 self.assertEqual(True, bool(e))
3632 e = etree.Element('foo')
3633 e.text = 'hey'
3634 self.assertEqual(False, bool(e))
3635 e = etree.Element('foo')
3636 e.tail = 'bar'
3637 self.assertEqual(False, bool(e))
3638 e = etree.Element('foo')
3639 e.set('bar', 'Bar')
3640 self.assertEqual(False, bool(e))
3641
3659
3667
3669 etree = self.etree
3670 qname1 = etree.QName('myns', 'a')
3671 qname2 = etree.QName('myns', 'a')
3672 self.assertEqual(qname1, "{myns}a")
3673 self.assertEqual("{myns}a", qname2)
3674 self.assertEqual(qname1, qname1)
3675 self.assertEqual(qname1, qname2)
3676
3686
3699
3709
3719
3729
3736
3737
3738
3754
3769
3770 required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)
3775
3776 required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3)
3785
3786 required_versions_ET['test_feed_parser_error_broken'] = (1,3)
3800
3801 required_versions_ET['test_feed_parser_error_position'] = (1,3)
3813
3814
3815
3816 required_versions_ET['test_parser_target_property'] = (1,3)
3818 class Target(object):
3819 pass
3820
3821 target = Target()
3822 parser = self.XMLParser(target=target)
3823
3824 self.assertEqual(target, parser.target)
3825
3827 assertEqual = self.assertEqual
3828 assertFalse = self.assertFalse
3829
3830 events = []
3831 class Target(object):
3832 def start(self, tag, attrib):
3833 events.append("start")
3834 assertFalse(attrib)
3835 assertEqual("TAG", tag)
3836 def end(self, tag):
3837 events.append("end")
3838 assertEqual("TAG", tag)
3839 def close(self):
3840 return "DONE"
3841
3842 parser = self.XMLParser(target=Target())
3843
3844 parser.feed("<TAG/>")
3845 done = parser.close()
3846
3847 self.assertEqual("DONE", done)
3848 self.assertEqual(["start", "end"], events)
3849
3851 assertEqual = self.assertEqual
3852
3853 events = []
3854 class Target(object):
3855 def start(self, tag, attrib):
3856 events.append("start")
3857 assertEqual("TAG", tag)
3858 raise ValueError("TEST")
3859 def end(self, tag):
3860 events.append("end")
3861 assertEqual("TAG", tag)
3862 def close(self):
3863 return "DONE"
3864
3865 parser = self.XMLParser(target=Target())
3866
3867 try:
3868 parser.feed("<TAG/>")
3869 except ValueError:
3870 self.assertTrue('TEST' in str(sys.exc_info()[1]))
3871 else:
3872 self.assertTrue(False)
3873 if 'lxml' in self.etree.__name__:
3874 self.assertEqual(["start"], events)
3875 else:
3876
3877 self.assertTrue("start" in events)
3878
3880 assertEqual = self.assertEqual
3881
3882 events = []
3883 class Target(object):
3884 def start(self, tag, attrib):
3885 events.append("start")
3886 assertEqual("TAG", tag)
3887 def end(self, tag):
3888 events.append("end")
3889 assertEqual("TAG", tag)
3890 raise ValueError("TEST")
3891 def close(self):
3892 return "DONE"
3893
3894 parser = self.XMLParser(target=Target())
3895
3896 try:
3897 parser.feed("<TAG/>")
3898 except ValueError:
3899 self.assertTrue('TEST' in str(sys.exc_info()[1]))
3900 else:
3901 self.assertTrue(False)
3902 self.assertEqual(["start", "end"], events)
3903
3905 assertEqual = self.assertEqual
3906
3907 events = []
3908 class Target(object):
3909 def start(self, tag, attrib):
3910 events.append("start")
3911 assertEqual("TAG", tag)
3912 def end(self, tag):
3913 events.append("end")
3914 assertEqual("TAG", tag)
3915 def close(self):
3916 raise ValueError("TEST")
3917
3918 parser = self.XMLParser(target=Target())
3919
3920 try:
3921 parser.feed("<TAG/>")
3922 parser.close()
3923 except ValueError:
3924 self.assertTrue('TEST' in str(sys.exc_info()[1]))
3925 else:
3926 self.assertTrue(False)
3927 self.assertEqual(["start", "end"], events)
3928
3930 assertEqual = self.assertEqual
3931
3932 events = []
3933 class Target(object):
3934 def start(self, tag, attrib):
3935 events.append("start")
3936 assertEqual("TAG", tag)
3937 raise IndexError("TEST-IE")
3938 def end(self, tag):
3939 events.append("end")
3940 assertEqual("TAG", tag)
3941 def close(self):
3942 raise ValueError("TEST-VE")
3943
3944 parser = self.XMLParser(target=Target())
3945
3946 try:
3947 parser.feed("<TAG/>")
3948 parser.close()
3949 except IndexError:
3950 if 'lxml' in self.etree.__name__:
3951
3952 self.assertTrue(sys.version_info[0] < 3)
3953 self.assertTrue('TEST-IE' in str(sys.exc_info()[1]))
3954 except ValueError:
3955 if 'lxml' in self.etree.__name__:
3956 self.assertTrue(sys.version_info[0] >= 3)
3957 self.assertTrue('TEST-VE' in str(sys.exc_info()[1]))
3958 else:
3959 self.assertTrue(False)
3960
3961 if 'lxml' in self.etree.__name__:
3962 self.assertEqual(["start"], events)
3963 else:
3964
3965 self.assertTrue("start" in events)
3966
3968 assertEqual = self.assertEqual
3969 assertFalse = self.assertFalse
3970 Element = self.etree.Element
3971
3972 events = []
3973 class Target(object):
3974 def start(self, tag, attrib):
3975 events.append("start")
3976 assertFalse(attrib)
3977 assertEqual("TAG", tag)
3978 def end(self, tag):
3979 events.append("end")
3980 assertEqual("TAG", tag)
3981 def close(self):
3982 return Element("DONE")
3983
3984 parser = self.XMLParser(target=Target())
3985 tree = self.etree.ElementTree()
3986 tree.parse(BytesIO("<TAG/>"), parser=parser)
3987
3988 self.assertEqual("DONE", tree.getroot().tag)
3989 self.assertEqual(["start", "end"], events)
3990
3992 assertEqual = self.assertEqual
3993
3994 events = []
3995 class Target(object):
3996 def start(self, tag, attrib):
3997 events.append("start-" + tag)
3998 for name, value in attrib.items():
3999 assertEqual(tag + name, value)
4000 def end(self, tag):
4001 events.append("end-" + tag)
4002 def close(self):
4003 return "DONE"
4004
4005 parser = self.XMLParser(target=Target())
4006
4007 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
4008 done = parser.close()
4009
4010 self.assertEqual("DONE", done)
4011 self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"],
4012 events)
4013
4015 events = []
4016 class Target(object):
4017 def start(self, tag, attrib):
4018 events.append("start-" + tag)
4019 def end(self, tag):
4020 events.append("end-" + tag)
4021 def data(self, data):
4022 events.append("data-" + data)
4023 def close(self):
4024 return "DONE"
4025
4026 parser = self.XMLParser(target=Target())
4027
4028 parser.feed('<root>A<sub/>B</root>')
4029 done = parser.close()
4030
4031 self.assertEqual("DONE", done)
4032 self.assertEqual(["start-root", "data-A", "start-sub",
4033 "end-sub", "data-B", "end-root"],
4034 events)
4035
4037 events = []
4038 class Target(object):
4039 def __init__(self):
4040 self._data = []
4041 def _flush_data(self):
4042 if self._data:
4043 events.append("data-" + ''.join(self._data))
4044 del self._data[:]
4045 def start(self, tag, attrib):
4046 self._flush_data()
4047 events.append("start-" + tag)
4048 def end(self, tag):
4049 self._flush_data()
4050 events.append("end-" + tag)
4051 def data(self, data):
4052 self._data.append(data)
4053 def close(self):
4054 self._flush_data()
4055 return "DONE"
4056
4057 parser = self.XMLParser(target=Target())
4058
4059 dtd = '''
4060 <!DOCTYPE root [
4061 <!ELEMENT root (sub*)>
4062 <!ELEMENT sub (#PCDATA)>
4063 <!ENTITY ent "an entity">
4064 ]>
4065 '''
4066 parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
4067 done = parser.close()
4068
4069 self.assertEqual("DONE", done)
4070 self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub",
4071 "data-this is an entity",
4072 "end-sub", "start-sub", "end-sub", "end-root"],
4073 events)
4074
4075 required_versions_ET['test_parser_target_entity_unknown'] = (1,3)
4077 events = []
4078 class Target(object):
4079 def __init__(self):
4080 self._data = []
4081 def _flush_data(self):
4082 if self._data:
4083 events.append("data-" + ''.join(self._data))
4084 del self._data[:]
4085 def start(self, tag, attrib):
4086 self._flush_data()
4087 events.append("start-" + tag)
4088 def end(self, tag):
4089 self._flush_data()
4090 events.append("end-" + tag)
4091 def data(self, data):
4092 self._data.append(data)
4093 def close(self):
4094 self._flush_data()
4095 return "DONE"
4096
4097 parser = self.XMLParser(target=Target())
4098
4099 def feed():
4100 parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
4101 parser.close()
4102
4103 self.assertRaises(self.etree.ParseError, feed)
4104
4105 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4107 class Builder(list):
4108 def start(self, tag, attrib):
4109 self.append(("start", tag))
4110 def end(self, tag):
4111 self.append(("end", tag))
4112 def data(self, text):
4113 pass
4114 def pi(self, target, data):
4115 self.append(("pi", target, data))
4116 def comment(self, data):
4117 self.append(("comment", data))
4118 def start_ns(self, prefix, uri):
4119 self.append(("start-ns", prefix, uri))
4120 def end_ns(self, prefix):
4121 self.append(("end-ns", prefix))
4122
4123 builder = Builder()
4124 parser = self.etree.XMLParser(target=builder)
4125 parser.feed(textwrap.dedent("""\
4126 <?pi data?>
4127 <!-- comment -->
4128 <root xmlns='namespace'>
4129 <element key='value'>text</element>
4130 <element>text</element>tail
4131 <empty-element/>
4132 </root>
4133 """))
4134 self.assertEqual(builder, [
4135 ('pi', 'pi', 'data'),
4136 ('comment', ' comment '),
4137 ('start-ns', '', 'namespace'),
4138 ('start', '{namespace}root'),
4139 ('start', '{namespace}element'),
4140 ('end', '{namespace}element'),
4141 ('start', '{namespace}element'),
4142 ('end', '{namespace}element'),
4143 ('start', '{namespace}empty-element'),
4144 ('end', '{namespace}empty-element'),
4145 ('end', '{namespace}root'),
4146 ('end-ns', ''),
4147 ])
4148
4149 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4151 class Builder(list):
4152 def end_ns(self, prefix):
4153 self.append(("end-ns", prefix))
4154
4155 builder = Builder()
4156 parser = self.etree.XMLParser(target=builder)
4157 parser.feed(textwrap.dedent("""\
4158 <?pi data?>
4159 <!-- comment -->
4160 <root xmlns='namespace' xmlns:p='pns'>
4161 <element key='value'>text</element>
4162 <p:element>text</p:element>tail
4163 <empty-element/>
4164 </root>
4165 """))
4166 self.assertEqual(builder, [
4167 ('end-ns', 'p'),
4168 ('end-ns', ''),
4169 ])
4170
4172 builder = self.etree.TreeBuilder()
4173 el = builder.start("root", {'a':'A', 'b':'B'})
4174 self.assertEqual("root", el.tag)
4175 self.assertEqual({'a':'A', 'b':'B'}, el.attrib)
4176 builder.data("ROOTTEXT")
4177 el = builder.start("child", {'x':'X', 'y':'Y'})
4178 self.assertEqual("child", el.tag)
4179 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib)
4180 builder.data("CHILDTEXT")
4181 el = builder.end("child")
4182 self.assertEqual("child", el.tag)
4183 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib)
4184 self.assertEqual("CHILDTEXT", el.text)
4185 self.assertEqual(None, el.tail)
4186 builder.data("CHILDTAIL")
4187 root = builder.end("root")
4188
4189 self.assertEqual("root", root.tag)
4190 self.assertEqual("ROOTTEXT", root.text)
4191 self.assertEqual("CHILDTEXT", root[0].text)
4192 self.assertEqual("CHILDTAIL", root[0].tail)
4193
4203
4204 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4214
4215
4216
4217
4218 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4220 ET = self.etree
4221 is_lxml = ET.__name__ == 'lxml.etree'
4222
4223 b = ET.TreeBuilder()
4224 self.assertEqual(b.pi('target', None).tag, ET.PI)
4225 if is_lxml:
4226 self.assertEqual(b.pi('target', None).target, 'target')
4227 else:
4228 self.assertEqual(b.pi('target', None).text, 'target')
4229
4230 b = ET.TreeBuilder(pi_factory=ET.PI)
4231 self.assertEqual(b.pi('target').tag, ET.PI)
4232 if is_lxml:
4233 self.assertEqual(b.pi('target').target, "target")
4234 else:
4235 self.assertEqual(b.pi('target').text, "target")
4236 self.assertEqual(b.pi('pitarget', ' text ').tag, ET.PI)
4237 if is_lxml:
4238 self.assertEqual(b.pi('pitarget', ' text ').target, "pitarget")
4239 self.assertEqual(b.pi('pitarget', ' text ').text, " text ")
4240 else:
4241 self.assertEqual(b.pi('pitarget', ' text ').text, "pitarget text ")
4242
4243
4244
4245
4246
4248
4249 ET = self.etree
4250 class TreeBuilderSubclass(ET.TreeBuilder):
4251 pass
4252
4253 if ET.__name__ == 'lxml.etree':
4254 def assert_content(a):
4255 self.assertEqual(a.text, "text")
4256 self.assertEqual(a[0].tail, "tail")
4257 else:
4258 def assert_content(a):
4259 self.assertEqual(a.text, "texttail")
4260
4261 xml = "<a>text<!-- comment -->tail</a>"
4262 a = ET.fromstring(xml)
4263 assert_content(a)
4264
4265 parser = ET.XMLParser(target=TreeBuilderSubclass())
4266 parser.feed(xml)
4267 a = parser.close()
4268 assert_content(a)
4269
4270 xml = "<a>text<?pi data?>tail</a>"
4271 a = ET.fromstring(xml)
4272 assert_content(a)
4273
4274 xml = "<a>text<?pi data?>tail</a>"
4275 parser = ET.XMLParser(target=TreeBuilderSubclass())
4276 parser.feed(xml)
4277 a = parser.close()
4278 assert_content(a)
4279
4280 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4287
4288 xml = "<a>text<?pi1?> <!-- comment -->\n<?pi2?>tail</a>"
4289 parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True, insert_pis=False))
4290 parser.feed(xml)
4291 a = parser.close()
4292 self.assertEqual(a[0].text, ' comment ')
4293 self.assertEqual(a[0].tail, '\ntail')
4294 self.assertEqual(a.text, "text ")
4295
4296 parser = ET.XMLParser(target=TreeBuilderSubclass(insert_comments=True, insert_pis=False))
4297 parser.feed(xml)
4298 a = parser.close()
4299 self.assertEqual(a[0].text, ' comment ')
4300 self.assertEqual(a[0].tail, '\ntail')
4301 self.assertEqual(a.text, "text ")
4302
4303 xml = "<a>text<!-- comment -->\n<?pi data?>tail</a>"
4304 parser = ET.XMLParser(target=ET.TreeBuilder(insert_pis=True, insert_comments=False))
4305 parser.feed(xml)
4306 a = parser.close()
4307 self.assertEqual(a[0].text[-4:], 'data')
4308 self.assertEqual(a[0].tail, 'tail')
4309 self.assertEqual(a.text, "text\n")
4310
4311 parser = ET.XMLParser(target=TreeBuilderSubclass(insert_pis=True, insert_comments=False))
4312 parser.feed(xml)
4313 a = parser.close()
4314 self.assertEqual(a[0].text[-4:], 'data')
4315 self.assertEqual(a[0].tail, 'tail')
4316 self.assertEqual(a.text, "text\n")
4317
4318
4319
4325
4337
4338 - def assertXML(self, expected, element, encoding='us-ascii'):
4339 """Writes element out and checks whether it is expected.
4340
4341 Does this two ways; once using BytesIO, once using a real file.
4342 """
4343 if isinstance(expected, unicode):
4344 expected = expected.encode(encoding)
4345 self.assertEqual(expected, self._writeElement(element, encoding))
4346 self.assertEqual(expected, self._writeElementFile(element, encoding))
4347
4349 "Checks if the result XML byte string specifies the encoding."
4350 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']"
4351 if isinstance(result, str):
4352 has_encoding = re.compile(enc_re).match
4353 else:
4354 has_encoding = re.compile(_bytes(enc_re)).match
4355 self.assertTrue(has_encoding(result))
4356 result_encoding = has_encoding(result).group(1)
4357 self.assertEqual(result_encoding.upper(), encoding.upper())
4358
4362
4365
4377
4379 len(string)
4380 for char in string:
4381 self.assertEqual(1, len(char))
4382 new_string = string + ""
4383 new_string = string + " "
4384 string[:0]
4385
4387 len(mapping)
4388 keys = mapping.keys()
4389 values = mapping.values()
4390 items = mapping.items()
4391 for key in keys:
4392 item = mapping[key]
4393 mapping["key"] = "value"
4394 self.assertEqual("value", mapping["key"])
4395
4398 etree = None
4399
4402
4405
4407 """Create an Element with a tag 'a', with the given amount of children
4408 named 'a0', 'a1' ... and so on.
4409
4410 """
4411 e = self.etree.Element('a')
4412 for i in range(numchildren):
4413 self.etree.SubElement(e, 'a%s' % i)
4414 return e
4415
4417 e = self._make_elem_with_children(10)
4418
4419 self.assertEqual(e[1].tag, 'a1')
4420 self.assertEqual(e[-2].tag, 'a8')
4421
4422 self.assertRaises(IndexError, lambda: e[12])
4423 self.assertRaises(IndexError, lambda: e[-12])
4424
4426 e = self._make_elem_with_children(6)
4427
4428 self.assertEqual(self._elem_tags(e[3:]), ['a3', 'a4', 'a5'])
4429 self.assertEqual(self._elem_tags(e[3:6]), ['a3', 'a4', 'a5'])
4430 self.assertEqual(self._elem_tags(e[3:16]), ['a3', 'a4', 'a5'])
4431 self.assertEqual(self._elem_tags(e[3:5]), ['a3', 'a4'])
4432 self.assertEqual(self._elem_tags(e[3:-1]), ['a3', 'a4'])
4433 self.assertEqual(self._elem_tags(e[:2]), ['a0', 'a1'])
4434
4436 e = self._make_elem_with_children(10)
4437
4438 self.assertEqual(self._elem_tags(e[8:10:1]), ['a8', 'a9'])
4439 self.assertEqual(self._elem_tags(e[::3]), ['a0', 'a3', 'a6', 'a9'])
4440 self.assertEqual(self._elem_tags(e[::8]), ['a0', 'a8'])
4441 self.assertEqual(self._elem_tags(e[1::8]), ['a1', 'a9'])
4442 self.assertEqual(self._elem_tags(e[3::sys.maxsize]), ['a3'])
4443 self.assertEqual(self._elem_tags(e[3::sys.maxsize<<64]), ['a3'])
4444
4446 e = self._make_elem_with_children(4)
4447
4448 self.assertEqual(self._elem_tags(e[::-1]), ['a3', 'a2', 'a1', 'a0'])
4449 self.assertEqual(self._elem_tags(e[::-2]), ['a3', 'a1'])
4450 self.assertEqual(self._elem_tags(e[3::-sys.maxsize]), ['a3'])
4451 self.assertEqual(self._elem_tags(e[3::-sys.maxsize-1]), ['a3'])
4452 self.assertEqual(self._elem_tags(e[3::-sys.maxsize<<64]), ['a3'])
4453
4478
4480 e = self._make_elem_with_children(4)
4481 e[1] = self.etree.Element('b')
4482 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4483
4484 e[-2] = self.etree.Element('c')
4485 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
4486
4487 with self.assertRaises(IndexError):
4488 e[5] = self.etree.Element('d')
4489 with self.assertRaises(IndexError):
4490 e[-5] = self.etree.Element('d')
4491 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
4492
4494 e = self._make_elem_with_children(4)
4495 e[1:3] = [self.etree.Element('b%s' % i) for i in range(2)]
4496 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'a3'])
4497
4498 e = self._make_elem_with_children(4)
4499 e[1:3] = [self.etree.Element('b')]
4500 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a3'])
4501
4502 e = self._make_elem_with_children(4)
4503 e[1:3] = [self.etree.Element('b%s' % i) for i in range(3)]
4504 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'b2', 'a3'])
4505
4507 e = self._make_elem_with_children(6)
4508 e[1:5:2] = [self.etree.Element('b%s' % i) for i in range(2)]
4509 self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'a2', 'b1', 'a4', 'a5'])
4510
4511 e = self._make_elem_with_children(6)
4512 with self.assertRaises(ValueError):
4513 e[1:5:2] = [self.etree.Element('b')]
4514 with self.assertRaises(ValueError):
4515 e[1:5:2] = [self.etree.Element('b%s' % i) for i in range(3)]
4516 with self.assertRaises(ValueError):
4517 e[1:5:2] = []
4518 self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3', 'a4', 'a5'])
4519
4520 e = self._make_elem_with_children(4)
4521 e[1::sys.maxsize] = [self.etree.Element('b')]
4522 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4523 e[1::sys.maxsize<<64] = [self.etree.Element('c')]
4524 self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
4525
4527 e = self._make_elem_with_children(4)
4528 e[2:0:-1] = [self.etree.Element('b%s' % i) for i in range(2)]
4529 self.assertEqual(self._subelem_tags(e), ['a0', 'b1', 'b0', 'a3'])
4530
4531 e = self._make_elem_with_children(4)
4532 with self.assertRaises(ValueError):
4533 e[2:0:-1] = [self.etree.Element('b')]
4534 with self.assertRaises(ValueError):
4535 e[2:0:-1] = [self.etree.Element('b%s' % i) for i in range(3)]
4536 with self.assertRaises(ValueError):
4537 e[2:0:-1] = []
4538 self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3'])
4539
4540 e = self._make_elem_with_children(4)
4541 e[1::-sys.maxsize] = [self.etree.Element('b')]
4542 self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
4543 e[1::-sys.maxsize-1] = [self.etree.Element('c')]
4544 self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
4545 e[1::-sys.maxsize<<64] = [self.etree.Element('d')]
4546 self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3'])
4547
4550 etree = None
4551
4559
4560 - def _feed(self, parser, data, chunk_size=None):
4566
4568 self.assertEqual(
4569 [(event, (elem.tag, elem.text))
4570 for event, elem in islice(parser.read_events(), max_events)],
4571 expected)
4572
4574 self.assertEqual(
4575 list(islice(parser.read_events(), max_events)),
4576 expected)
4577
4582
4584 for chunk_size in (None, 1, 5):
4585
4586 parser = self.etree.XMLPullParser()
4587 self.assert_event_tags(parser, [])
4588 self._feed(parser, "<!-- comment -->\n", chunk_size)
4589 self.assert_event_tags(parser, [])
4590 self._feed(parser,
4591 "<root>\n <element key='value'>text</element",
4592 chunk_size)
4593 self.assert_event_tags(parser, [])
4594 self._feed(parser, ">\n", chunk_size)
4595 self.assert_event_tags(parser, [('end', 'element')])
4596 self._feed(parser, "<element>text</element>tail\n", chunk_size)
4597 self._feed(parser, "<empty-element/>\n", chunk_size)
4598 self.assert_event_tags(parser, [
4599 ('end', 'element'),
4600 ('end', 'empty-element'),
4601 ])
4602 self._feed(parser, "</root>\n", chunk_size)
4603 self.assert_event_tags(parser, [('end', 'root')])
4604 root = self._close_and_return_root(parser)
4605 self.assertEqual(root.tag, 'root')
4606
4608 parser = self.etree.XMLPullParser()
4609 it = parser.read_events()
4610 self._feed(parser, "<root>\n <element key='value'>text</element>\n")
4611 action, elem = next(it)
4612 self.assertEqual((action, elem.tag), ('end', 'element'))
4613 self._feed(parser, "</root>\n")
4614 action, elem = next(it)
4615 self.assertEqual((action, elem.tag), ('end', 'root'))
4616 with self.assertRaises(StopIteration):
4617 next(it)
4618
4620 parser = self.etree.XMLPullParser()
4621 self.assert_event_tags(parser, [])
4622 self._feed(parser, "<!-- comment -->\n")
4623 self.assert_event_tags(parser, [])
4624 self._feed(parser, "<root xmlns='namespace'>\n")
4625 self.assert_event_tags(parser, [])
4626 self._feed(parser, "<element key='value'>text</element")
4627 self.assert_event_tags(parser, [])
4628 self._feed(parser, ">\n")
4629 self.assert_event_tags(parser, [('end', '{namespace}element')])
4630 self._feed(parser, "<element>text</element>tail\n")
4631 self._feed(parser, "<empty-element/>\n")
4632 self.assert_event_tags(parser, [
4633 ('end', '{namespace}element'),
4634 ('end', '{namespace}empty-element'),
4635 ])
4636 self._feed(parser, "</root>\n")
4637 self.assert_event_tags(parser, [('end', '{namespace}root')])
4638 root = self._close_and_return_root(parser)
4639 self.assertEqual(root.tag, '{namespace}root')
4640
4642 parser = self.etree.XMLPullParser(events=('start-ns', 'end-ns'))
4643 self._feed(parser, "<!-- comment -->\n")
4644 self._feed(parser, "<root xmlns='namespace'>\n")
4645 self.assertEqual(
4646 list(parser.read_events()),
4647 [('start-ns', ('', 'namespace'))])
4648 self._feed(parser, "<element key='value'>text</element")
4649 self._feed(parser, ">\n")
4650 self._feed(parser, "<element>text</element>tail\n")
4651 self._feed(parser, "<empty-element/>\n")
4652 self._feed(parser, "</root>\n")
4653 self.assertEqual(list(parser.read_events()), [('end-ns', None)])
4654 parser.close()
4655
4657 parser = self.etree.XMLPullParser(events=['end-ns'])
4658 self._feed(parser, "<!-- comment -->\n")
4659 self._feed(parser, "<root xmlns='namespace' xmlns:a='abc' xmlns:b='xyz'>\n")
4660 self.assertEqual(list(parser.read_events()), [])
4661 self._feed(parser, "<a:element key='value'>text</a:element")
4662 self._feed(parser, ">\n")
4663 self._feed(parser, "<b:element>text</b:element>tail\n")
4664 self._feed(parser, "<empty-element/>\n")
4665 self.assertEqual(list(parser.read_events()), [])
4666 self._feed(parser, "</root>\n")
4667 self.assertEqual(list(parser.read_events()), [
4668 ('end-ns', None),
4669 ('end-ns', None),
4670 ('end-ns', None),
4671 ])
4672 parser.close()
4673
4674 @et_needs_pyversion(3,8)
4676 parser = self.etree.XMLPullParser(events=('start-ns', 'start', 'end'))
4677 self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
4678 self.assert_event_tuples(parser, [
4679 ('start-ns', ('', 'abc')),
4680 ('start-ns', ('p', 'xyz')),
4681 ], max_events=2)
4682 self.assert_event_tags(parser, [
4683 ('start', '{abc}tag'),
4684 ], max_events=1)
4685
4686 self._feed(parser, "<child />\n")
4687 self.assert_event_tags(parser, [
4688 ('start', '{abc}child'),
4689 ('end', '{abc}child'),
4690 ])
4691
4692 self._feed(parser, "</tag>\n")
4693 parser.close()
4694 self.assert_event_tags(parser, [
4695 ('end', '{abc}tag'),
4696 ])
4697
4698 @et_needs_pyversion(3,8)
4700 parser = self.etree.XMLPullParser(events=('start-ns', 'start', 'end', 'end-ns'))
4701 self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
4702 self.assert_event_tuples(parser, [
4703 ('start-ns', ('', 'abc')),
4704 ('start-ns', ('p', 'xyz')),
4705 ], max_events=2)
4706 self.assert_event_tags(parser, [
4707 ('start', '{abc}tag'),
4708 ], max_events=1)
4709
4710 self._feed(parser, "<child />\n")
4711 self.assert_event_tags(parser, [
4712 ('start', '{abc}child'),
4713 ('end', '{abc}child'),
4714 ])
4715
4716 self._feed(parser, "</tag>\n")
4717 parser.close()
4718 self.assert_event_tags(parser, [
4719 ('end', '{abc}tag'),
4720 ], max_events=1)
4721 self.assert_event_tuples(parser, [
4722 ('end-ns', None),
4723 ('end-ns', None),
4724 ])
4725
4727 parser = self.etree.XMLPullParser(events=())
4728 self._feed(parser, "<root/>\n")
4729 self.assert_event_tags(parser, [])
4730
4731 parser = self.etree.XMLPullParser(events=('start', 'end'))
4732 self._feed(parser, "<!-- text here -->\n")
4733 self.assert_events(parser, [])
4734
4735 parser = self.etree.XMLPullParser(events=('start', 'end'))
4736 self._feed(parser, "<root>\n")
4737 self.assert_event_tags(parser, [('start', 'root')])
4738 self._feed(parser, "<element key='value'>text</element")
4739 self.assert_event_tags(parser, [('start', 'element')])
4740 self._feed(parser, ">\n")
4741 self.assert_event_tags(parser, [('end', 'element')])
4742 self._feed(parser,
4743 "<element xmlns='foo'>text<empty-element/></element>tail\n")
4744 self.assert_event_tags(parser, [
4745 ('start', '{foo}element'),
4746 ('start', '{foo}empty-element'),
4747 ('end', '{foo}empty-element'),
4748 ('end', '{foo}element'),
4749 ])
4750 self._feed(parser, "</root>")
4751 root = self._close_and_return_root(parser)
4752 self.assert_event_tags(parser, [('end', 'root')])
4753 self.assertEqual(root.tag, 'root')
4754
4755 parser = self.etree.XMLPullParser(events=('start',))
4756 self._feed(parser, "<!-- comment -->\n")
4757 self.assert_event_tags(parser, [])
4758 self._feed(parser, "<root>\n")
4759 self.assert_event_tags(parser, [('start', 'root')])
4760 self._feed(parser, "<element key='value'>text</element")
4761 self.assert_event_tags(parser, [('start', 'element')])
4762 self._feed(parser, ">\n")
4763 self.assert_event_tags(parser, [])
4764 self._feed(parser,
4765 "<element xmlns='foo'>text<empty-element/></element>tail\n")
4766 self.assert_event_tags(parser, [
4767 ('start', '{foo}element'),
4768 ('start', '{foo}empty-element'),
4769 ])
4770 self._feed(parser, "</root>")
4771 root = self._close_and_return_root(parser)
4772 self.assertEqual(root.tag, 'root')
4773
4774 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4793
4794 @et_needs_pyversion(3, 8, 0, 'alpha', 4)
4803
4805
4806 eventset = {'end', 'start'}
4807 parser = self.etree.XMLPullParser(events=eventset)
4808 self._feed(parser, "<foo>bar</foo>")
4809 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
4810
4811 class DummyIter(object):
4812 def __init__(self):
4813 self.events = iter(['start', 'end', 'start-ns'])
4814 def __iter__(self):
4815 return self
4816 def __next__(self):
4817 return next(self.events)
4818 def next(self):
4819 return next(self.events)
4820
4821 parser = self.etree.XMLPullParser(events=DummyIter())
4822 self._feed(parser, "<foo>bar</foo>")
4823 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
4824
4826 with self.assertRaises(ValueError):
4827 self.etree.XMLPullParser(events=('start', 'end', 'bogus'))
4828
4831 etree = None
4832 maxDiff = None
4833
4834 if not hasattr(unittest.TestCase, 'subTest'):
4835 @contextmanager
4836 - def subTest(self, name, **kwargs):
4837 try:
4838 yield
4839 except unittest.SkipTest:
4840 raise
4841 except Exception as e:
4842 print("Subtest {} failed: {}".format(name, e))
4843 raise
4844
4847
4848
4849
4850
4853
4855 c14n_roundtrip = self.c14n_roundtrip
4856
4857 self.assertEqual(c14n_roundtrip("<doc/>"), '<doc></doc>')
4858 self.assertEqual(c14n_roundtrip("<doc xmlns='uri'/>"),
4859 '<doc xmlns="uri"></doc>')
4860 self.assertEqual(c14n_roundtrip("<prefix:doc xmlns:prefix='uri'/>"),
4861 '<prefix:doc xmlns:prefix="uri"></prefix:doc>')
4862 self.assertEqual(c14n_roundtrip("<doc xmlns:prefix='uri'><prefix:bar/></doc>"),
4863 '<doc><prefix:bar xmlns:prefix="uri"></prefix:bar></doc>')
4864 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/' />"),
4865 '<elem></elem>')
4866
4867
4868 self.assertEqual(c14n_roundtrip("<doc>Hello, world!<!-- Comment 1 --></doc>"),
4869 '<doc>Hello, world!</doc>')
4870 self.assertEqual(c14n_roundtrip("<value>2</value>"),
4871 '<value>2</value>')
4872 self.assertEqual(c14n_roundtrip('<compute><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></compute>'),
4873 '<compute>value>"0" && value<"10" ?"valid":"error"</compute>')
4874 self.assertEqual(c14n_roundtrip('''<compute expr='value>"0" && value<"10" ?"valid":"error"'>valid</compute>'''),
4875 '<compute expr="value>"0" && value<"10" ?"valid":"error"">valid</compute>')
4876 self.assertEqual(c14n_roundtrip("<norm attr=' '   
	 ' '/>"),
4877 '<norm attr=" \' 
	 \' "></norm>')
4878 self.assertEqual(c14n_roundtrip("<normNames attr=' A   
	 B '/>"),
4879 '<normNames attr=" A 
	 B "></normNames>')
4880 self.assertEqual(c14n_roundtrip("<normId id=' '   
	 ' '/>"),
4881 '<normId id=" \' 
	 \' "></normId>')
4882
4883
4884
4885
4886
4888 c14n_roundtrip = self.c14n_roundtrip
4889 xml = textwrap.dedent("""\
4890 <root xmlns:x="http://example.com/x">
4891 <a x:attr="attrx">
4892 <b>abtext</b>
4893 </a>
4894 <b>btext</b>
4895 <c>
4896 <x:d>dtext</x:d>
4897 </c>
4898 </root>
4899 """)
4900 self.assertEqual(
4901 c14n_roundtrip(xml, strip_text=True),
4902 '<root>'
4903 '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>'
4904 '<b>btext</b>'
4905 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4906 '</root>')
4907 self.assertEqual(
4908 c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr']),
4909 '<root>'
4910 '<a><b>abtext</b></a>'
4911 '<b>btext</b>'
4912 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4913 '</root>')
4914 self.assertEqual(
4915 c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d']),
4916 '<root>'
4917 '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>'
4918 '<b>btext</b>'
4919 '<c></c>'
4920 '</root>')
4921 self.assertEqual(
4922 c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr'],
4923 exclude_tags=['{http://example.com/x}d']),
4924 '<root>'
4925 '<a><b>abtext</b></a>'
4926 '<b>btext</b>'
4927 '<c></c>'
4928 '</root>')
4929 self.assertEqual(
4930 c14n_roundtrip(xml, strip_text=True, exclude_tags=['a', 'b']),
4931 '<root>'
4932 '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>'
4933 '</root>')
4934 self.assertEqual(
4935 c14n_roundtrip(xml, exclude_tags=['a', 'b']),
4936 '<root>\n'
4937 ' \n'
4938 ' \n'
4939 ' <c>\n'
4940 ' <x:d xmlns:x="http://example.com/x">dtext</x:d>\n'
4941 ' </c>\n'
4942 '</root>')
4943 self.assertEqual(
4944 c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d', 'b']),
4945 '<root>'
4946 '<a xmlns:x="http://example.com/x" x:attr="attrx"></a>'
4947 '<c></c>'
4948 '</root>')
4949 self.assertEqual(
4950 c14n_roundtrip(xml, exclude_tags=['{http://example.com/x}d', 'b']),
4951 '<root>\n'
4952 ' <a xmlns:x="http://example.com/x" x:attr="attrx">\n'
4953 ' \n'
4954 ' </a>\n'
4955 ' \n'
4956 ' <c>\n'
4957 ' \n'
4958 ' </c>\n'
4959 '</root>')
4960
4961
4962
4963
4964
4965
4966
4967
4969 datadir = os.path.join(os.path.dirname(__file__), "c14n-20")
4970 full_path = partial(os.path.join, datadir)
4971
4972 files = [filename[:-4] for filename in sorted(os.listdir(datadir))
4973 if filename.endswith('.xml')]
4974 input_files = [
4975 filename for filename in files
4976 if filename.startswith('in')
4977 ]
4978 configs = {
4979 filename: {
4980
4981 option.tag.split('}')[-1]: ((option.text or '').strip(), option)
4982 for option in self.etree.parse(full_path(filename) + ".xml").getroot()
4983 }
4984 for filename in files
4985 if filename.startswith('c14n')
4986 }
4987
4988 tests = {
4989 input_file: [
4990 (filename, configs[filename.rsplit('_', 1)[-1]])
4991 for filename in files
4992 if filename.startswith('out_%s_' % input_file)
4993 and filename.rsplit('_', 1)[-1] in configs
4994 ]
4995 for input_file in input_files
4996 }
4997
4998
4999 self.assertEqual(30, len([
5000 output_file for output_files in tests.values()
5001 for output_file in output_files]))
5002
5003 def get_option(config, option_name, default=None):
5004 return config.get(option_name, (default, ()))[0]
5005
5006 for input_file, output_files in tests.items():
5007 for output_file, config in output_files:
5008 keep_comments = get_option(
5009 config, 'IgnoreComments') == 'true'
5010 strip_text = get_option(
5011 config, 'TrimTextNodes') == 'true'
5012 rewrite_prefixes = get_option(
5013 config, 'PrefixRewrite') == 'sequential'
5014 if 'QNameAware' in config:
5015 qattrs = [
5016 "{%s}%s" % (el.get('NS'), el.get('Name'))
5017 for el in config['QNameAware'][1].findall(
5018 '{http://www.w3.org/2010/xml-c14n2}QualifiedAttr')
5019 ]
5020 qtags = [
5021 "{%s}%s" % (el.get('NS'), el.get('Name'))
5022 for el in config['QNameAware'][1].findall(
5023 '{http://www.w3.org/2010/xml-c14n2}Element')
5024 ]
5025 else:
5026 qtags = qattrs = None
5027
5028
5029 config_descr = ','.join(
5030 "%s=%s" % (name, value or ','.join(c.tag.split('}')[-1] for c in children))
5031 for name, (value, children) in sorted(config.items())
5032 )
5033
5034 with self.subTest("{}({})".format(output_file, config_descr)):
5035 if input_file == 'inNsRedecl' and not rewrite_prefixes:
5036 self.skipTest(
5037 "Redeclared namespace handling is not supported in {}".format(
5038 output_file))
5039 if input_file == 'inNsSuperfluous' and not rewrite_prefixes:
5040 self.skipTest(
5041 "Redeclared namespace handling is not supported in {}".format(
5042 output_file))
5043 if 'QNameAware' in config and config['QNameAware'][1].find(
5044 '{http://www.w3.org/2010/xml-c14n2}XPathElement') is not None:
5045 self.skipTest(
5046 "QName rewriting in XPath text is not supported in {}".format(
5047 output_file))
5048
5049 f = full_path(input_file + ".xml")
5050 if input_file == 'inC14N5':
5051
5052 with open(full_path('world.txt'), 'rb') as entity_file:
5053 with open(f, 'rb') as f:
5054 f = io.BytesIO(f.read().replace(b'&ent2;', entity_file.read().strip()))
5055
5056 text = self._canonicalize(
5057 f,
5058 with_comments=keep_comments,
5059 strip_text=strip_text,
5060 rewrite_prefixes=rewrite_prefixes,
5061 qname_aware_tags=qtags, qname_aware_attrs=qattrs)
5062
5063 with io.open(full_path(output_file + ".xml"), 'r', encoding='utf8') as f:
5064 expected = f.read()
5065 if input_file == 'inC14N3' and self.etree is not etree:
5066
5067 expected = expected.replace(' attr="default"', '')
5068 text = text.replace(' attr="default"', '')
5069 self.assertEqual(expected, text)
5070
5071
5072 if etree:
5075
5078
5081
5084
5086 - def _canonicalize(self, input_file, with_comments=True, strip_text=False,
5087 rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None,
5088 **options):
5089 if rewrite_prefixes or qname_aware_attrs or qname_aware_tags:
5090 self.skipTest("C14N 2.0 feature not supported with ElementTree.write()")
5091
5092 parser = self.etree.XMLParser(attribute_defaults=True, collect_ids=False)
5093 tree = self.etree.parse(input_file, parser)
5094 out = io.BytesIO()
5095 tree.write(
5096 out, method='c14n2',
5097 with_comments=with_comments, strip_text=strip_text,
5098 **options)
5099 return out.getvalue().decode('utf8')
5100
5102 - def _canonicalize(self, input_file, with_comments=True, strip_text=False,
5103 rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None,
5104 **options):
5105 if rewrite_prefixes or qname_aware_attrs or qname_aware_tags:
5106 self.skipTest("C14N 2.0 feature not supported with ElementTree.tostring()")
5107
5108 parser = self.etree.XMLParser(attribute_defaults=True, collect_ids=False)
5109 tree = self.etree.parse(input_file, parser)
5110 return self.etree.tostring(
5111 tree, method='c14n2',
5112 with_comments=with_comments, strip_text=strip_text,
5113 **options).decode('utf8')
5114
5115
5116 if ElementTree:
5118 etree = ElementTree
5119
5120 @classmethod
5122 import warnings
5123
5124 warnings.filterwarnings(
5125 'ignore',
5126 r'This method will be removed.*\.iter\(\).*instead',
5127 PendingDeprecationWarning)
5128
5129 filter_by_version(
5130 ElementTreeTestCase,
5131 ElementTreeTestCase.required_versions_ET, ET_VERSION)
5132
5133 if hasattr(ElementTree, 'XMLPullParser'):
5136 else:
5137 ElementTreePullTestCase = None
5138
5139 if hasattr(ElementTree, 'canonicalize'):
5142 else:
5143 ElementTreeC14NTest = None
5147
5148
5149 if cElementTree:
5152
5153 filter_by_version(
5154 CElementTreeTestCase,
5155 CElementTreeTestCase.required_versions_cET, CET_VERSION)
5159
5181
5182 if __name__ == '__main__':
5183 print('to test use test.py %s' % __file__)
5184