| Home | Trees | Indices | Help |
|
|---|
|
|
1 # -*- coding: utf-8 -*-
2
3 """
4 Tests specific to the extended etree API
5
6 Tests that apply to the general ElementTree API should go into
7 test_elementtree
8 """
9
10 import os.path
11 import unittest
12 import copy
13 import sys
14 import re
15 import operator
16 import tempfile
17 import gzip
18
19 this_dir = os.path.dirname(__file__)
20 if this_dir not in sys.path:
21 sys.path.insert(0, this_dir) # needed for Py3
22
23 from common_imports import etree, StringIO, BytesIO, HelperTestCase, fileInTestDir, read_file
24 from common_imports import SillyFileLike, LargeFileLikeUnicode, doctest, make_doctest
25 from common_imports import canonicalize, sorted, _str, _bytes
26
27 print("")
28 print("TESTED VERSION: %s" % etree.__version__)
29 print(" Python: " + repr(sys.version_info))
30 print(" lxml.etree: " + repr(etree.LXML_VERSION))
31 print(" libxml used: " + repr(etree.LIBXML_VERSION))
32 print(" libxml compiled: " + repr(etree.LIBXML_COMPILED_VERSION))
33 print(" libxslt used: " + repr(etree.LIBXSLT_VERSION))
34 print(" libxslt compiled: " + repr(etree.LIBXSLT_COMPILED_VERSION))
35 print("")
36
37 try:
38 _unicode = unicode
39 except NameError:
40 # Python 3
41 _unicode = str
42
44 """Tests only for etree, not ElementTree"""
45 etree = etree
46
48 self.assert_(isinstance(etree.__version__, _unicode))
49 self.assert_(isinstance(etree.LXML_VERSION, tuple))
50 self.assertEqual(len(etree.LXML_VERSION), 4)
51 self.assert_(isinstance(etree.LXML_VERSION[0], int))
52 self.assert_(isinstance(etree.LXML_VERSION[1], int))
53 self.assert_(isinstance(etree.LXML_VERSION[2], int))
54 self.assert_(isinstance(etree.LXML_VERSION[3], int))
55 self.assert_(etree.__version__.startswith(
56 str(etree.LXML_VERSION[0])))
57
59 if hasattr(self.etree, '__pyx_capi__'):
60 # newer Pyrex compatible C-API
61 self.assert_(isinstance(self.etree.__pyx_capi__, dict))
62 self.assert_(len(self.etree.__pyx_capi__) > 0)
63 else:
64 # older C-API mechanism
65 self.assert_(hasattr(self.etree, '_import_c_api'))
66
68 Element = self.etree.Element
69 el = Element('name')
70 self.assertEquals(el.tag, 'name')
71 el = Element('{}name')
72 self.assertEquals(el.tag, 'name')
73
75 Element = self.etree.Element
76 el = Element('name')
77 self.assertRaises(ValueError, Element, '{}')
78 self.assertRaises(ValueError, setattr, el, 'tag', '{}')
79
80 self.assertRaises(ValueError, Element, '{test}')
81 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')
82
84 Element = self.etree.Element
85 self.assertRaises(ValueError, Element, 'p:name')
86 self.assertRaises(ValueError, Element, '{test}p:name')
87
88 el = Element('name')
89 self.assertRaises(ValueError, setattr, el, 'tag', 'p:name')
90
92 Element = self.etree.Element
93 self.assertRaises(ValueError, Element, "p'name")
94 self.assertRaises(ValueError, Element, 'p"name')
95
96 self.assertRaises(ValueError, Element, "{test}p'name")
97 self.assertRaises(ValueError, Element, '{test}p"name')
98
99 el = Element('name')
100 self.assertRaises(ValueError, setattr, el, 'tag', "p'name")
101 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')
102
104 Element = self.etree.Element
105 self.assertRaises(ValueError, Element, ' name ')
106 self.assertRaises(ValueError, Element, 'na me')
107 self.assertRaises(ValueError, Element, '{test} name')
108
109 el = Element('name')
110 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
111
113 Element = self.etree.Element
114 SubElement = self.etree.SubElement
115
116 el = Element('name')
117 self.assertRaises(ValueError, SubElement, el, '{}')
118 self.assertRaises(ValueError, SubElement, el, '{test}')
119
121 Element = self.etree.Element
122 SubElement = self.etree.SubElement
123
124 el = Element('name')
125 self.assertRaises(ValueError, SubElement, el, 'p:name')
126 self.assertRaises(ValueError, SubElement, el, '{test}p:name')
127
129 Element = self.etree.Element
130 SubElement = self.etree.SubElement
131
132 el = Element('name')
133 self.assertRaises(ValueError, SubElement, el, "p'name")
134 self.assertRaises(ValueError, SubElement, el, "{test}p'name")
135
136 self.assertRaises(ValueError, SubElement, el, 'p"name')
137 self.assertRaises(ValueError, SubElement, el, '{test}p"name')
138
140 Element = self.etree.Element
141 SubElement = self.etree.SubElement
142
143 el = Element('name')
144 self.assertRaises(ValueError, SubElement, el, ' name ')
145 self.assertRaises(ValueError, SubElement, el, 'na me')
146 self.assertRaises(ValueError, SubElement, el, '{test} name')
147
149 Element = self.etree.Element
150 SubElement = self.etree.SubElement
151
152 el = Element('name')
153 self.assertRaises(ValueError, SubElement, el, 'name', {'a b c' : 'abc'})
154 self.assertRaises(ValueError, SubElement, el, 'name', {'a' : 'a\0\n'})
155 self.assertEquals(0, len(el))
156
158 QName = self.etree.QName
159 self.assertRaises(ValueError, QName, '')
160 self.assertRaises(ValueError, QName, 'test', '')
161
163 QName = self.etree.QName
164 self.assertRaises(ValueError, QName, 'p:name')
165 self.assertRaises(ValueError, QName, 'test', 'p:name')
166
168 QName = self.etree.QName
169 self.assertRaises(ValueError, QName, ' name ')
170 self.assertRaises(ValueError, QName, 'na me')
171 self.assertRaises(ValueError, QName, 'test', ' name')
172
174 # ET doesn't have namespace/localname properties on QNames
175 QName = self.etree.QName
176 namespace, localname = 'http://myns', 'a'
177 qname = QName(namespace, localname)
178 self.assertEquals(namespace, qname.namespace)
179 self.assertEquals(localname, qname.localname)
180
182 # ET doesn't have namespace/localname properties on QNames
183 QName = self.etree.QName
184 qname1 = QName('http://myns', 'a')
185 a = self.etree.Element(qname1, nsmap={'p' : 'http://myns'})
186
187 qname2 = QName(a)
188 self.assertEquals(a.tag, qname1.text)
189 self.assertEquals(qname1.text, qname2.text)
190 self.assertEquals(qname1, qname2)
191
193 # ET doesn't resove QNames as text values
194 etree = self.etree
195 qname = etree.QName('http://myns', 'a')
196 a = etree.Element(qname, nsmap={'p' : 'http://myns'})
197 a.text = qname
198
199 self.assertEquals("p:a", a.text)
200
202 etree = self.etree
203 self.assertRaises(ValueError,
204 etree.Element, "root", nsmap={'"' : 'testns'})
205 self.assertRaises(ValueError,
206 etree.Element, "root", nsmap={'&' : 'testns'})
207 self.assertRaises(ValueError,
208 etree.Element, "root", nsmap={'a:b' : 'testns'})
209
211 # ET in Py 3.x has no "attrib.has_key()" method
212 XML = self.etree.XML
213
214 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
215 self.assertEquals(
216 True, root.attrib.has_key('bar'))
217 self.assertEquals(
218 False, root.attrib.has_key('baz'))
219 self.assertEquals(
220 False, root.attrib.has_key('hah'))
221 self.assertEquals(
222 True,
223 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
224
226 Element = self.etree.Element
227 root = Element("root")
228 root.set("attr", "TEST")
229 self.assertEquals("TEST", root.get("attr"))
230
232 # ElementTree accepts arbitrary attribute values
233 # lxml.etree allows only strings
234 Element = self.etree.Element
235 root = Element("root")
236 self.assertRaises(TypeError, root.set, "newattr", 5)
237 self.assertRaises(TypeError, root.set, "newattr", None)
238
240 XML = self.etree.XML
241 xml = _bytes('<test a="5" b="10" c="20"><x a="4" b="2"/></test>')
242
243 root = XML(xml)
244 self.etree.strip_attributes(root, 'a')
245 self.assertEquals(_bytes('<test b="10" c="20"><x b="2"></x></test>'),
246 self._writeElement(root))
247
248 root = XML(xml)
249 self.etree.strip_attributes(root, 'b', 'c')
250 self.assertEquals(_bytes('<test a="5"><x a="4"></x></test>'),
251 self._writeElement(root))
252
254 XML = self.etree.XML
255 xml = _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20" n:a="5"><x a="4" n:b="2"/></test>')
256
257 root = XML(xml)
258 self.etree.strip_attributes(root, 'a')
259 self.assertEquals(
260 _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'),
261 self._writeElement(root))
262
263 root = XML(xml)
264 self.etree.strip_attributes(root, '{http://test/ns}a', 'c')
265 self.assertEquals(
266 _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'),
267 self._writeElement(root))
268
269 root = XML(xml)
270 self.etree.strip_attributes(root, '{http://test/ns}*')
271 self.assertEquals(
272 _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'),
273 self._writeElement(root))
274
276 XML = self.etree.XML
277 xml = _bytes('<test><a><b><c/></b></a><x><a><b/><c/></a></x></test>')
278
279 root = XML(xml)
280 self.etree.strip_elements(root, 'a')
281 self.assertEquals(_bytes('<test><x></x></test>'),
282 self._writeElement(root))
283
284 root = XML(xml)
285 self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z')
286 self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'),
287 self._writeElement(root))
288
289 root = XML(xml)
290 self.etree.strip_elements(root, 'c')
291 self.assertEquals(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'),
292 self._writeElement(root))
293
295 XML = self.etree.XML
296 xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"/>C</b>BT</n:a>AT<x>X<a>A<b xmlns="urn:a"/>BT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>')
297
298 root = XML(xml)
299 self.etree.strip_elements(root, 'a')
300 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X</x>XT</test>'),
301 self._writeElement(root))
302
303 root = XML(xml)
304 self.etree.strip_elements(root, '{urn:a}b', 'c')
305 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
306 self._writeElement(root))
307
308 root = XML(xml)
309 self.etree.strip_elements(root, '{urn:a}*', 'c')
310 self.assertEquals(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
311 self._writeElement(root))
312
313 root = XML(xml)
314 self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False)
315 self.assertEquals(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
316 self._writeElement(root))
317
336
362
389
415
434
436 # lxml.etree separates target and text
437 Element = self.etree.Element
438 SubElement = self.etree.SubElement
439 ProcessingInstruction = self.etree.ProcessingInstruction
440
441 a = Element('a')
442 a.append(ProcessingInstruction('foo', 'some more text'))
443 self.assertEquals(a[0].target, 'foo')
444 self.assertEquals(a[0].text, 'some more text')
445
447 XML = self.etree.XML
448 root = XML(_bytes("<test><?mypi my test ?></test>"))
449 self.assertEquals(root[0].target, "mypi")
450 self.assertEquals(root[0].text, "my test ")
451
453 XML = self.etree.XML
454 root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>"))
455 self.assertEquals(root[0].target, "mypi")
456 self.assertEquals(root[0].get('my'), "1")
457 self.assertEquals(root[0].get('test'), " abc ")
458 self.assertEquals(root[0].get('quotes'), "' '")
459 self.assertEquals(root[0].get('only'), None)
460 self.assertEquals(root[0].get('names'), None)
461 self.assertEquals(root[0].get('nope'), None)
462
464 XML = self.etree.XML
465 root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>"))
466 self.assertEquals(root[0].target, "mypi")
467 self.assertEquals(root[0].attrib['my'], "1")
468 self.assertEquals(root[0].attrib['test'], " abc ")
469 self.assertEquals(root[0].attrib['quotes'], "' '")
470 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'only')
471 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'names')
472 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'nope')
473
475 # previously caused a crash
476 ProcessingInstruction = self.etree.ProcessingInstruction
477
478 a = ProcessingInstruction("PI", "ONE")
479 b = copy.deepcopy(a)
480 b.text = "ANOTHER"
481
482 self.assertEquals('ONE', a.text)
483 self.assertEquals('ANOTHER', b.text)
484
486 XML = self.etree.XML
487 tostring = self.etree.tostring
488 root = XML(_bytes("<?mypi my test ?><test/><!--comment -->"))
489 tree1 = self.etree.ElementTree(root)
490 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
491 tostring(tree1))
492
493 tree2 = copy.deepcopy(tree1)
494 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
495 tostring(tree2))
496
497 root2 = copy.deepcopy(tree1.getroot())
498 self.assertEquals(_bytes("<test/>"),
499 tostring(root2))
500
502 XML = self.etree.XML
503 tostring = self.etree.tostring
504 xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>')
505 root = XML(xml)
506 tree1 = self.etree.ElementTree(root)
507 self.assertEquals(xml, tostring(tree1))
508
509 tree2 = copy.deepcopy(tree1)
510 self.assertEquals(xml, tostring(tree2))
511
512 root2 = copy.deepcopy(tree1.getroot())
513 self.assertEquals(_bytes("<test/>"),
514 tostring(root2))
515
517 # ElementTree accepts arbitrary attribute values
518 # lxml.etree allows only strings
519 Element = self.etree.Element
520
521 root = Element("root")
522 root.set("attr", "TEST")
523 self.assertEquals("TEST", root.get("attr"))
524 self.assertRaises(TypeError, root.set, "newattr", 5)
525
527 fromstring = self.etree.fromstring
528 tostring = self.etree.tostring
529 XMLParser = self.etree.XMLParser
530
531 xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
532 parser = XMLParser(remove_comments=True)
533 root = fromstring(xml, parser)
534 self.assertEquals(
535 _bytes('<a><b><c/></b></a>'),
536 tostring(root))
537
539 parse = self.etree.parse
540 tostring = self.etree.tostring
541 XMLParser = self.etree.XMLParser
542
543 xml = _bytes('<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>')
544
545 f = BytesIO(xml)
546 tree = parse(f)
547 self.assertEquals(
548 xml,
549 tostring(tree))
550
551 parser = XMLParser(remove_pis=True)
552 tree = parse(f, parser)
553 self.assertEquals(
554 _bytes('<a><b><c/></b></a>'),
555 tostring(tree))
556
558 # ET raises IOError only
559 parse = self.etree.parse
560 self.assertRaises(TypeError, parse, 'notthere.xml', object())
561
563 # ET removes comments
564 iterparse = self.etree.iterparse
565 tostring = self.etree.tostring
566
567 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
568 events = list(iterparse(f))
569 root = events[-1][1]
570 self.assertEquals(3, len(events))
571 self.assertEquals(
572 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
573 tostring(root))
574
576 # ET removes comments
577 iterparse = self.etree.iterparse
578 tostring = self.etree.tostring
579
580 def name(event, el):
581 if event == 'comment':
582 return el.text
583 else:
584 return el.tag
585
586 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
587 events = list(iterparse(f, events=('end', 'comment')))
588 root = events[-1][1]
589 self.assertEquals(6, len(events))
590 self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'],
591 [ name(*item) for item in events ])
592 self.assertEquals(
593 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
594 tostring(root))
595
597 # ET removes pis
598 iterparse = self.etree.iterparse
599 tostring = self.etree.tostring
600 ElementTree = self.etree.ElementTree
601
602 def name(event, el):
603 if event == 'pi':
604 return (el.target, el.text)
605 else:
606 return el.tag
607
608 f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>')
609 events = list(iterparse(f, events=('end', 'pi')))
610 root = events[-2][1]
611 self.assertEquals(8, len(events))
612 self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b',
613 ('pid','d'), 'a', ('pie','e')],
614 [ name(*item) for item in events ])
615 self.assertEquals(
616 _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'),
617 tostring(ElementTree(root)))
618
620 iterparse = self.etree.iterparse
621 tostring = self.etree.tostring
622
623 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
624 events = list(iterparse(f, remove_comments=True,
625 events=('end', 'comment')))
626 root = events[-1][1]
627 self.assertEquals(3, len(events))
628 self.assertEquals(['c', 'b', 'a'],
629 [ el.tag for (event, el) in events ])
630 self.assertEquals(
631 _bytes('<a><b><c/></b></a>'),
632 tostring(root))
633
635 iterparse = self.etree.iterparse
636 f = BytesIO('<a><b><c/></a>')
637 # ET raises ExpatError, lxml raises XMLSyntaxError
638 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))
639
641 iterparse = self.etree.iterparse
642 f = BytesIO("""
643 <a> \n \n <b> b test </b> \n
644
645 \n\t <c> \n </c> </a> \n """)
646 iterator = iterparse(f, remove_blank_text=True)
647 text = [ (element.text, element.tail)
648 for event, element in iterator ]
649 self.assertEquals(
650 [(" b test ", None), (" \n ", None), (None, None)],
651 text)
652
654 iterparse = self.etree.iterparse
655 f = BytesIO('<a><b><d/></b><c/></a>')
656
657 iterator = iterparse(f, tag="b", events=('start', 'end'))
658 events = list(iterator)
659 root = iterator.root
660 self.assertEquals(
661 [('start', root[0]), ('end', root[0])],
662 events)
663
665 iterparse = self.etree.iterparse
666 f = BytesIO('<a><b><d/></b><c/></a>')
667
668 iterator = iterparse(f, tag="*", events=('start', 'end'))
669 events = list(iterator)
670 self.assertEquals(
671 8,
672 len(events))
673
675 iterparse = self.etree.iterparse
676 f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>')
677
678 iterator = iterparse(f, tag="{urn:test:1}b", events=('start', 'end'))
679 events = list(iterator)
680 root = iterator.root
681 self.assertEquals(
682 [('start', root[0]), ('end', root[0])],
683 events)
684
686 iterparse = self.etree.iterparse
687 f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>')
688
689 iterator = iterparse(f, tag="{urn:test:1}*", events=('start', 'end'))
690 events = list(iterator)
691 self.assertEquals(
692 8,
693 len(events))
694
696 text = _str('Søk på nettet')
697 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
698 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
699 ).encode('iso-8859-1')
700
701 self.assertRaises(self.etree.ParseError,
702 list, self.etree.iterparse(BytesIO(xml_latin1)))
703
705 text = _str('Søk på nettet', encoding="UTF-8")
706 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
707 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
708 ).encode('iso-8859-1')
709
710 iterator = self.etree.iterparse(BytesIO(xml_latin1),
711 encoding="iso-8859-1")
712 self.assertEquals(1, len(list(iterator)))
713
714 a = iterator.root
715 self.assertEquals(a.text, text)
716
718 tostring = self.etree.tostring
719 f = BytesIO('<root><![CDATA[test]]></root>')
720 context = self.etree.iterparse(f, strip_cdata=False)
721 content = [ el.text for event,el in context ]
722
723 self.assertEquals(['test'], content)
724 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
725 tostring(context.root))
726
730
732 self.etree.XMLParser(encoding="ascii")
733 self.etree.XMLParser(encoding="utf-8")
734 self.etree.XMLParser(encoding="iso-8859-1")
735
737 parser = self.etree.XMLParser(recover=True)
738
739 parser.feed('<?xml version=')
740 parser.feed('"1.0"?><ro')
741 parser.feed('ot><')
742 parser.feed('a test="works"')
743 parser.feed('><othertag/></root') # <a> not closed!
744 parser.feed('>')
745
746 root = parser.close()
747
748 self.assertEquals(root.tag, "root")
749 self.assertEquals(len(root), 1)
750 self.assertEquals(root[0].tag, "a")
751 self.assertEquals(root[0].get("test"), "works")
752 self.assertEquals(len(root[0]), 1)
753 self.assertEquals(root[0][0].tag, "othertag")
754 # FIXME: would be nice to get some errors logged ...
755 #self.assert_(len(parser.error_log) > 0, "error log is empty")
756
758 assertEquals = self.assertEquals
759 assertFalse = self.assertFalse
760
761 events = []
762 class Target(object):
763 def start(self, tag, attrib):
764 events.append("start")
765 assertFalse(attrib)
766 assertEquals("TAG", tag)
767 def end(self, tag):
768 events.append("end")
769 assertEquals("TAG", tag)
770 def close(self):
771 return "DONE" # no Element!
772
773 parser = self.etree.XMLParser(target=Target())
774 tree = self.etree.ElementTree()
775
776 self.assertRaises(TypeError,
777 tree.parse, BytesIO("<TAG/>"), parser=parser)
778 self.assertEquals(["start", "end"], events)
779
781 # ET doesn't call .close() on errors
782 events = []
783 class Target(object):
784 def start(self, tag, attrib):
785 events.append("start-" + tag)
786 def end(self, tag):
787 events.append("end-" + tag)
788 if tag == 'a':
789 raise ValueError("dead and gone")
790 def data(self, data):
791 events.append("data-" + data)
792 def close(self):
793 events.append("close")
794 return "DONE"
795
796 parser = self.etree.XMLParser(target=Target())
797
798 try:
799 parser.feed(_bytes('<root>A<a>ca</a>B</root>'))
800 done = parser.close()
801 self.fail("error expected, but parsing succeeded")
802 except ValueError:
803 done = 'value error received as expected'
804
805 self.assertEquals(["start-root", "data-A", "start-a",
806 "data-ca", "end-a", "close"],
807 events)
808
810 # ET doesn't call .close() on errors
811 events = []
812 class Target(object):
813 def start(self, tag, attrib):
814 events.append("start-" + tag)
815 def end(self, tag):
816 events.append("end-" + tag)
817 if tag == 'a':
818 raise ValueError("dead and gone")
819 def data(self, data):
820 events.append("data-" + data)
821 def close(self):
822 events.append("close")
823 return "DONE"
824
825 parser = self.etree.XMLParser(target=Target())
826
827 try:
828 done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'),
829 parser=parser)
830 self.fail("error expected, but parsing succeeded")
831 except ValueError:
832 done = 'value error received as expected'
833
834 self.assertEquals(["start-root", "data-A", "start-a",
835 "data-ca", "end-a", "close"],
836 events)
837
839 events = []
840 class Target(object):
841 def start(self, tag, attrib):
842 events.append("start-" + tag)
843 def end(self, tag):
844 events.append("end-" + tag)
845 def data(self, data):
846 events.append("data-" + data)
847 def comment(self, text):
848 events.append("comment-" + text)
849 def close(self):
850 return "DONE"
851
852 parser = self.etree.XMLParser(target=Target())
853
854 parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->'))
855 done = parser.close()
856
857 self.assertEquals("DONE", done)
858 self.assertEquals(["comment-a", "start-root", "data-A", "comment-b",
859 "start-sub", "end-sub", "comment-c", "data-B",
860 "end-root", "comment-d"],
861 events)
862
864 events = []
865 class Target(object):
866 def start(self, tag, attrib):
867 events.append("start-" + tag)
868 def end(self, tag):
869 events.append("end-" + tag)
870 def data(self, data):
871 events.append("data-" + data)
872 def pi(self, target, data):
873 events.append("pi-" + target + "-" + data)
874 def close(self):
875 return "DONE"
876
877 parser = self.etree.XMLParser(target=Target())
878
879 parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>'))
880 done = parser.close()
881
882 self.assertEquals("DONE", done)
883 self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b",
884 "data-B", "end-root", "pi-test-c"],
885 events)
886
888 events = []
889 class Target(object):
890 def start(self, tag, attrib):
891 events.append("start-" + tag)
892 def end(self, tag):
893 events.append("end-" + tag)
894 def data(self, data):
895 events.append("data-" + data)
896 def close(self):
897 return "DONE"
898
899 parser = self.etree.XMLParser(target=Target(),
900 strip_cdata=False)
901
902 parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>'))
903 done = parser.close()
904
905 self.assertEquals("DONE", done)
906 self.assertEquals(["start-root", "data-A", "start-a",
907 "data-ca", "end-a", "data-B", "end-root"],
908 events)
909
911 events = []
912 class Target(object):
913 def start(self, tag, attrib):
914 events.append("start-" + tag)
915 def end(self, tag):
916 events.append("end-" + tag)
917 def data(self, data):
918 events.append("data-" + data)
919 def close(self):
920 events.append("close")
921 return "DONE"
922
923 parser = self.etree.XMLParser(target=Target(),
924 recover=True)
925
926 parser.feed(_bytes('<root>A<a>ca</a>B</not-root>'))
927 done = parser.close()
928
929 self.assertEquals("DONE", done)
930 self.assertEquals(["start-root", "data-A", "start-a",
931 "data-ca", "end-a", "data-B",
932 "end-root", "close"],
933 events)
934
936 iterwalk = self.etree.iterwalk
937 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
938
939 iterator = iterwalk(root, tag="b", events=('start', 'end'))
940 events = list(iterator)
941 self.assertEquals(
942 [('start', root[0]), ('end', root[0])],
943 events)
944
946 iterwalk = self.etree.iterwalk
947 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
948
949 iterator = iterwalk(root, tag="*", events=('start', 'end'))
950 events = list(iterator)
951 self.assertEquals(
952 8,
953 len(events))
954
956 iterwalk = self.etree.iterwalk
957 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
958
959 events = list(iterwalk(root))
960 self.assertEquals(
961 [('end', root[0]), ('end', root[1]), ('end', root)],
962 events)
963
965 iterwalk = self.etree.iterwalk
966 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
967
968 iterator = iterwalk(root, events=('start',))
969 events = list(iterator)
970 self.assertEquals(
971 [('start', root), ('start', root[0]), ('start', root[1])],
972 events)
973
975 iterwalk = self.etree.iterwalk
976 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
977
978 iterator = iterwalk(root, events=('start','end'))
979 events = list(iterator)
980 self.assertEquals(
981 [('start', root), ('start', root[0]), ('end', root[0]),
982 ('start', root[1]), ('end', root[1]), ('end', root)],
983 events)
984
986 iterwalk = self.etree.iterwalk
987 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
988
989 iterator = iterwalk(root)
990 for event, elem in iterator:
991 elem.clear()
992
993 self.assertEquals(0,
994 len(root))
995
997 iterwalk = self.etree.iterwalk
998 root = self.etree.XML(_bytes('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>'))
999
1000 attr_name = '{testns}bla'
1001 events = []
1002 iterator = iterwalk(root, events=('start','end','start-ns','end-ns'))
1003 for event, elem in iterator:
1004 events.append(event)
1005 if event == 'start':
1006 if elem.tag != '{ns1}a':
1007 elem.set(attr_name, 'value')
1008
1009 self.assertEquals(
1010 ['start-ns', 'start', 'start', 'start-ns', 'start',
1011 'end', 'end-ns', 'end', 'end', 'end-ns'],
1012 events)
1013
1014 self.assertEquals(
1015 None,
1016 root.get(attr_name))
1017 self.assertEquals(
1018 'value',
1019 root[0].get(attr_name))
1020
1022 iterwalk = self.etree.iterwalk
1023 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
1024
1025 counts = []
1026 for event, elem in iterwalk(root):
1027 counts.append(len(list(elem.getiterator())))
1028 self.assertEquals(
1029 [1,2,1,4],
1030 counts)
1031
1033 parse = self.etree.parse
1034 parser = self.etree.XMLParser(dtd_validation=True)
1035 assertEqual = self.assertEqual
1036 test_url = _str("__nosuch.dtd")
1037
1038 class MyResolver(self.etree.Resolver):
1039 def resolve(self, url, id, context):
1040 assertEqual(url, test_url)
1041 return self.resolve_string(
1042 _str('''<!ENTITY myentity "%s">
1043 <!ELEMENT doc ANY>''') % url, context)
1044
1045 parser.resolvers.add(MyResolver())
1046
1047 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1048 tree = parse(StringIO(xml), parser)
1049 root = tree.getroot()
1050 self.assertEquals(root.text, test_url)
1051
1053 parse = self.etree.parse
1054 parser = self.etree.XMLParser(dtd_validation=True)
1055 assertEqual = self.assertEqual
1056 test_url = _str("__nosuch.dtd")
1057
1058 class MyResolver(self.etree.Resolver):
1059 def resolve(self, url, id, context):
1060 assertEqual(url, test_url)
1061 return self.resolve_string(
1062 (_str('''<!ENTITY myentity "%s">
1063 <!ELEMENT doc ANY>''') % url).encode('utf-8'),
1064 context)
1065
1066 parser.resolvers.add(MyResolver())
1067
1068 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1069 tree = parse(StringIO(xml), parser)
1070 root = tree.getroot()
1071 self.assertEquals(root.text, test_url)
1072
1074 parse = self.etree.parse
1075 parser = self.etree.XMLParser(dtd_validation=True)
1076 assertEqual = self.assertEqual
1077 test_url = _str("__nosuch.dtd")
1078
1079 class MyResolver(self.etree.Resolver):
1080 def resolve(self, url, id, context):
1081 assertEqual(url, test_url)
1082 return self.resolve_file(
1083 SillyFileLike(
1084 _str('''<!ENTITY myentity "%s">
1085 <!ELEMENT doc ANY>''') % url), context)
1086
1087 parser.resolvers.add(MyResolver())
1088
1089 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1090 tree = parse(StringIO(xml), parser)
1091 root = tree.getroot()
1092 self.assertEquals(root.text, test_url)
1093
1095 parse = self.etree.parse
1096 parser = self.etree.XMLParser(attribute_defaults=True)
1097 assertEqual = self.assertEqual
1098 test_url = _str("__nosuch.dtd")
1099
1100 class MyResolver(self.etree.Resolver):
1101 def resolve(self, url, id, context):
1102 assertEqual(url, test_url)
1103 return self.resolve_filename(
1104 fileInTestDir('test.dtd'), context)
1105
1106 parser.resolvers.add(MyResolver())
1107
1108 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
1109 tree = parse(StringIO(xml), parser)
1110 root = tree.getroot()
1111 self.assertEquals(
1112 root.attrib, {'default': 'valueA'})
1113 self.assertEquals(
1114 root[0].attrib, {'default': 'valueB'})
1115
1117 parse = self.etree.parse
1118 parser = self.etree.XMLParser(attribute_defaults=True)
1119 assertEqual = self.assertEqual
1120 test_url = _str("__nosuch.dtd")
1121
1122 class MyResolver(self.etree.Resolver):
1123 def resolve(self, url, id, context):
1124 assertEqual(url, fileInTestDir(test_url))
1125 return self.resolve_filename(
1126 fileInTestDir('test.dtd'), context)
1127
1128 parser.resolvers.add(MyResolver())
1129
1130 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
1131 tree = parse(StringIO(xml), parser,
1132 base_url=fileInTestDir('__test.xml'))
1133 root = tree.getroot()
1134 self.assertEquals(
1135 root.attrib, {'default': 'valueA'})
1136 self.assertEquals(
1137 root[0].attrib, {'default': 'valueB'})
1138
1140 parse = self.etree.parse
1141 parser = self.etree.XMLParser(attribute_defaults=True)
1142 assertEqual = self.assertEqual
1143 test_url = _str("__nosuch.dtd")
1144
1145 class MyResolver(self.etree.Resolver):
1146 def resolve(self, url, id, context):
1147 assertEqual(url, test_url)
1148 return self.resolve_file(
1149 open(fileInTestDir('test.dtd'), 'rb'), context)
1150
1151 parser.resolvers.add(MyResolver())
1152
1153 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
1154 tree = parse(StringIO(xml), parser)
1155 root = tree.getroot()
1156 self.assertEquals(
1157 root.attrib, {'default': 'valueA'})
1158 self.assertEquals(
1159 root[0].attrib, {'default': 'valueB'})
1160
1162 parse = self.etree.parse
1163 parser = self.etree.XMLParser(load_dtd=True)
1164 assertEqual = self.assertEqual
1165 test_url = _str("__nosuch.dtd")
1166
1167 class check(object):
1168 resolved = False
1169
1170 class MyResolver(self.etree.Resolver):
1171 def resolve(self, url, id, context):
1172 assertEqual(url, test_url)
1173 check.resolved = True
1174 return self.resolve_empty(context)
1175
1176 parser.resolvers.add(MyResolver())
1177
1178 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1179 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser)
1180 self.assert_(check.resolved)
1181
1183 parse = self.etree.parse
1184 parser = self.etree.XMLParser(dtd_validation=True)
1185
1186 class _LocalException(Exception):
1187 pass
1188
1189 class MyResolver(self.etree.Resolver):
1190 def resolve(self, url, id, context):
1191 raise _LocalException
1192
1193 parser.resolvers.add(MyResolver())
1194
1195 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
1196 self.assertRaises(_LocalException, parse, BytesIO(xml), parser)
1197
1198 if etree.LIBXML_VERSION > (2,6,20):
1200 parse = self.etree.parse
1201 tostring = self.etree.tostring
1202 parser = self.etree.XMLParser(resolve_entities=False)
1203 Entity = self.etree.Entity
1204
1205 xml = _bytes('<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>')
1206 tree = parse(BytesIO(xml), parser)
1207 root = tree.getroot()
1208 self.assertEquals(root[0].tag, Entity)
1209 self.assertEquals(root[0].text, "&myentity;")
1210 self.assertEquals(root[0].tail, None)
1211 self.assertEquals(root[0].name, "myentity")
1212
1213 self.assertEquals(_bytes('<doc>&myentity;</doc>'),
1214 tostring(root))
1215
1217 xml = _bytes('''<!DOCTYPE root [ <!ENTITY nbsp " "> ]>
1218 <root>
1219 <child1/>
1220 <child2/>
1221 <child3> </child3>
1222 </root>''')
1223
1224 parser = self.etree.XMLParser(resolve_entities=False)
1225 root = etree.fromstring(xml, parser)
1226 self.assertEquals([ el.tag for el in root ],
1227 ['child1', 'child2', 'child3'])
1228
1229 root[0] = root[-1]
1230 self.assertEquals([ el.tag for el in root ],
1231 ['child3', 'child2'])
1232 self.assertEquals(root[0][0].text, ' ')
1233 self.assertEquals(root[0][0].name, 'nbsp')
1234
1236 Entity = self.etree.Entity
1237 Element = self.etree.Element
1238 tostring = self.etree.tostring
1239
1240 root = Element("root")
1241 root.append( Entity("test") )
1242
1243 self.assertEquals(root[0].tag, Entity)
1244 self.assertEquals(root[0].text, "&test;")
1245 self.assertEquals(root[0].tail, None)
1246 self.assertEquals(root[0].name, "test")
1247
1248 self.assertEquals(_bytes('<root>&test;</root>'),
1249 tostring(root))
1250
1252 Entity = self.etree.Entity
1253 self.assertEquals(Entity("test").text, '&test;')
1254 self.assertEquals(Entity("#17683").text, '䔓')
1255 self.assertEquals(Entity("#x1768").text, 'ᝨ')
1256 self.assertEquals(Entity("#x98AF").text, '颯')
1257
1259 Entity = self.etree.Entity
1260 self.assertRaises(ValueError, Entity, 'a b c')
1261 self.assertRaises(ValueError, Entity, 'a,b')
1262 self.assertRaises(ValueError, Entity, 'a\0b')
1263 self.assertRaises(ValueError, Entity, '#abc')
1264 self.assertRaises(ValueError, Entity, '#xxyz')
1265
1267 CDATA = self.etree.CDATA
1268 Element = self.etree.Element
1269 tostring = self.etree.tostring
1270
1271 root = Element("root")
1272 root.text = CDATA('test')
1273
1274 self.assertEquals('test',
1275 root.text)
1276 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
1277 tostring(root))
1278
1280 CDATA = self.etree.CDATA
1281 Element = self.etree.Element
1282 root = Element("root")
1283
1284 root.text = CDATA("test")
1285 self.assertEquals('test', root.text)
1286
1287 root.text = CDATA(_str("test"))
1288 self.assertEquals('test', root.text)
1289
1290 self.assertRaises(TypeError, CDATA, 1)
1291
1293 CDATA = self.etree.CDATA
1294 Element = self.etree.Element
1295
1296 root = Element("root")
1297 cdata = CDATA('test')
1298
1299 self.assertRaises(TypeError,
1300 setattr, root, 'tail', cdata)
1301 self.assertRaises(TypeError,
1302 root.set, 'attr', cdata)
1303 self.assertRaises(TypeError,
1304 operator.setitem, root.attrib, 'attr', cdata)
1305
1307 tostring = self.etree.tostring
1308 parser = self.etree.XMLParser(strip_cdata=False)
1309 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
1310
1311 self.assertEquals('test', root.text)
1312 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
1313 tostring(root))
1314
1316 tostring = self.etree.tostring
1317 parser = self.etree.XMLParser(strip_cdata=False)
1318 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
1319 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
1320 tostring(root))
1321
1322 self.assertEquals(['test'], root.xpath('//text()'))
1323
1324 # TypeError in etree, AssertionError in ElementTree;
1326 Element = self.etree.Element
1327 SubElement = self.etree.SubElement
1328
1329 a = Element('a')
1330 b = SubElement(a, 'b')
1331
1332 self.assertRaises(TypeError,
1333 a.__setitem__, 0, 'foo')
1334
1336 Element = self.etree.Element
1337 root = Element('root')
1338 # raises AssertionError in ElementTree
1339 self.assertRaises(TypeError, root.append, None)
1340 self.assertRaises(TypeError, root.extend, [None])
1341 self.assertRaises(TypeError, root.extend, [Element('one'), None])
1342 self.assertEquals('one', root[0].tag)
1343
1345 Element = self.etree.Element
1346 SubElement = self.etree.SubElement
1347 root = Element('root')
1348 SubElement(root, 'a')
1349 SubElement(root, 'b')
1350
1351 self.assertEquals(['a', 'b'],
1352 [c.tag for c in root])
1353 root[1].addnext(root[0])
1354 self.assertEquals(['b', 'a'],
1355 [c.tag for c in root])
1356
1358 Element = self.etree.Element
1359 SubElement = self.etree.SubElement
1360 root = Element('root')
1361 SubElement(root, 'a')
1362 SubElement(root, 'b')
1363
1364 self.assertEquals(['a', 'b'],
1365 [c.tag for c in root])
1366 root[0].addprevious(root[1])
1367 self.assertEquals(['b', 'a'],
1368 [c.tag for c in root])
1369
1371 Element = self.etree.Element
1372 a = Element('a')
1373 b = Element('b')
1374 self.assertRaises(TypeError, a.addnext, b)
1375
1377 Element = self.etree.Element
1378 a = Element('a')
1379 b = Element('b')
1380 self.assertRaises(TypeError, a.addnext, b)
1381
1383 Element = self.etree.Element
1384 SubElement = self.etree.SubElement
1385 PI = self.etree.PI
1386 root = Element('root')
1387 SubElement(root, 'a')
1388 pi = PI('TARGET', 'TEXT')
1389 pi.tail = "TAIL"
1390
1391 self.assertEquals(_bytes('<root><a></a></root>'),
1392 self._writeElement(root))
1393 root[0].addprevious(pi)
1394 self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'),
1395 self._writeElement(root))
1396
1398 Element = self.etree.Element
1399 PI = self.etree.PI
1400 root = Element('root')
1401 pi = PI('TARGET', 'TEXT')
1402 pi.tail = "TAIL"
1403
1404 self.assertEquals(_bytes('<root></root>'),
1405 self._writeElement(root))
1406 root.addprevious(pi)
1407 self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'),
1408 self._writeElement(root))
1409
1411 Element = self.etree.Element
1412 SubElement = self.etree.SubElement
1413 PI = self.etree.PI
1414 root = Element('root')
1415 SubElement(root, 'a')
1416 pi = PI('TARGET', 'TEXT')
1417 pi.tail = "TAIL"
1418
1419 self.assertEquals(_bytes('<root><a></a></root>'),
1420 self._writeElement(root))
1421 root[0].addnext(pi)
1422 self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'),
1423 self._writeElement(root))
1424
1426 Element = self.etree.Element
1427 PI = self.etree.PI
1428 root = Element('root')
1429 pi = PI('TARGET', 'TEXT')
1430 pi.tail = "TAIL"
1431
1432 self.assertEquals(_bytes('<root></root>'),
1433 self._writeElement(root))
1434 root.addnext(pi)
1435 self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'),
1436 self._writeElement(root))
1437
1439 Element = self.etree.Element
1440 SubElement = self.etree.SubElement
1441 Comment = self.etree.Comment
1442 root = Element('root')
1443 SubElement(root, 'a')
1444 comment = Comment('TEXT ')
1445 comment.tail = "TAIL"
1446
1447 self.assertEquals(_bytes('<root><a></a></root>'),
1448 self._writeElement(root))
1449 root[0].addnext(comment)
1450 self.assertEquals(_bytes('<root><a></a><!--TEXT -->TAIL</root>'),
1451 self._writeElement(root))
1452
1454 Element = self.etree.Element
1455 Comment = self.etree.Comment
1456 root = Element('root')
1457 comment = Comment('TEXT ')
1458 comment.tail = "TAIL"
1459
1460 self.assertEquals(_bytes('<root></root>'),
1461 self._writeElement(root))
1462 root.addnext(comment)
1463 self.assertEquals(_bytes('<root></root>\n<!--TEXT -->'),
1464 self._writeElement(root))
1465
1467 Element = self.etree.Element
1468 SubElement = self.etree.SubElement
1469 Comment = self.etree.Comment
1470 root = Element('root')
1471 SubElement(root, 'a')
1472 comment = Comment('TEXT ')
1473 comment.tail = "TAIL"
1474
1475 self.assertEquals(_bytes('<root><a></a></root>'),
1476 self._writeElement(root))
1477 root[0].addprevious(comment)
1478 self.assertEquals(_bytes('<root><!--TEXT -->TAIL<a></a></root>'),
1479 self._writeElement(root))
1480
1482 Element = self.etree.Element
1483 Comment = self.etree.Comment
1484 root = Element('root')
1485 comment = Comment('TEXT ')
1486 comment.tail = "TAIL"
1487
1488 self.assertEquals(_bytes('<root></root>'),
1489 self._writeElement(root))
1490 root.addprevious(comment)
1491 self.assertEquals(_bytes('<!--TEXT -->\n<root></root>'),
1492 self._writeElement(root))
1493
1494 # ET's Elements have items() and key(), but not values()
1496 XML = self.etree.XML
1497
1498 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
1499 values = root.values()
1500 values.sort()
1501 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
1502
1503 # gives error in ElementTree
1505 Element = self.etree.Element
1506 Comment = self.etree.Comment
1507
1508 a = Element('a')
1509 a.append(Comment())
1510 self.assertEquals(
1511 _bytes('<a><!----></a>'),
1512 self._writeElement(a))
1513
1514 # ElementTree ignores comments
1516 ElementTree = self.etree.ElementTree
1517 tostring = self.etree.tostring
1518
1519 xml = _bytes('<a><b/><!----><c/></a>')
1520 f = BytesIO(xml)
1521 doc = ElementTree(file=f)
1522 a = doc.getroot()
1523 self.assertEquals(
1524 '',
1525 a[1].text)
1526 self.assertEquals(
1527 xml,
1528 tostring(a))
1529
1530 # ElementTree ignores comments
1532 ElementTree = self.etree.ElementTree
1533
1534 f = BytesIO('<a><b></b><!-- hoi --><c></c></a>')
1535 doc = ElementTree(file=f)
1536 a = doc.getroot()
1537 self.assertEquals(
1538 ' hoi ',
1539 a[1].text)
1540
1541 # does not raise an exception in ElementTree
1543 Element = self.etree.Element
1544 Comment = self.etree.Comment
1545
1546 c = Comment()
1547 el = Element('myel')
1548
1549 self.assertRaises(TypeError, c.append, el)
1550 self.assertRaises(TypeError, c.insert, 0, el)
1551 self.assertRaises(TypeError, c.set, "myattr", "test")
1552
1553 # test passing 'None' to dump
1556
1558 ElementTree = self.etree.ElementTree
1559
1560 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>')
1561 doc = ElementTree(file=f)
1562 a = doc.getroot()
1563 self.assertEquals(
1564 None,
1565 a.prefix)
1566 self.assertEquals(
1567 'foo',
1568 a[0].prefix)
1569
1571 ElementTree = self.etree.ElementTree
1572
1573 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>')
1574 doc = ElementTree(file=f)
1575 a = doc.getroot()
1576 self.assertEquals(
1577 None,
1578 a.prefix)
1579 self.assertEquals(
1580 None,
1581 a[0].prefix)
1582
1584 Element = self.etree.Element
1585 SubElement = self.etree.SubElement
1586
1587 a = Element('a')
1588 b = SubElement(a, 'b')
1589 c = SubElement(a, 'c')
1590 d = SubElement(b, 'd')
1591 self.assertEquals(
1592 None,
1593 a.getparent())
1594 self.assertEquals(
1595 a,
1596 b.getparent())
1597 self.assertEquals(
1598 b.getparent(),
1599 c.getparent())
1600 self.assertEquals(
1601 b,
1602 d.getparent())
1603
1605 XML = self.etree.XML
1606
1607 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1608 result = []
1609 for el in root.iterchildren():
1610 result.append(el.tag)
1611 self.assertEquals(['one', 'two', 'three'], result)
1612
1614 XML = self.etree.XML
1615
1616 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1617 result = []
1618 for el in root.iterchildren(reversed=True):
1619 result.append(el.tag)
1620 self.assertEquals(['three', 'two', 'one'], result)
1621
1623 XML = self.etree.XML
1624
1625 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1626 result = []
1627 for el in root.iterchildren(tag='two'):
1628 result.append(el.text)
1629 self.assertEquals(['Two', 'Bla'], result)
1630
1632 XML = self.etree.XML
1633
1634 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1635 result = []
1636 for el in root.iterchildren(reversed=True, tag='two'):
1637 result.append(el.text)
1638 self.assertEquals(['Bla', 'Two'], result)
1639
1641 Element = self.etree.Element
1642 SubElement = self.etree.SubElement
1643
1644 a = Element('a')
1645 b = SubElement(a, 'b')
1646 c = SubElement(a, 'c')
1647 d = SubElement(b, 'd')
1648 self.assertEquals(
1649 [],
1650 list(a.iterancestors()))
1651 self.assertEquals(
1652 [a],
1653 list(b.iterancestors()))
1654 self.assertEquals(
1655 [a],
1656 list(c.iterancestors()))
1657 self.assertEquals(
1658 [b, a],
1659 list(d.iterancestors()))
1660
1662 Element = self.etree.Element
1663 SubElement = self.etree.SubElement
1664
1665 a = Element('a')
1666 b = SubElement(a, 'b')
1667 c = SubElement(a, 'c')
1668 d = SubElement(b, 'd')
1669 self.assertEquals(
1670 [a],
1671 list(d.iterancestors(tag='a')))
1672
1674 Element = self.etree.Element
1675 SubElement = self.etree.SubElement
1676
1677 a = Element('a')
1678 b = SubElement(a, 'b')
1679 c = SubElement(a, 'c')
1680 d = SubElement(b, 'd')
1681 e = SubElement(c, 'e')
1682
1683 self.assertEquals(
1684 [b, d, c, e],
1685 list(a.iterdescendants()))
1686 self.assertEquals(
1687 [],
1688 list(d.iterdescendants()))
1689
1691 Element = self.etree.Element
1692 SubElement = self.etree.SubElement
1693
1694 a = Element('a')
1695 b = SubElement(a, 'b')
1696 c = SubElement(a, 'c')
1697 d = SubElement(b, 'd')
1698 e = SubElement(c, 'e')
1699
1700 self.assertEquals(
1701 [],
1702 list(a.iterdescendants('a')))
1703 a2 = SubElement(e, 'a')
1704 self.assertEquals(
1705 [a2],
1706 list(a.iterdescendants('a')))
1707 self.assertEquals(
1708 [a2],
1709 list(c.iterdescendants('a')))
1710
1712 Element = self.etree.Element
1713 SubElement = self.etree.SubElement
1714
1715 a = Element('a')
1716 b = SubElement(a, 'b')
1717 c = SubElement(a, 'c')
1718 d = SubElement(b, 'd')
1719 self.assertEquals(
1720 a,
1721 a.getroottree().getroot())
1722 self.assertEquals(
1723 a,
1724 b.getroottree().getroot())
1725 self.assertEquals(
1726 a,
1727 d.getroottree().getroot())
1728
1730 Element = self.etree.Element
1731 SubElement = self.etree.SubElement
1732
1733 a = Element('a')
1734 b = SubElement(a, 'b')
1735 c = SubElement(a, 'c')
1736 self.assertEquals(
1737 None,
1738 a.getnext())
1739 self.assertEquals(
1740 c,
1741 b.getnext())
1742 self.assertEquals(
1743 None,
1744 c.getnext())
1745
1747 Element = self.etree.Element
1748 SubElement = self.etree.SubElement
1749
1750 a = Element('a')
1751 b = SubElement(a, 'b')
1752 c = SubElement(a, 'c')
1753 d = SubElement(b, 'd')
1754 self.assertEquals(
1755 None,
1756 a.getprevious())
1757 self.assertEquals(
1758 b,
1759 c.getprevious())
1760 self.assertEquals(
1761 None,
1762 b.getprevious())
1763
1765 Element = self.etree.Element
1766 SubElement = self.etree.SubElement
1767
1768 a = Element('a')
1769 b = SubElement(a, 'b')
1770 c = SubElement(a, 'c')
1771 d = SubElement(b, 'd')
1772 self.assertEquals(
1773 [],
1774 list(a.itersiblings()))
1775 self.assertEquals(
1776 [c],
1777 list(b.itersiblings()))
1778 self.assertEquals(
1779 [],
1780 list(c.itersiblings()))
1781 self.assertEquals(
1782 [b],
1783 list(c.itersiblings(preceding=True)))
1784 self.assertEquals(
1785 [],
1786 list(b.itersiblings(preceding=True)))
1787
1789 Element = self.etree.Element
1790 SubElement = self.etree.SubElement
1791
1792 a = Element('a')
1793 b = SubElement(a, 'b')
1794 c = SubElement(a, 'c')
1795 d = SubElement(b, 'd')
1796 self.assertEquals(
1797 [],
1798 list(a.itersiblings(tag='XXX')))
1799 self.assertEquals(
1800 [c],
1801 list(b.itersiblings(tag='c')))
1802 self.assertEquals(
1803 [b],
1804 list(c.itersiblings(preceding=True, tag='b')))
1805 self.assertEquals(
1806 [],
1807 list(c.itersiblings(preceding=True, tag='c')))
1808
1810 parseid = self.etree.parseid
1811 XML = self.etree.XML
1812 xml_text = _bytes('''
1813 <!DOCTYPE document [
1814 <!ELEMENT document (h1,p)*>
1815 <!ELEMENT h1 (#PCDATA)>
1816 <!ATTLIST h1 myid ID #REQUIRED>
1817 <!ELEMENT p (#PCDATA)>
1818 <!ATTLIST p someid ID #REQUIRED>
1819 ]>
1820 <document>
1821 <h1 myid="chapter1">...</h1>
1822 <p id="note1" class="note">...</p>
1823 <p>Regular paragraph.</p>
1824 <p xml:id="xmlid">XML:ID paragraph.</p>
1825 <p someid="warn1" class="warning">...</p>
1826 </document>
1827 ''')
1828
1829 tree, dic = parseid(BytesIO(xml_text))
1830 root = tree.getroot()
1831 root2 = XML(xml_text)
1832 self.assertEquals(self._writeElement(root),
1833 self._writeElement(root2))
1834 expected = {
1835 "chapter1" : root[0],
1836 "xmlid" : root[3],
1837 "warn1" : root[4]
1838 }
1839 self.assert_("chapter1" in dic)
1840 self.assert_("warn1" in dic)
1841 self.assert_("xmlid" in dic)
1842 self._checkIDDict(dic, expected)
1843
1845 XMLDTDID = self.etree.XMLDTDID
1846 XML = self.etree.XML
1847 xml_text = _bytes('''
1848 <!DOCTYPE document [
1849 <!ELEMENT document (h1,p)*>
1850 <!ELEMENT h1 (#PCDATA)>
1851 <!ATTLIST h1 myid ID #REQUIRED>
1852 <!ELEMENT p (#PCDATA)>
1853 <!ATTLIST p someid ID #REQUIRED>
1854 ]>
1855 <document>
1856 <h1 myid="chapter1">...</h1>
1857 <p id="note1" class="note">...</p>
1858 <p>Regular paragraph.</p>
1859 <p xml:id="xmlid">XML:ID paragraph.</p>
1860 <p someid="warn1" class="warning">...</p>
1861 </document>
1862 ''')
1863
1864 root, dic = XMLDTDID(xml_text)
1865 root2 = XML(xml_text)
1866 self.assertEquals(self._writeElement(root),
1867 self._writeElement(root2))
1868 expected = {
1869 "chapter1" : root[0],
1870 "xmlid" : root[3],
1871 "warn1" : root[4]
1872 }
1873 self.assert_("chapter1" in dic)
1874 self.assert_("warn1" in dic)
1875 self.assert_("xmlid" in dic)
1876 self._checkIDDict(dic, expected)
1877
1879 XMLDTDID = self.etree.XMLDTDID
1880 XML = self.etree.XML
1881 xml_text = _bytes('''
1882 <document>
1883 <h1 myid="chapter1">...</h1>
1884 <p id="note1" class="note">...</p>
1885 <p>Regular paragraph.</p>
1886 <p someid="warn1" class="warning">...</p>
1887 </document>
1888 ''')
1889
1890 root, dic = XMLDTDID(xml_text)
1891 root2 = XML(xml_text)
1892 self.assertEquals(self._writeElement(root),
1893 self._writeElement(root2))
1894 expected = {}
1895 self._checkIDDict(dic, expected)
1896
1898 self.assertEquals(len(dic),
1899 len(expected))
1900 self.assertEquals(sorted(dic.items()),
1901 sorted(expected.items()))
1902 if sys.version_info < (3,):
1903 self.assertEquals(sorted(dic.iteritems()),
1904 sorted(expected.iteritems()))
1905 self.assertEquals(sorted(dic.keys()),
1906 sorted(expected.keys()))
1907 if sys.version_info < (3,):
1908 self.assertEquals(sorted(dic.iterkeys()),
1909 sorted(expected.iterkeys()))
1910 if sys.version_info < (3,):
1911 self.assertEquals(sorted(dic.values()),
1912 sorted(expected.values()))
1913 self.assertEquals(sorted(dic.itervalues()),
1914 sorted(expected.itervalues()))
1915
1917 etree = self.etree
1918
1919 r = {'foo': 'http://ns.infrae.com/foo'}
1920 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1921 self.assertEquals(
1922 'foo',
1923 e.prefix)
1924 self.assertEquals(
1925 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'),
1926 self._writeElement(e))
1927
1929 etree = self.etree
1930
1931 r = {None: 'http://ns.infrae.com/foo'}
1932 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1933 self.assertEquals(
1934 None,
1935 e.prefix)
1936 self.assertEquals(
1937 '{http://ns.infrae.com/foo}bar',
1938 e.tag)
1939 self.assertEquals(
1940 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'),
1941 self._writeElement(e))
1942
1944 etree = self.etree
1945
1946 r = {None: 'http://ns.infrae.com/foo',
1947 'hoi': 'http://ns.infrae.com/hoi'}
1948 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1949 e.set('{http://ns.infrae.com/hoi}test', 'value')
1950 self.assertEquals(
1951 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'),
1952 self._writeElement(e))
1953
1955 etree = self.etree
1956 r = {None: 'http://ns.infrae.com/foo',
1957 'hoi': 'http://ns.infrae.com/hoi'}
1958 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r)
1959 tree = etree.ElementTree(element=e)
1960 etree.SubElement(e, '{http://ns.infrae.com/hoi}x')
1961 self.assertEquals(
1962 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'),
1963 self._writeElement(e))
1964
1966 etree = self.etree
1967
1968 r = {None: 'http://ns.infrae.com/foo'}
1969 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1970 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1971
1972 e1.append(e2)
1973
1974 self.assertEquals(
1975 None,
1976 e1.prefix)
1977 self.assertEquals(
1978 None,
1979 e1[0].prefix)
1980 self.assertEquals(
1981 '{http://ns.infrae.com/foo}bar',
1982 e1.tag)
1983 self.assertEquals(
1984 '{http://ns.infrae.com/foo}bar',
1985 e1[0].tag)
1986
1988 etree = self.etree
1989
1990 r = {None: 'http://ns.infrae.com/BAR'}
1991 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r)
1992 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1993
1994 e1.append(e2)
1995
1996 self.assertEquals(
1997 None,
1998 e1.prefix)
1999 self.assertNotEquals(
2000 None,
2001 e2.prefix)
2002 self.assertEquals(
2003 '{http://ns.infrae.com/BAR}bar',
2004 e1.tag)
2005 self.assertEquals(
2006 '{http://ns.infrae.com/foo}bar',
2007 e2.tag)
2008
2010 ns_href = "http://a.b.c"
2011 one = self.etree.fromstring(
2012 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
2013 baz = one[0][0]
2014
2015 two = self.etree.fromstring(
2016 _bytes('<root xmlns:ns="%s"/>' % ns_href))
2017 two.append(baz)
2018 del one # make sure the source document is deallocated
2019
2020 self.assertEquals('{%s}baz' % ns_href, baz.tag)
2021 self.assertEquals(
2022 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href),
2023 self.etree.tostring(two))
2024
2026 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>')
2027 root = self.etree.fromstring(xml)
2028 self.assertEquals(xml,
2029 self.etree.tostring(root))
2030 self.etree.cleanup_namespaces(root)
2031 self.assertEquals(
2032 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'),
2033 self.etree.tostring(root))
2034
2036 etree = self.etree
2037
2038 r = {None: 'http://ns.infrae.com/foo',
2039 'hoi': 'http://ns.infrae.com/hoi'}
2040 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
2041 self.assertEquals(
2042 r,
2043 e.nsmap)
2044
2046 etree = self.etree
2047
2048 re = {None: 'http://ns.infrae.com/foo',
2049 'hoi': 'http://ns.infrae.com/hoi'}
2050 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re)
2051
2052 rs = {None: 'http://ns.infrae.com/honk',
2053 'top': 'http://ns.infrae.com/top'}
2054 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs)
2055
2056 r = re.copy()
2057 r.update(rs)
2058 self.assertEquals(re, e.nsmap)
2059 self.assertEquals(r, s.nsmap)
2060
2062 Element = self.etree.Element
2063 SubElement = self.etree.SubElement
2064
2065 a = Element('{a}a')
2066 b = SubElement(a, '{a}b')
2067 c = SubElement(a, '{a}c')
2068 d = SubElement(b, '{b}d')
2069 e = SubElement(c, '{a}e')
2070 f = SubElement(c, '{b}f')
2071
2072 self.assertEquals(
2073 [a],
2074 list(a.getiterator('{a}a')))
2075 self.assertEquals(
2076 [],
2077 list(a.getiterator('{b}a')))
2078 self.assertEquals(
2079 [],
2080 list(a.getiterator('a')))
2081 self.assertEquals(
2082 [f],
2083 list(c.getiterator('{b}*')))
2084 self.assertEquals(
2085 [d, f],
2086 list(a.getiterator('{b}*')))
2087
2089 Element = self.etree.Element
2090 Entity = self.etree.Entity
2091 SubElement = self.etree.SubElement
2092
2093 a = Element('a')
2094 b = SubElement(a, 'b')
2095 entity_b = Entity("TEST-b")
2096 b.append(entity_b)
2097
2098 self.assertEquals(
2099 [entity_b],
2100 list(a.getiterator(Entity)))
2101
2102 entity_a = Entity("TEST-a")
2103 a.append(entity_a)
2104
2105 self.assertEquals(
2106 [entity_b, entity_a],
2107 list(a.getiterator(Entity)))
2108
2109 self.assertEquals(
2110 [entity_b],
2111 list(b.getiterator(Entity)))
2112
2114 Element = self.etree.Element
2115 Comment = self.etree.Comment
2116 PI = self.etree.PI
2117 SubElement = self.etree.SubElement
2118
2119 a = Element('a')
2120 b = SubElement(a, 'b')
2121 a.append(Comment("test"))
2122 a.append(PI("pi", "content"))
2123 c = SubElement(a, 'c')
2124
2125 self.assertEquals(
2126 [a, b, c],
2127 list(a.getiterator(Element)))
2128
2130 # ElementTree iterates over everything here
2131 Element = self.etree.Element
2132 Comment = self.etree.Comment
2133 PI = self.etree.PI
2134 SubElement = self.etree.SubElement
2135
2136 a = Element('a')
2137 b = SubElement(a, 'b')
2138 a.append(Comment("test"))
2139 a.append(PI("pi", "content"))
2140 c = SubElement(a, 'c')
2141
2142 self.assertEquals(
2143 [a, b, c],
2144 list(a.getiterator('*')))
2145
2147 XML = self.etree.XML
2148 ElementTree = self.etree.ElementTree
2149 QName = self.etree.QName
2150 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
2151 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])
2152
2154 XML = self.etree.XML
2155 ElementTree = self.etree.ElementTree
2156 QName = self.etree.QName
2157 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
2158 self.assertEquals(len(list(tree.findall(QName("c")))), 1)
2159
2161 XML = self.etree.XML
2162 ElementTree = self.etree.ElementTree
2163 QName = self.etree.QName
2164 tree = ElementTree(XML(
2165 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')))
2166 self.assertEquals(len(list(tree.findall(QName("b")))), 2)
2167 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)
2168
2170 XML = self.etree.XML
2171 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
2172 self.assertEquals(len(root.findall(".//{X}b")), 2)
2173 self.assertEquals(len(root.findall(".//{X}*")), 2)
2174 self.assertEquals(len(root.findall(".//b")), 3)
2175
2177 etree = self.etree
2178 e = etree.Element('foo')
2179 for i in range(10):
2180 etree.SubElement(e, 'a%s' % i)
2181 for i in range(10):
2182 self.assertEquals(
2183 i,
2184 e.index(e[i]))
2185 self.assertEquals(
2186 3, e.index(e[3], 3))
2187 self.assertRaises(
2188 ValueError, e.index, e[3], 4)
2189 self.assertRaises(
2190 ValueError, e.index, e[3], 0, 2)
2191 self.assertRaises(
2192 ValueError, e.index, e[8], 0, -3)
2193 self.assertRaises(
2194 ValueError, e.index, e[8], -5, -3)
2195 self.assertEquals(
2196 8, e.index(e[8], 0, -1))
2197 self.assertEquals(
2198 8, e.index(e[8], -12, -1))
2199 self.assertEquals(
2200 0, e.index(e[0], -12, -1))
2201
2203 etree = self.etree
2204 e = etree.Element('foo')
2205 for i in range(10):
2206 el = etree.SubElement(e, 'a%s' % i)
2207 el.text = "text%d" % i
2208 el.tail = "tail%d" % i
2209
2210 child0 = e[0]
2211 child1 = e[1]
2212 child2 = e[2]
2213
2214 e.replace(e[0], e[1])
2215 self.assertEquals(
2216 9, len(e))
2217 self.assertEquals(
2218 child1, e[0])
2219 self.assertEquals(
2220 child1.text, "text1")
2221 self.assertEquals(
2222 child1.tail, "tail1")
2223 self.assertEquals(
2224 child0.tail, "tail0")
2225 self.assertEquals(
2226 child2, e[1])
2227
2228 e.replace(e[-1], e[0])
2229 self.assertEquals(
2230 child1, e[-1])
2231 self.assertEquals(
2232 child1.text, "text1")
2233 self.assertEquals(
2234 child1.tail, "tail1")
2235 self.assertEquals(
2236 child2, e[0])
2237
2239 etree = self.etree
2240 e = etree.Element('foo')
2241 for i in range(10):
2242 etree.SubElement(e, 'a%s' % i)
2243
2244 new_element = etree.Element("test")
2245 new_element.text = "TESTTEXT"
2246 new_element.tail = "TESTTAIL"
2247 child1 = e[1]
2248 e.replace(e[0], new_element)
2249 self.assertEquals(
2250 new_element, e[0])
2251 self.assertEquals(
2252 "TESTTEXT",
2253 e[0].text)
2254 self.assertEquals(
2255 "TESTTAIL",
2256 e[0].tail)
2257 self.assertEquals(
2258 child1, e[1])
2259
2261 Element = self.etree.Element
2262 SubElement = self.etree.SubElement
2263
2264 a = Element('a')
2265
2266 e = Element('e')
2267 f = Element('f')
2268 g = Element('g')
2269
2270 s = [e, f, g]
2271 a[::-1] = s
2272 self.assertEquals(
2273 [g, f, e],
2274 list(a))
2275
2277 Element = self.etree.Element
2278 SubElement = self.etree.SubElement
2279
2280 a = Element('a')
2281 b = SubElement(a, 'b')
2282 c = SubElement(a, 'c')
2283 d = SubElement(a, 'd')
2284 e = SubElement(a, 'e')
2285
2286 x = Element('x')
2287 y = Element('y')
2288
2289 a[1::2] = [x, y]
2290 self.assertEquals(
2291 [b, x, d, y],
2292 list(a))
2293
2295 Element = self.etree.Element
2296 SubElement = self.etree.SubElement
2297
2298 a = Element('a')
2299 b = SubElement(a, 'b')
2300 c = SubElement(a, 'c')
2301 d = SubElement(a, 'd')
2302 e = SubElement(a, 'e')
2303
2304 x = Element('x')
2305 y = Element('y')
2306
2307 a[1::-1] = [x, y]
2308 self.assertEquals(
2309 [y, x, d, e],
2310 list(a))
2311
2313 Element = self.etree.Element
2314 SubElement = self.etree.SubElement
2315
2316 a = Element('a')
2317 b = SubElement(a, 'b')
2318 c = SubElement(a, 'c')
2319 d = SubElement(a, 'd')
2320 e = SubElement(a, 'e')
2321
2322 x = Element('x')
2323 y = Element('y')
2324
2325 a[::-2] = [x, y]
2326 self.assertEquals(
2327 [b, y, d, x],
2328 list(a))
2329
2331 Element = self.etree.Element
2332 SubElement = self.etree.SubElement
2333 try:
2334 slice
2335 except NameError:
2336 print("slice() not found")
2337 return
2338
2339 a = Element('a')
2340 b = SubElement(a, 'b')
2341 c = SubElement(a, 'c')
2342 d = SubElement(a, 'd')
2343 e = SubElement(a, 'e')
2344
2345 x = Element('x')
2346 y = Element('y')
2347 z = Element('z')
2348
2349 self.assertRaises(
2350 ValueError,
2351 operator.setitem, a, slice(1,None,2), [x, y, z])
2352
2353 self.assertEquals(
2354 [b, c, d, e],
2355 list(a))
2356
2358 XML = self.etree.XML
2359 root = XML(_bytes('''<?xml version="1.0"?>
2360 <root><test>
2361
2362 <bla/></test>
2363 </root>
2364 '''))
2365
2366 self.assertEquals(
2367 [2, 2, 4],
2368 [ el.sourceline for el in root.getiterator() ])
2369
2371 parse = self.etree.parse
2372 tree = parse(fileInTestDir('include/test_xinclude.xml'))
2373
2374 self.assertEquals(
2375 [1, 2, 3],
2376 [ el.sourceline for el in tree.getiterator() ])
2377
2379 iterparse = self.etree.iterparse
2380 lines = [ el.sourceline for (event, el) in
2381 iterparse(fileInTestDir('include/test_xinclude.xml')) ]
2382
2383 self.assertEquals(
2384 [2, 3, 1],
2385 lines)
2386
2388 iterparse = self.etree.iterparse
2389 lines = [ el.sourceline for (event, el) in
2390 iterparse(fileInTestDir('include/test_xinclude.xml'),
2391 events=("start",)) ]
2392
2393 self.assertEquals(
2394 [1, 2, 3],
2395 lines)
2396
2398 Element = self.etree.Element
2399 SubElement = self.etree.SubElement
2400 el = Element("test")
2401 self.assertEquals(None, el.sourceline)
2402
2403 child = SubElement(el, "test")
2404 self.assertEquals(None, el.sourceline)
2405 self.assertEquals(None, child.sourceline)
2406
2408 etree = self.etree
2409 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2410 docinfo = root.getroottree().docinfo
2411 self.assertEquals(docinfo.URL, "http://no/such/url")
2412
2414 etree = self.etree
2415 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2416 docinfo = root.getroottree().docinfo
2417 self.assertEquals(docinfo.URL, "http://no/such/url")
2418 docinfo.URL = "https://secret/url"
2419 self.assertEquals(docinfo.URL, "https://secret/url")
2420
2422 etree = self.etree
2423 tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url")
2424 docinfo = tree.docinfo
2425 self.assertEquals(docinfo.URL, "http://no/such/url")
2426
2428 etree = self.etree
2429 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2430 base_url="http://no/such/url")
2431 docinfo = tree.docinfo
2432 self.assertEquals(docinfo.URL, "http://no/such/url")
2433
2435 etree = self.etree
2436 root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url")
2437 docinfo = root.getroottree().docinfo
2438 self.assertEquals(docinfo.URL, "http://no/such/url")
2439
2441 etree = self.etree
2442 xml_header = '<?xml version="1.0" encoding="ascii"?>'
2443 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN"
2444 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
2445 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)
2446
2447 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2448
2449 tree = etree.parse(BytesIO(xml))
2450 docinfo = tree.docinfo
2451 self.assertEquals(docinfo.encoding, "ascii")
2452 self.assertEquals(docinfo.xml_version, "1.0")
2453 self.assertEquals(docinfo.public_id, pub_id)
2454 self.assertEquals(docinfo.system_url, sys_id)
2455 self.assertEquals(docinfo.root_name, 'html')
2456 self.assertEquals(docinfo.doctype, doctype_string)
2457
2459 etree = self.etree
2460 xml_header = '<?xml version="1.0" encoding="UTF-8"?>'
2461 sys_id = "some.dtd"
2462 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id
2463 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2464
2465 tree = etree.parse(BytesIO(xml))
2466 docinfo = tree.docinfo
2467 self.assertEquals(docinfo.encoding, "UTF-8")
2468 self.assertEquals(docinfo.xml_version, "1.0")
2469 self.assertEquals(docinfo.public_id, None)
2470 self.assertEquals(docinfo.system_url, sys_id)
2471 self.assertEquals(docinfo.root_name, 'html')
2472 self.assertEquals(docinfo.doctype, doctype_string)
2473
2475 etree = self.etree
2476 xml = _bytes('<html><body></body></html>')
2477 tree = etree.parse(BytesIO(xml))
2478 docinfo = tree.docinfo
2479 self.assertEquals(docinfo.encoding, "UTF-8")
2480 self.assertEquals(docinfo.xml_version, "1.0")
2481 self.assertEquals(docinfo.public_id, None)
2482 self.assertEquals(docinfo.system_url, None)
2483 self.assertEquals(docinfo.root_name, 'html')
2484 self.assertEquals(docinfo.doctype, '')
2485
2487 etree = self.etree
2488 xml = _bytes('<!DOCTYPE root><root></root>')
2489 tree = etree.parse(BytesIO(xml))
2490 docinfo = tree.docinfo
2491 self.assertEquals(docinfo.encoding, "UTF-8")
2492 self.assertEquals(docinfo.xml_version, "1.0")
2493 self.assertEquals(docinfo.public_id, None)
2494 self.assertEquals(docinfo.system_url, None)
2495 self.assertEquals(docinfo.root_name, 'root')
2496 self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')
2497
2499 etree = self.etree
2500 xml = _bytes('<!DOCTYPE root>\n<root/>')
2501 tree = etree.parse(BytesIO(xml))
2502 self.assertEquals(xml, etree.tostring(tree))
2503
2505 etree = self.etree
2506 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN"
2507 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
2508 doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id))
2509
2510 xml = _bytes('<!DOCTYPE root>\n<root/>')
2511 tree = etree.parse(BytesIO(xml))
2512 self.assertEquals(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string),
2513 etree.tostring(tree, doctype=doctype_string))
2514
2516 etree = self.etree
2517 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2518 self.assertEquals(root.base, "http://no/such/url")
2519 self.assertEquals(
2520 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2521 root.base = "https://secret/url"
2522 self.assertEquals(root.base, "https://secret/url")
2523 self.assertEquals(
2524 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2525 "https://secret/url")
2526
2528 etree = self.etree
2529 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2530 self.assertEquals(root.base, "http://no/such/url")
2531 self.assertEquals(
2532 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2533 root.set('{http://www.w3.org/XML/1998/namespace}base',
2534 "https://secret/url")
2535 self.assertEquals(root.base, "https://secret/url")
2536 self.assertEquals(
2537 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2538 "https://secret/url")
2539
2541 etree = self.etree
2542 root = etree.HTML(_bytes("<html><body></body></html>"),
2543 base_url="http://no/such/url")
2544 self.assertEquals(root.base, "http://no/such/url")
2545
2547 etree = self.etree
2548 root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>'))
2549 self.assertEquals(root.base, "http://no/such/url")
2550
2552 # parse from a file object that returns unicode strings
2553 f = LargeFileLikeUnicode()
2554 tree = self.etree.parse(f)
2555 root = tree.getroot()
2556 self.assert_(root.tag.endswith('root'))
2557
2559 # check that DTDs that go in also go back out
2560 xml = _bytes('''\
2561 <!DOCTYPE test SYSTEM "test.dtd" [
2562 <!ENTITY entity "tasty">
2563 <!ELEMENT test (a)>
2564 <!ELEMENT a (#PCDATA)>
2565 ]>
2566 <test><a>test-test</a></test>\
2567 ''')
2568 tree = self.etree.parse(BytesIO(xml))
2569 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")),
2570 xml.replace(_bytes(" "), _bytes("")))
2571
2573 Element = self.etree.Element
2574
2575 a = Element('a')
2576 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho')
2577 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho')
2578
2579 self.assertRaises(ValueError, Element, 'ha\0ho')
2580
2582 Element = self.etree.Element
2583
2584 a = Element('a')
2585 self.assertRaises(ValueError, setattr, a, "text",
2586 _str('ha\0ho'))
2587 self.assertRaises(ValueError, setattr, a, "tail",
2588 _str('ha\0ho'))
2589
2590 self.assertRaises(ValueError, Element,
2591 _str('ha\0ho'))
2592
2594 Element = self.etree.Element
2595
2596 a = Element('a')
2597 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho')
2598 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho')
2599
2600 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho')
2601 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho')
2602
2603 self.assertRaises(ValueError, Element, 'ha\x07ho')
2604 self.assertRaises(ValueError, Element, 'ha\x02ho')
2605
2607 Element = self.etree.Element
2608
2609 a = Element('a')
2610 self.assertRaises(ValueError, setattr, a, "text",
2611 _str('ha\x07ho'))
2612 self.assertRaises(ValueError, setattr, a, "text",
2613 _str('ha\x02ho'))
2614
2615 self.assertRaises(ValueError, setattr, a, "tail",
2616 _str('ha\x07ho'))
2617 self.assertRaises(ValueError, setattr, a, "tail",
2618 _str('ha\x02ho'))
2619
2620 self.assertRaises(ValueError, Element,
2621 _str('ha\x07ho'))
2622 self.assertRaises(ValueError, Element,
2623 _str('ha\x02ho'))
2624
2626 Element = self.etree.Element
2627
2628 a = Element('a')
2629 self.assertRaises(ValueError, setattr, a, "text",
2630 _str('ha\u1234\x07ho'))
2631 self.assertRaises(ValueError, setattr, a, "text",
2632 _str('ha\u1234\x02ho'))
2633
2634 self.assertRaises(ValueError, setattr, a, "tail",
2635 _str('ha\u1234\x07ho'))
2636 self.assertRaises(ValueError, setattr, a, "tail",
2637 _str('ha\u1234\x02ho'))
2638
2639 self.assertRaises(ValueError, Element,
2640 _str('ha\u1234\x07ho'))
2641 self.assertRaises(ValueError, Element,
2642 _str('ha\u1234\x02ho'))
2643
2645 # ElementTree fails to serialize this
2646 tostring = self.etree.tostring
2647 Element = self.etree.Element
2648 SubElement = self.etree.SubElement
2649
2650 a = Element('a')
2651 b = SubElement(a, 'b')
2652 c = SubElement(a, 'c')
2653
2654 result = tostring(a, encoding='UTF-16')
2655 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2656 canonicalize(result))
2657
2659 # ElementTree raises an AssertionError here
2660 tostring = self.etree.tostring
2661 self.assertRaises(TypeError, self.etree.tostring, None)
2662
2664 tostring = self.etree.tostring
2665 Element = self.etree.Element
2666 SubElement = self.etree.SubElement
2667
2668 a = Element('a')
2669 b = SubElement(a, 'b')
2670 c = SubElement(a, 'c')
2671
2672 result = tostring(a)
2673 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2674
2675 result = tostring(a, pretty_print=False)
2676 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2677
2678 result = tostring(a, pretty_print=True)
2679 self.assertEquals(result, _bytes("<a>\n <b/>\n <c/>\n</a>\n"))
2680
2682 tostring = self.etree.tostring
2683 Element = self.etree.Element
2684 SubElement = self.etree.SubElement
2685
2686 a = Element('a')
2687 a.tail = "aTAIL"
2688 b = SubElement(a, 'b')
2689 b.tail = "bTAIL"
2690 c = SubElement(a, 'c')
2691
2692 result = tostring(a)
2693 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2694
2695 result = tostring(a, with_tail=False)
2696 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>"))
2697
2698 result = tostring(a, with_tail=True)
2699 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2700
2702 tostring = self.etree.tostring
2703 XML = self.etree.XML
2704 ElementTree = self.etree.ElementTree
2705 Element = self.etree.Element
2706
2707 tree = Element("root").getroottree()
2708 self.assertEquals(None, tree.docinfo.standalone)
2709
2710 tree = XML(_bytes("<root/>")).getroottree()
2711 self.assertEquals(None, tree.docinfo.standalone)
2712
2713 tree = XML(_bytes(
2714 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"
2715 )).getroottree()
2716 self.assertEquals(True, tree.docinfo.standalone)
2717
2718 tree = XML(_bytes(
2719 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"
2720 )).getroottree()
2721 self.assertEquals(False, tree.docinfo.standalone)
2722
2724 tostring = self.etree.tostring
2725 XML = self.etree.XML
2726 ElementTree = self.etree.ElementTree
2727
2728 root = XML(_bytes("<root/>"))
2729
2730 tree = ElementTree(root)
2731 self.assertEquals(None, tree.docinfo.standalone)
2732
2733 result = tostring(root, xml_declaration=True, encoding="ASCII")
2734 self.assertEquals(result, _bytes(
2735 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2736
2737 result = tostring(root, xml_declaration=True, encoding="ASCII",
2738 standalone=True)
2739 self.assertEquals(result, _bytes(
2740 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2741
2742 tree = ElementTree(XML(result))
2743 self.assertEquals(True, tree.docinfo.standalone)
2744
2745 result = tostring(root, xml_declaration=True, encoding="ASCII",
2746 standalone=False)
2747 self.assertEquals(result, _bytes(
2748 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"))
2749
2750 tree = ElementTree(XML(result))
2751 self.assertEquals(False, tree.docinfo.standalone)
2752
2754 tostring = self.etree.tostring
2755 XML = self.etree.XML
2756 ElementTree = self.etree.ElementTree
2757
2758 root = XML(_bytes(
2759 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>"))
2760
2761 tree = ElementTree(root)
2762 self.assertEquals(True, tree.docinfo.standalone)
2763
2764 result = tostring(root, xml_declaration=True, encoding="ASCII")
2765 self.assertEquals(result, _bytes(
2766 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2767
2768 result = tostring(root, xml_declaration=True, encoding="ASCII",
2769 standalone=True)
2770 self.assertEquals(result, _bytes(
2771 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2772
2774 tostring = self.etree.tostring
2775 Element = self.etree.Element
2776 SubElement = self.etree.SubElement
2777
2778 a = Element('a')
2779 a.text = "A"
2780 a.tail = "tail"
2781 b = SubElement(a, 'b')
2782 b.text = "B"
2783 b.tail = _str("Søk på nettet")
2784 c = SubElement(a, 'c')
2785 c.text = "C"
2786
2787 result = tostring(a, method="text", encoding="UTF-16")
2788
2789 self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"),
2790 result)
2791
2793 tostring = self.etree.tostring
2794 Element = self.etree.Element
2795 SubElement = self.etree.SubElement
2796
2797 a = Element('a')
2798 a.text = _str('Søk på nettetA')
2799 a.tail = "tail"
2800 b = SubElement(a, 'b')
2801 b.text = "B"
2802 b.tail = _str('Søk på nettetB')
2803 c = SubElement(a, 'c')
2804 c.text = "C"
2805
2806 self.assertRaises(UnicodeEncodeError,
2807 tostring, a, method="text")
2808
2809 self.assertEquals(
2810 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'),
2811 tostring(a, encoding="UTF-8", method="text"))
2812
2814 tounicode = self.etree.tounicode
2815 Element = self.etree.Element
2816 SubElement = self.etree.SubElement
2817
2818 a = Element('a')
2819 b = SubElement(a, 'b')
2820 c = SubElement(a, 'c')
2821
2822 self.assert_(isinstance(tounicode(a), _unicode))
2823 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2824 canonicalize(tounicode(a)))
2825
2827 tounicode = self.etree.tounicode
2828 Element = self.etree.Element
2829 SubElement = self.etree.SubElement
2830
2831 a = Element('a')
2832 b = SubElement(a, 'b')
2833 c = SubElement(a, 'c')
2834 d = SubElement(c, 'd')
2835 self.assert_(isinstance(tounicode(b), _unicode))
2836 self.assert_(isinstance(tounicode(c), _unicode))
2837 self.assertEquals(_bytes('<b></b>'),
2838 canonicalize(tounicode(b)))
2839 self.assertEquals(_bytes('<c><d></d></c>'),
2840 canonicalize(tounicode(c)))
2841
2845
2847 tounicode = self.etree.tounicode
2848 Element = self.etree.Element
2849 SubElement = self.etree.SubElement
2850
2851 a = Element('a')
2852 b = SubElement(a, 'b')
2853 c = SubElement(a, 'c')
2854 d = SubElement(c, 'd')
2855 b.tail = 'Foo'
2856
2857 self.assert_(isinstance(tounicode(b), _unicode))
2858 self.assert_(tounicode(b) == '<b/>Foo' or
2859 tounicode(b) == '<b />Foo')
2860
2862 tounicode = self.etree.tounicode
2863 Element = self.etree.Element
2864 SubElement = self.etree.SubElement
2865
2866 a = Element('a')
2867 b = SubElement(a, 'b')
2868 c = SubElement(a, 'c')
2869
2870 result = tounicode(a)
2871 self.assertEquals(result, "<a><b/><c/></a>")
2872
2873 result = tounicode(a, pretty_print=False)
2874 self.assertEquals(result, "<a><b/><c/></a>")
2875
2876 result = tounicode(a, pretty_print=True)
2877 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2878
2880 tostring = self.etree.tostring
2881 Element = self.etree.Element
2882 SubElement = self.etree.SubElement
2883
2884 a = Element('a')
2885 b = SubElement(a, 'b')
2886 c = SubElement(a, 'c')
2887
2888 self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode))
2889 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2890 canonicalize(tostring(a, encoding=_unicode)))
2891
2893 tostring = self.etree.tostring
2894 Element = self.etree.Element
2895 SubElement = self.etree.SubElement
2896
2897 a = Element('a')
2898 b = SubElement(a, 'b')
2899 c = SubElement(a, 'c')
2900 d = SubElement(c, 'd')
2901 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2902 self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode))
2903 self.assertEquals(_bytes('<b></b>'),
2904 canonicalize(tostring(b, encoding=_unicode)))
2905 self.assertEquals(_bytes('<c><d></d></c>'),
2906 canonicalize(tostring(c, encoding=_unicode)))
2907
2909 tostring = self.etree.tostring
2910 self.assertRaises(TypeError, self.etree.tostring,
2911 None, encoding=_unicode)
2912
2914 tostring = self.etree.tostring
2915 Element = self.etree.Element
2916 SubElement = self.etree.SubElement
2917
2918 a = Element('a')
2919 b = SubElement(a, 'b')
2920 c = SubElement(a, 'c')
2921 d = SubElement(c, 'd')
2922 b.tail = 'Foo'
2923
2924 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2925 self.assert_(tostring(b, encoding=_unicode) == '<b/>Foo' or
2926 tostring(b, encoding=_unicode) == '<b />Foo')
2927
2929 tostring = self.etree.tostring
2930 Element = self.etree.Element
2931 SubElement = self.etree.SubElement
2932
2933 a = Element('a')
2934 b = SubElement(a, 'b')
2935 c = SubElement(a, 'c')
2936
2937 result = tostring(a, encoding=_unicode)
2938 self.assertEquals(result, "<a><b/><c/></a>")
2939
2940 result = tostring(a, encoding=_unicode, pretty_print=False)
2941 self.assertEquals(result, "<a><b/><c/></a>")
2942
2943 result = tostring(a, encoding=_unicode, pretty_print=True)
2944 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2945
2946 # helper methods
2947
2949 """Write out element for comparison.
2950 """
2951 ElementTree = self.etree.ElementTree
2952 f = BytesIO()
2953 tree = ElementTree(element=element)
2954 tree.write(f, encoding=encoding, compression=compression)
2955 data = f.getvalue()
2956 if compression:
2957 data = zlib.decompress(data)
2958 return canonicalize(data)
2959
2960
2963 filename = fileInTestDir('test_broken.xml')
2964 root = etree.XML(_bytes('''\
2965 <doc xmlns:xi="http://www.w3.org/2001/XInclude">
2966 <xi:include href="%s" parse="text"/>
2967 </doc>
2968 ''' % filename))
2969 old_text = root.text
2970 content = read_file(filename)
2971 old_tail = root[0].tail
2972
2973 self.include( etree.ElementTree(root) )
2974 self.assertEquals(old_text + content + old_tail,
2975 root.text)
2976
2978 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'))
2979 self.assertNotEquals(
2980 'a',
2981 tree.getroot()[1].tag)
2982 # process xincludes
2983 self.include( tree )
2984 # check whether we find it replaced with included data
2985 self.assertEquals(
2986 'a',
2987 tree.getroot()[1].tag)
2988
2990 class res(etree.Resolver):
2991 include_text = read_file(fileInTestDir('test.xml'))
2992 called = {}
2993 def resolve(self, url, id, context):
2994 if url.endswith(".dtd"):
2995 self.called["dtd"] = True
2996 return self.resolve_filename(
2997 fileInTestDir('test.dtd'), context)
2998 elif url.endswith("test_xinclude.xml"):
2999 self.called["input"] = True
3000 return None # delegate to default resolver
3001 else:
3002 self.called["include"] = True
3003 return self.resolve_string(self.include_text, context)
3004
3005 res_instance = res()
3006 parser = etree.XMLParser(load_dtd = True)
3007 parser.resolvers.add(res_instance)
3008
3009 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
3010 parser = parser)
3011
3012 self.include(tree)
3013
3014 called = list(res_instance.called.items())
3015 called.sort()
3016 self.assertEquals(
3017 [("dtd", True), ("include", True), ("input", True)],
3018 called)
3019
3023
3024
3029
3030
3033 tree = self.parse(_bytes('<a><b/></a>'))
3034 f = BytesIO()
3035 tree.write_c14n(f)
3036 s = f.getvalue()
3037 self.assertEquals(_bytes('<a><b></b></a>'),
3038 s)
3039
3041 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3042 f = BytesIO()
3043 tree.write_c14n(f, compression=9)
3044 gzfile = gzip.GzipFile(fileobj=BytesIO(f.getvalue()))
3045 try:
3046 s = gzfile.read()
3047 finally:
3048 gzfile.close()
3049 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
3050 s)
3051
3053 tree = self.parse(_bytes('<a><b/></a>'))
3054 handle, filename = tempfile.mkstemp()
3055 try:
3056 tree.write_c14n(filename)
3057 data = read_file(filename, 'rb')
3058 finally:
3059 os.close(handle)
3060 os.remove(filename)
3061 self.assertEquals(_bytes('<a><b></b></a>'),
3062 data)
3063
3065 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3066 handle, filename = tempfile.mkstemp()
3067 try:
3068 tree.write_c14n(filename, compression=9)
3069 f = gzip.open(filename, 'rb')
3070 try:
3071 data = f.read()
3072 finally:
3073 f.close()
3074 finally:
3075 os.close(handle)
3076 os.remove(filename)
3077 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
3078 data)
3079
3081 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
3082 f = BytesIO()
3083 tree.write_c14n(f)
3084 s = f.getvalue()
3085 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3086 s)
3087 f = BytesIO()
3088 tree.write_c14n(f, with_comments=True)
3089 s = f.getvalue()
3090 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3091 s)
3092 f = BytesIO()
3093 tree.write_c14n(f, with_comments=False)
3094 s = f.getvalue()
3095 self.assertEquals(_bytes('<a><b></b></a>'),
3096 s)
3097
3099 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
3100 s = etree.tostring(tree, method='c14n')
3101 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3102 s)
3103 s = etree.tostring(tree, method='c14n', with_comments=True)
3104 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3105 s)
3106 s = etree.tostring(tree, method='c14n', with_comments=False)
3107 self.assertEquals(_bytes('<a><b></b></a>'),
3108 s)
3109
3111 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
3112 s = etree.tostring(tree.getroot(), method='c14n')
3113 self.assertEquals(_bytes('<a><!--ho--><b></b></a>'),
3114 s)
3115 s = etree.tostring(tree.getroot(), method='c14n', with_comments=True)
3116 self.assertEquals(_bytes('<a><!--ho--><b></b></a>'),
3117 s)
3118 s = etree.tostring(tree.getroot(), method='c14n', with_comments=False)
3119 self.assertEquals(_bytes('<a><b></b></a>'),
3120 s)
3121
3123 tree = self.parse(_bytes(
3124 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3125 f = BytesIO()
3126 tree.write_c14n(f)
3127 s = f.getvalue()
3128 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3129 s)
3130 f = BytesIO()
3131 tree.write_c14n(f, exclusive=False)
3132 s = f.getvalue()
3133 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3134 s)
3135 f = BytesIO()
3136 tree.write_c14n(f, exclusive=True)
3137 s = f.getvalue()
3138 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3139 s)
3140
3142 tree = self.parse(_bytes(
3143 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3144 s = etree.tostring(tree, method='c14n')
3145 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3146 s)
3147 s = etree.tostring(tree, method='c14n', exclusive=False)
3148 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3149 s)
3150 s = etree.tostring(tree, method='c14n', exclusive=True)
3151 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3152 s)
3153
3155 tree = self.parse(_bytes(
3156 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3157 s = etree.tostring(tree.getroot(), method='c14n')
3158 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3159 s)
3160 s = etree.tostring(tree.getroot(), method='c14n', exclusive=False)
3161 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3162 s)
3163 s = etree.tostring(tree.getroot(), method='c14n', exclusive=True)
3164 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3165 s)
3166
3167 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=False)
3168 self.assertEquals(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'),
3169 s)
3170 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True)
3171 self.assertEquals(_bytes('<z:b xmlns:z="http://cde"></z:b>'),
3172 s)
3173
3174
3177 tree = self.parse(_bytes('<a><b/></a>'))
3178 f = BytesIO()
3179 tree.write(f)
3180 s = f.getvalue()
3181 self.assertEquals(_bytes('<a><b/></a>'),
3182 s)
3183
3185 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3186 f = BytesIO()
3187 tree.write(f, compression=9)
3188 gzfile = gzip.GzipFile(fileobj=BytesIO(f.getvalue()))
3189 try:
3190 s = gzfile.read()
3191 finally:
3192 gzfile.close()
3193 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3194 s)
3195
3197 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3198 f = BytesIO()
3199 tree.write(f, compression=0)
3200 s0 = f.getvalue()
3201
3202 f = BytesIO()
3203 tree.write(f)
3204 self.assertEquals(f.getvalue(), s0)
3205
3206 f = BytesIO()
3207 tree.write(f, compression=1)
3208 s = f.getvalue()
3209 self.assert_(len(s) <= len(s0))
3210 gzfile = gzip.GzipFile(fileobj=BytesIO(s))
3211 try:
3212 s1 = gzfile.read()
3213 finally:
3214 gzfile.close()
3215
3216 f = BytesIO()
3217 tree.write(f, compression=9)
3218 s = f.getvalue()
3219 self.assert_(len(s) <= len(s0))
3220 gzfile = gzip.GzipFile(fileobj=BytesIO(s))
3221 try:
3222 s9 = gzfile.read()
3223 finally:
3224 gzfile.close()
3225
3226 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3227 s0)
3228 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3229 s1)
3230 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3231 s9)
3232
3234 tree = self.parse(_bytes('<a><b/></a>'))
3235 handle, filename = tempfile.mkstemp()
3236 try:
3237 tree.write(filename)
3238 data = read_file(filename, 'rb')
3239 finally:
3240 os.close(handle)
3241 os.remove(filename)
3242 self.assertEquals(_bytes('<a><b/></a>'),
3243 data)
3244
3246 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3247 handle, filename = tempfile.mkstemp()
3248 try:
3249 tree.write(filename, compression=9)
3250 f = gzip.open(filename, 'rb')
3251 try:
3252 data = f.read()
3253 finally:
3254 f.close()
3255 finally:
3256 os.close(handle)
3257 os.remove(filename)
3258 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3259 data)
3260
3262 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3263 handle, filename = tempfile.mkstemp()
3264 try:
3265 tree.write(filename, compression=9)
3266 data = etree.tostring(etree.parse(filename))
3267 finally:
3268 os.close(handle)
3269 os.remove(filename)
3270 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3271 data)
3272
3274 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
3275 handle, filename = tempfile.mkstemp()
3276 try:
3277 tree.write(filename, compression=9)
3278 data = etree.tostring(etree.parse(
3279 gzip.GzipFile(filename)))
3280 finally:
3281 os.close(handle)
3282 os.remove(filename)
3283 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
3284 data)
3285
3287 etree = etree
3288
3290 parse = self.etree.parse
3291 f = BytesIO('<a><b></c></b></a>')
3292 self.etree.clear_error_log()
3293 try:
3294 parse(f)
3295 logs = None
3296 except SyntaxError:
3297 e = sys.exc_info()[1]
3298 logs = e.error_log
3299 f.close()
3300 self.assert_([ log for log in logs
3301 if 'mismatch' in log.message ])
3302 self.assert_([ log for log in logs
3303 if 'PARSER' in log.domain_name])
3304 self.assert_([ log for log in logs
3305 if 'ERR_TAG_NAME_MISMATCH' in log.type_name ])
3306 self.assert_([ log for log in logs
3307 if 1 == log.line ])
3308 self.assert_([ log for log in logs
3309 if 15 == log.column ])
3310
3321
3322 self.etree.use_global_python_log(Logger())
3323 f = BytesIO('<a><b></c></b></a>')
3324 try:
3325 parse(f)
3326 except SyntaxError:
3327 pass
3328 f.close()
3329
3330 self.assert_([ message for message in messages
3331 if 'mismatch' in message ])
3332 self.assert_([ message for message in messages
3333 if ':PARSER:' in message])
3334 self.assert_([ message for message in messages
3335 if ':ERR_TAG_NAME_MISMATCH:' in message ])
3336 self.assert_([ message for message in messages
3337 if ':1:15:' in message ])
3338
3340 suite = unittest.TestSuite()
3341 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)])
3342 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)])
3343 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)])
3344 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)])
3345 suite.addTests([unittest.makeSuite(ETreeWriteTestCase)])
3346 suite.addTests([unittest.makeSuite(ETreeErrorLogTest)])
3347 suite.addTests(
3348 [make_doctest('../../../doc/tutorial.txt')])
3349 suite.addTests(
3350 [make_doctest('../../../doc/api.txt')])
3351 suite.addTests(
3352 [make_doctest('../../../doc/FAQ.txt')])
3353 suite.addTests(
3354 [make_doctest('../../../doc/parsing.txt')])
3355 suite.addTests(
3356 [make_doctest('../../../doc/resolvers.txt')])
3357 return suite
3358
3359 if __name__ == '__main__':
3360 print('to test use test.py %s' % __file__)
3361
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Fri Nov 11 18:38:29 2011 | http://epydoc.sourceforge.net |