| 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, unittest, copy, sys, operator, tempfile, gzip
11
12 this_dir = os.path.dirname(__file__)
13 if this_dir not in sys.path:
14 sys.path.insert(0, this_dir) # needed for Py3
15
16 from common_imports import etree, StringIO, BytesIO, HelperTestCase, fileInTestDir
17 from common_imports import SillyFileLike, LargeFileLikeUnicode, doctest, make_doctest
18 from common_imports import canonicalize, sorted, _str, _bytes
19
20 print("")
21 print("TESTED VERSION: %s" % etree.__version__)
22 print(" Python: " + repr(sys.version_info))
23 print(" lxml.etree: " + repr(etree.LXML_VERSION))
24 print(" libxml used: " + repr(etree.LIBXML_VERSION))
25 print(" libxml compiled: " + repr(etree.LIBXML_COMPILED_VERSION))
26 print(" libxslt used: " + repr(etree.LIBXSLT_VERSION))
27 print(" libxslt compiled: " + repr(etree.LIBXSLT_COMPILED_VERSION))
28 print("")
29
30 try:
31 _unicode = unicode
32 except NameError:
33 # Python 3
34 _unicode = str
35
37 """Tests only for etree, not ElementTree"""
38 etree = etree
39
41 self.assert_(isinstance(etree.__version__, _unicode))
42 self.assert_(isinstance(etree.LXML_VERSION, tuple))
43 self.assertEqual(len(etree.LXML_VERSION), 4)
44 self.assert_(isinstance(etree.LXML_VERSION[0], int))
45 self.assert_(isinstance(etree.LXML_VERSION[1], int))
46 self.assert_(isinstance(etree.LXML_VERSION[2], int))
47 self.assert_(isinstance(etree.LXML_VERSION[3], int))
48 self.assert_(etree.__version__.startswith(
49 str(etree.LXML_VERSION[0])))
50
52 if hasattr(self.etree, '__pyx_capi__'):
53 # newer Pyrex compatible C-API
54 self.assert_(isinstance(self.etree.__pyx_capi__, dict))
55 self.assert_(len(self.etree.__pyx_capi__) > 0)
56 else:
57 # older C-API mechanism
58 self.assert_(hasattr(self.etree, '_import_c_api'))
59
61 Element = self.etree.Element
62 el = Element('name')
63 self.assertEquals(el.tag, 'name')
64 el = Element('{}name')
65 self.assertEquals(el.tag, 'name')
66
68 Element = self.etree.Element
69 el = Element('name')
70 self.assertRaises(ValueError, Element, '{}')
71 self.assertRaises(ValueError, setattr, el, 'tag', '{}')
72
73 self.assertRaises(ValueError, Element, '{test}')
74 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')
75
77 Element = self.etree.Element
78 self.assertRaises(ValueError, Element, 'p:name')
79 self.assertRaises(ValueError, Element, '{test}p:name')
80
81 el = Element('name')
82 self.assertRaises(ValueError, setattr, el, 'tag', 'p:name')
83
85 Element = self.etree.Element
86 self.assertRaises(ValueError, Element, "p'name")
87 self.assertRaises(ValueError, Element, 'p"name')
88
89 self.assertRaises(ValueError, Element, "{test}p'name")
90 self.assertRaises(ValueError, Element, '{test}p"name')
91
92 el = Element('name')
93 self.assertRaises(ValueError, setattr, el, 'tag', "p'name")
94 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')
95
97 Element = self.etree.Element
98 self.assertRaises(ValueError, Element, ' name ')
99 self.assertRaises(ValueError, Element, 'na me')
100 self.assertRaises(ValueError, Element, '{test} name')
101
102 el = Element('name')
103 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
104
106 Element = self.etree.Element
107 SubElement = self.etree.SubElement
108
109 el = Element('name')
110 self.assertRaises(ValueError, SubElement, el, '{}')
111 self.assertRaises(ValueError, SubElement, el, '{test}')
112
114 Element = self.etree.Element
115 SubElement = self.etree.SubElement
116
117 el = Element('name')
118 self.assertRaises(ValueError, SubElement, el, 'p:name')
119 self.assertRaises(ValueError, SubElement, el, '{test}p:name')
120
122 Element = self.etree.Element
123 SubElement = self.etree.SubElement
124
125 el = Element('name')
126 self.assertRaises(ValueError, SubElement, el, "p'name")
127 self.assertRaises(ValueError, SubElement, el, "{test}p'name")
128
129 self.assertRaises(ValueError, SubElement, el, 'p"name')
130 self.assertRaises(ValueError, SubElement, el, '{test}p"name')
131
133 Element = self.etree.Element
134 SubElement = self.etree.SubElement
135
136 el = Element('name')
137 self.assertRaises(ValueError, SubElement, el, ' name ')
138 self.assertRaises(ValueError, SubElement, el, 'na me')
139 self.assertRaises(ValueError, SubElement, el, '{test} name')
140
142 QName = self.etree.QName
143 self.assertRaises(ValueError, QName, '')
144 self.assertRaises(ValueError, QName, 'test', '')
145
147 QName = self.etree.QName
148 self.assertRaises(ValueError, QName, 'p:name')
149 self.assertRaises(ValueError, QName, 'test', 'p:name')
150
152 QName = self.etree.QName
153 self.assertRaises(ValueError, QName, ' name ')
154 self.assertRaises(ValueError, QName, 'na me')
155 self.assertRaises(ValueError, QName, 'test', ' name')
156
158 # ET doesn't have namespace/localname properties on QNames
159 QName = self.etree.QName
160 namespace, localname = 'http://myns', 'a'
161 qname = QName(namespace, localname)
162 self.assertEquals(namespace, qname.namespace)
163 self.assertEquals(localname, qname.localname)
164
166 # ET doesn't have namespace/localname properties on QNames
167 QName = self.etree.QName
168 qname1 = QName('http://myns', 'a')
169 a = self.etree.Element(qname1, nsmap={'p' : 'http://myns'})
170
171 qname2 = QName(a)
172 self.assertEquals(a.tag, qname1.text)
173 self.assertEquals(qname1.text, qname2.text)
174 self.assertEquals(qname1, qname2)
175
177 # ET doesn't resove QNames as text values
178 etree = self.etree
179 qname = etree.QName('http://myns', 'a')
180 a = etree.Element(qname, nsmap={'p' : 'http://myns'})
181 a.text = qname
182
183 self.assertEquals("p:a", a.text)
184
186 etree = self.etree
187 self.assertRaises(ValueError,
188 etree.Element, "root", nsmap={'"' : 'testns'})
189 self.assertRaises(ValueError,
190 etree.Element, "root", nsmap={'&' : 'testns'})
191 self.assertRaises(ValueError,
192 etree.Element, "root", nsmap={'a:b' : 'testns'})
193
195 Element = self.etree.Element
196 root = Element("root")
197 root.set("attr", "TEST")
198 self.assertEquals("TEST", root.get("attr"))
199
201 # ElementTree accepts arbitrary attribute values
202 # lxml.etree allows only strings
203 Element = self.etree.Element
204 root = Element("root")
205 self.assertRaises(TypeError, root.set, "newattr", 5)
206 self.assertRaises(TypeError, root.set, "newattr", None)
207
209 XML = self.etree.XML
210 xml = _bytes('<test a="5" b="10" c="20"><x a="4" b="2"/></test>')
211
212 root = XML(xml)
213 self.etree.strip_attributes(root, 'a')
214 self.assertEquals(_bytes('<test b="10" c="20"><x b="2"></x></test>'),
215 self._writeElement(root))
216
217 root = XML(xml)
218 self.etree.strip_attributes(root, 'b', 'c')
219 self.assertEquals(_bytes('<test a="5"><x a="4"></x></test>'),
220 self._writeElement(root))
221
223 XML = self.etree.XML
224 xml = _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20" n:a="5"><x a="4" n:b="2"/></test>')
225
226 root = XML(xml)
227 self.etree.strip_attributes(root, 'a')
228 self.assertEquals(
229 _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'),
230 self._writeElement(root))
231
232 root = XML(xml)
233 self.etree.strip_attributes(root, '{http://test/ns}a', 'c')
234 self.assertEquals(
235 _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'),
236 self._writeElement(root))
237
238 root = XML(xml)
239 self.etree.strip_attributes(root, '{http://test/ns}*')
240 self.assertEquals(
241 _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'),
242 self._writeElement(root))
243
245 XML = self.etree.XML
246 xml = _bytes('<test><a><b><c/></b></a><x><a><b/><c/></a></x></test>')
247
248 root = XML(xml)
249 self.etree.strip_elements(root, 'a')
250 self.assertEquals(_bytes('<test><x></x></test>'),
251 self._writeElement(root))
252
253 root = XML(xml)
254 self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z')
255 self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'),
256 self._writeElement(root))
257
258 root = XML(xml)
259 self.etree.strip_elements(root, 'c')
260 self.assertEquals(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'),
261 self._writeElement(root))
262
264 XML = self.etree.XML
265 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>')
266
267 root = XML(xml)
268 self.etree.strip_elements(root, 'a')
269 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>'),
270 self._writeElement(root))
271
272 root = XML(xml)
273 self.etree.strip_elements(root, '{urn:a}b', 'c')
274 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>'),
275 self._writeElement(root))
276
277 root = XML(xml)
278 self.etree.strip_elements(root, '{urn:a}*', 'c')
279 self.assertEquals(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
280 self._writeElement(root))
281
282 root = XML(xml)
283 self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False)
284 self.assertEquals(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
285 self._writeElement(root))
286
305
324
326 # lxml.etree separates target and text
327 Element = self.etree.Element
328 SubElement = self.etree.SubElement
329 ProcessingInstruction = self.etree.ProcessingInstruction
330
331 a = Element('a')
332 a.append(ProcessingInstruction('foo', 'some more text'))
333 self.assertEquals(a[0].target, 'foo')
334 self.assertEquals(a[0].text, 'some more text')
335
337 XML = self.etree.XML
338 root = XML(_bytes("<test><?mypi my test ?></test>"))
339 self.assertEquals(root[0].target, "mypi")
340 self.assertEquals(root[0].text, "my test ")
341
343 # previously caused a crash
344 ProcessingInstruction = self.etree.ProcessingInstruction
345
346 a = ProcessingInstruction("PI", "ONE")
347 b = copy.deepcopy(a)
348 b.text = "ANOTHER"
349
350 self.assertEquals('ONE', a.text)
351 self.assertEquals('ANOTHER', b.text)
352
354 XML = self.etree.XML
355 tostring = self.etree.tostring
356 root = XML(_bytes("<?mypi my test ?><test/><!--comment -->"))
357 tree1 = self.etree.ElementTree(root)
358 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
359 tostring(tree1))
360
361 tree2 = copy.deepcopy(tree1)
362 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
363 tostring(tree2))
364
365 root2 = copy.deepcopy(tree1.getroot())
366 self.assertEquals(_bytes("<test/>"),
367 tostring(root2))
368
370 XML = self.etree.XML
371 tostring = self.etree.tostring
372 xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>')
373 root = XML(xml)
374 tree1 = self.etree.ElementTree(root)
375 self.assertEquals(xml, tostring(tree1))
376
377 tree2 = copy.deepcopy(tree1)
378 self.assertEquals(xml, tostring(tree2))
379
380 root2 = copy.deepcopy(tree1.getroot())
381 self.assertEquals(_bytes("<test/>"),
382 tostring(root2))
383
385 # ElementTree accepts arbitrary attribute values
386 # lxml.etree allows only strings
387 Element = self.etree.Element
388
389 root = Element("root")
390 root.set("attr", "TEST")
391 self.assertEquals("TEST", root.get("attr"))
392 self.assertRaises(TypeError, root.set, "newattr", 5)
393
395 fromstring = self.etree.fromstring
396 tostring = self.etree.tostring
397 XMLParser = self.etree.XMLParser
398
399 xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
400 parser = XMLParser(remove_comments=True)
401 root = fromstring(xml, parser)
402 self.assertEquals(
403 _bytes('<a><b><c/></b></a>'),
404 tostring(root))
405
407 parse = self.etree.parse
408 tostring = self.etree.tostring
409 XMLParser = self.etree.XMLParser
410
411 xml = _bytes('<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>')
412
413 f = BytesIO(xml)
414 tree = parse(f)
415 self.assertEquals(
416 xml,
417 tostring(tree))
418
419 parser = XMLParser(remove_pis=True)
420 tree = parse(f, parser)
421 self.assertEquals(
422 _bytes('<a><b><c/></b></a>'),
423 tostring(tree))
424
426 # ET raises IOError only
427 parse = self.etree.parse
428 self.assertRaises(TypeError, parse, 'notthere.xml', object())
429
431 parse = self.etree.parse
432 f = BytesIO('<a><b></c></b></a>')
433 self.etree.clear_error_log()
434 try:
435 parse(f)
436 logs = None
437 except SyntaxError:
438 e = sys.exc_info()[1]
439 logs = e.error_log
440 f.close()
441 self.assert_([ log for log in logs
442 if 'mismatch' in log.message ])
443 self.assert_([ log for log in logs
444 if 'PARSER' in log.domain_name])
445 self.assert_([ log for log in logs
446 if 'TAG_NAME_MISMATCH' in log.type_name ])
447 self.assert_([ log for log in logs
448 if 1 == log.line ])
449 self.assert_([ log for log in logs
450 if 15 == log.column ])
451
453 # ET removes comments
454 iterparse = self.etree.iterparse
455 tostring = self.etree.tostring
456
457 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
458 events = list(iterparse(f))
459 root = events[-1][1]
460 self.assertEquals(3, len(events))
461 self.assertEquals(
462 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
463 tostring(root))
464
466 # ET removes comments
467 iterparse = self.etree.iterparse
468 tostring = self.etree.tostring
469
470 def name(event, el):
471 if event == 'comment':
472 return el.text
473 else:
474 return el.tag
475
476 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
477 events = list(iterparse(f, events=('end', 'comment')))
478 root = events[-1][1]
479 self.assertEquals(6, len(events))
480 self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'],
481 [ name(*item) for item in events ])
482 self.assertEquals(
483 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
484 tostring(root))
485
487 # ET removes pis
488 iterparse = self.etree.iterparse
489 tostring = self.etree.tostring
490 ElementTree = self.etree.ElementTree
491
492 def name(event, el):
493 if event == 'pi':
494 return (el.target, el.text)
495 else:
496 return el.tag
497
498 f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>')
499 events = list(iterparse(f, events=('end', 'pi')))
500 root = events[-2][1]
501 self.assertEquals(8, len(events))
502 self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b',
503 ('pid','d'), 'a', ('pie','e')],
504 [ name(*item) for item in events ])
505 self.assertEquals(
506 _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'),
507 tostring(ElementTree(root)))
508
510 iterparse = self.etree.iterparse
511 tostring = self.etree.tostring
512
513 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
514 events = list(iterparse(f, remove_comments=True,
515 events=('end', 'comment')))
516 root = events[-1][1]
517 self.assertEquals(3, len(events))
518 self.assertEquals(['c', 'b', 'a'],
519 [ el.tag for (event, el) in events ])
520 self.assertEquals(
521 _bytes('<a><b><c/></b></a>'),
522 tostring(root))
523
525 iterparse = self.etree.iterparse
526 f = BytesIO('<a><b><c/></a>')
527 # ET raises ExpatError, lxml raises XMLSyntaxError
528 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))
529
531 iterparse = self.etree.iterparse
532 f = BytesIO("""
533 <a> \n \n <b> b test </b> \n
534
535 \n\t <c> \n </c> </a> \n """)
536 iterator = iterparse(f, remove_blank_text=True)
537 text = [ (element.text, element.tail)
538 for event, element in iterator ]
539 self.assertEquals(
540 [(" b test ", None), (" \n ", None), (None, None)],
541 text)
542
544 iterparse = self.etree.iterparse
545 f = BytesIO('<a><b><d/></b><c/></a>')
546
547 iterator = iterparse(f, tag="b", events=('start', 'end'))
548 events = list(iterator)
549 root = iterator.root
550 self.assertEquals(
551 [('start', root[0]), ('end', root[0])],
552 events)
553
555 iterparse = self.etree.iterparse
556 f = BytesIO('<a><b><d/></b><c/></a>')
557
558 iterator = iterparse(f, tag="*", events=('start', 'end'))
559 events = list(iterator)
560 self.assertEquals(
561 8,
562 len(events))
563
565 text = _str('Søk på nettet')
566 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
567 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
568 ).encode('iso-8859-1')
569
570 self.assertRaises(self.etree.ParseError,
571 list, self.etree.iterparse(BytesIO(xml_latin1)))
572
574 text = _str('Søk på nettet', encoding="UTF-8")
575 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
576 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
577 ).encode('iso-8859-1')
578
579 iterator = self.etree.iterparse(BytesIO(xml_latin1),
580 encoding="iso-8859-1")
581 self.assertEquals(1, len(list(iterator)))
582
583 a = iterator.root
584 self.assertEquals(a.text, text)
585
587 tostring = self.etree.tostring
588 f = BytesIO('<root><![CDATA[test]]></root>')
589 context = self.etree.iterparse(f, strip_cdata=False)
590 content = [ el.text for event,el in context ]
591
592 self.assertEquals(['test'], content)
593 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
594 tostring(context.root))
595
599
601 self.etree.XMLParser(encoding="ascii")
602 self.etree.XMLParser(encoding="utf-8")
603 self.etree.XMLParser(encoding="iso-8859-1")
604
606 assertEquals = self.assertEquals
607 assertFalse = self.assertFalse
608
609 events = []
610 class Target(object):
611 def start(self, tag, attrib):
612 events.append("start")
613 assertFalse(attrib)
614 assertEquals("TAG", tag)
615 def end(self, tag):
616 events.append("end")
617 assertEquals("TAG", tag)
618 def close(self):
619 return "DONE" # no Element!
620
621 parser = self.etree.XMLParser(target=Target())
622 tree = self.etree.ElementTree()
623
624 self.assertRaises(TypeError,
625 tree.parse, BytesIO("<TAG/>"), parser=parser)
626 self.assertEquals(["start", "end"], events)
627
629 events = []
630 class Target(object):
631 def start(self, tag, attrib):
632 events.append("start-" + tag)
633 def end(self, tag):
634 events.append("end-" + tag)
635 def data(self, data):
636 events.append("data-" + data)
637 def comment(self, text):
638 events.append("comment-" + text)
639 def close(self):
640 return "DONE"
641
642 parser = self.etree.XMLParser(target=Target())
643
644 parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->'))
645 done = parser.close()
646
647 self.assertEquals("DONE", done)
648 self.assertEquals(["comment-a", "start-root", "data-A", "comment-b",
649 "start-sub", "end-sub", "comment-c", "data-B",
650 "end-root", "comment-d"],
651 events)
652
654 events = []
655 class Target(object):
656 def start(self, tag, attrib):
657 events.append("start-" + tag)
658 def end(self, tag):
659 events.append("end-" + tag)
660 def data(self, data):
661 events.append("data-" + data)
662 def pi(self, target, data):
663 events.append("pi-" + target + "-" + data)
664 def close(self):
665 return "DONE"
666
667 parser = self.etree.XMLParser(target=Target())
668
669 parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>'))
670 done = parser.close()
671
672 self.assertEquals("DONE", done)
673 self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b",
674 "data-B", "end-root", "pi-test-c"],
675 events)
676
678 events = []
679 class Target(object):
680 def start(self, tag, attrib):
681 events.append("start-" + tag)
682 def end(self, tag):
683 events.append("end-" + tag)
684 def data(self, data):
685 events.append("data-" + data)
686 def close(self):
687 return "DONE"
688
689 parser = self.etree.XMLParser(target=Target(),
690 strip_cdata=False)
691
692 parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>'))
693 done = parser.close()
694
695 self.assertEquals("DONE", done)
696 self.assertEquals(["start-root", "data-A", "start-a",
697 "data-ca", "end-a", "data-B", "end-root"],
698 events)
699
701 events = []
702 class Target(object):
703 def start(self, tag, attrib):
704 events.append("start-" + tag)
705 def end(self, tag):
706 events.append("end-" + tag)
707 def data(self, data):
708 events.append("data-" + data)
709 def close(self):
710 events.append("close")
711 return "DONE"
712
713 parser = self.etree.XMLParser(target=Target(),
714 recover=True)
715
716 parser.feed(_bytes('<root>A<a>ca</a>B</not-root>'))
717 done = parser.close()
718
719 self.assertEquals("DONE", done)
720 self.assertEquals(["start-root", "data-A", "start-a",
721 "data-ca", "end-a", "data-B",
722 "end-root", "close"],
723 events)
724
726 iterwalk = self.etree.iterwalk
727 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
728
729 iterator = iterwalk(root, tag="b", events=('start', 'end'))
730 events = list(iterator)
731 self.assertEquals(
732 [('start', root[0]), ('end', root[0])],
733 events)
734
736 iterwalk = self.etree.iterwalk
737 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
738
739 iterator = iterwalk(root, tag="*", events=('start', 'end'))
740 events = list(iterator)
741 self.assertEquals(
742 8,
743 len(events))
744
746 iterwalk = self.etree.iterwalk
747 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
748
749 events = list(iterwalk(root))
750 self.assertEquals(
751 [('end', root[0]), ('end', root[1]), ('end', root)],
752 events)
753
755 iterwalk = self.etree.iterwalk
756 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
757
758 iterator = iterwalk(root, events=('start',))
759 events = list(iterator)
760 self.assertEquals(
761 [('start', root), ('start', root[0]), ('start', root[1])],
762 events)
763
765 iterwalk = self.etree.iterwalk
766 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
767
768 iterator = iterwalk(root, events=('start','end'))
769 events = list(iterator)
770 self.assertEquals(
771 [('start', root), ('start', root[0]), ('end', root[0]),
772 ('start', root[1]), ('end', root[1]), ('end', root)],
773 events)
774
776 iterwalk = self.etree.iterwalk
777 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
778
779 iterator = iterwalk(root)
780 for event, elem in iterator:
781 elem.clear()
782
783 self.assertEquals(0,
784 len(root))
785
787 iterwalk = self.etree.iterwalk
788 root = self.etree.XML(_bytes('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>'))
789
790 attr_name = '{testns}bla'
791 events = []
792 iterator = iterwalk(root, events=('start','end','start-ns','end-ns'))
793 for event, elem in iterator:
794 events.append(event)
795 if event == 'start':
796 if elem.tag != '{ns1}a':
797 elem.set(attr_name, 'value')
798
799 self.assertEquals(
800 ['start-ns', 'start', 'start', 'start-ns', 'start',
801 'end', 'end-ns', 'end', 'end', 'end-ns'],
802 events)
803
804 self.assertEquals(
805 None,
806 root.get(attr_name))
807 self.assertEquals(
808 'value',
809 root[0].get(attr_name))
810
812 iterwalk = self.etree.iterwalk
813 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
814
815 counts = []
816 for event, elem in iterwalk(root):
817 counts.append(len(list(elem.getiterator())))
818 self.assertEquals(
819 [1,2,1,4],
820 counts)
821
823 parse = self.etree.parse
824 parser = self.etree.XMLParser(dtd_validation=True)
825 assertEqual = self.assertEqual
826 test_url = _str("__nosuch.dtd")
827
828 class MyResolver(self.etree.Resolver):
829 def resolve(self, url, id, context):
830 assertEqual(url, test_url)
831 return self.resolve_string(
832 _str('''<!ENTITY myentity "%s">
833 <!ELEMENT doc ANY>''') % url, context)
834
835 parser.resolvers.add(MyResolver())
836
837 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
838 tree = parse(StringIO(xml), parser)
839 root = tree.getroot()
840 self.assertEquals(root.text, test_url)
841
843 parse = self.etree.parse
844 parser = self.etree.XMLParser(dtd_validation=True)
845 assertEqual = self.assertEqual
846 test_url = _str("__nosuch.dtd")
847
848 class MyResolver(self.etree.Resolver):
849 def resolve(self, url, id, context):
850 assertEqual(url, test_url)
851 return self.resolve_string(
852 (_str('''<!ENTITY myentity "%s">
853 <!ELEMENT doc ANY>''') % url).encode('utf-8'),
854 context)
855
856 parser.resolvers.add(MyResolver())
857
858 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
859 tree = parse(StringIO(xml), parser)
860 root = tree.getroot()
861 self.assertEquals(root.text, test_url)
862
864 parse = self.etree.parse
865 parser = self.etree.XMLParser(dtd_validation=True)
866 assertEqual = self.assertEqual
867 test_url = _str("__nosuch.dtd")
868
869 class MyResolver(self.etree.Resolver):
870 def resolve(self, url, id, context):
871 assertEqual(url, test_url)
872 return self.resolve_file(
873 SillyFileLike(
874 _str('''<!ENTITY myentity "%s">
875 <!ELEMENT doc ANY>''') % url), context)
876
877 parser.resolvers.add(MyResolver())
878
879 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
880 tree = parse(StringIO(xml), parser)
881 root = tree.getroot()
882 self.assertEquals(root.text, test_url)
883
885 parse = self.etree.parse
886 parser = self.etree.XMLParser(attribute_defaults=True)
887 assertEqual = self.assertEqual
888 test_url = _str("__nosuch.dtd")
889
890 class MyResolver(self.etree.Resolver):
891 def resolve(self, url, id, context):
892 assertEqual(url, test_url)
893 return self.resolve_filename(
894 fileInTestDir('test.dtd'), context)
895
896 parser.resolvers.add(MyResolver())
897
898 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
899 tree = parse(StringIO(xml), parser)
900 root = tree.getroot()
901 self.assertEquals(
902 root.attrib, {'default': 'valueA'})
903 self.assertEquals(
904 root[0].attrib, {'default': 'valueB'})
905
907 parse = self.etree.parse
908 parser = self.etree.XMLParser(attribute_defaults=True)
909 assertEqual = self.assertEqual
910 test_url = _str("__nosuch.dtd")
911
912 class MyResolver(self.etree.Resolver):
913 def resolve(self, url, id, context):
914 assertEqual(url, fileInTestDir(test_url))
915 return self.resolve_filename(
916 fileInTestDir('test.dtd'), context)
917
918 parser.resolvers.add(MyResolver())
919
920 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
921 tree = parse(StringIO(xml), parser,
922 base_url=fileInTestDir('__test.xml'))
923 root = tree.getroot()
924 self.assertEquals(
925 root.attrib, {'default': 'valueA'})
926 self.assertEquals(
927 root[0].attrib, {'default': 'valueB'})
928
930 parse = self.etree.parse
931 parser = self.etree.XMLParser(attribute_defaults=True)
932 assertEqual = self.assertEqual
933 test_url = _str("__nosuch.dtd")
934
935 class MyResolver(self.etree.Resolver):
936 def resolve(self, url, id, context):
937 assertEqual(url, test_url)
938 return self.resolve_file(
939 open(fileInTestDir('test.dtd'), 'rb'), context)
940
941 parser.resolvers.add(MyResolver())
942
943 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
944 tree = parse(StringIO(xml), parser)
945 root = tree.getroot()
946 self.assertEquals(
947 root.attrib, {'default': 'valueA'})
948 self.assertEquals(
949 root[0].attrib, {'default': 'valueB'})
950
952 parse = self.etree.parse
953 parser = self.etree.XMLParser(load_dtd=True)
954 assertEqual = self.assertEqual
955 test_url = _str("__nosuch.dtd")
956
957 class check(object):
958 resolved = False
959
960 class MyResolver(self.etree.Resolver):
961 def resolve(self, url, id, context):
962 assertEqual(url, test_url)
963 check.resolved = True
964 return self.resolve_empty(context)
965
966 parser.resolvers.add(MyResolver())
967
968 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
969 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser)
970 self.assert_(check.resolved)
971
973 parse = self.etree.parse
974 parser = self.etree.XMLParser(dtd_validation=True)
975
976 class _LocalException(Exception):
977 pass
978
979 class MyResolver(self.etree.Resolver):
980 def resolve(self, url, id, context):
981 raise _LocalException
982
983 parser.resolvers.add(MyResolver())
984
985 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
986 self.assertRaises(_LocalException, parse, BytesIO(xml), parser)
987
988 if etree.LIBXML_VERSION > (2,6,20):
990 parse = self.etree.parse
991 tostring = self.etree.tostring
992 parser = self.etree.XMLParser(resolve_entities=False)
993 Entity = self.etree.Entity
994
995 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
996 tree = parse(BytesIO(xml), parser)
997 root = tree.getroot()
998 self.assertEquals(root[0].tag, Entity)
999 self.assertEquals(root[0].text, "&myentity;")
1000 self.assertEquals(root[0].tail, None)
1001 self.assertEquals(root[0].name, "myentity")
1002
1003 self.assertEquals(_bytes('<doc>&myentity;</doc>'),
1004 tostring(root))
1005
1007 Entity = self.etree.Entity
1008 Element = self.etree.Element
1009 tostring = self.etree.tostring
1010
1011 root = Element("root")
1012 root.append( Entity("test") )
1013
1014 self.assertEquals(root[0].tag, Entity)
1015 self.assertEquals(root[0].text, "&test;")
1016 self.assertEquals(root[0].tail, None)
1017 self.assertEquals(root[0].name, "test")
1018
1019 self.assertEquals(_bytes('<root>&test;</root>'),
1020 tostring(root))
1021
1023 Entity = self.etree.Entity
1024 self.assertEquals(Entity("test").text, '&test;')
1025 self.assertEquals(Entity("#17683").text, '䔓')
1026 self.assertEquals(Entity("#x1768").text, 'ᝨ')
1027 self.assertEquals(Entity("#x98AF").text, '颯')
1028
1030 Entity = self.etree.Entity
1031 self.assertRaises(ValueError, Entity, 'a b c')
1032 self.assertRaises(ValueError, Entity, 'a,b')
1033 self.assertRaises(ValueError, Entity, 'a\0b')
1034 self.assertRaises(ValueError, Entity, '#abc')
1035 self.assertRaises(ValueError, Entity, '#xxyz')
1036
1038 CDATA = self.etree.CDATA
1039 Element = self.etree.Element
1040 tostring = self.etree.tostring
1041
1042 root = Element("root")
1043 root.text = CDATA('test')
1044
1045 self.assertEquals('test',
1046 root.text)
1047 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
1048 tostring(root))
1049
1051 CDATA = self.etree.CDATA
1052 Element = self.etree.Element
1053 root = Element("root")
1054
1055 root.text = CDATA("test")
1056 self.assertEquals('test', root.text)
1057
1058 root.text = CDATA(_str("test"))
1059 self.assertEquals('test', root.text)
1060
1061 self.assertRaises(TypeError, CDATA, 1)
1062
1064 CDATA = self.etree.CDATA
1065 Element = self.etree.Element
1066
1067 root = Element("root")
1068 cdata = CDATA('test')
1069
1070 self.assertRaises(TypeError,
1071 setattr, root, 'tail', cdata)
1072 self.assertRaises(TypeError,
1073 root.set, 'attr', cdata)
1074 self.assertRaises(TypeError,
1075 operator.setitem, root.attrib, 'attr', cdata)
1076
1078 tostring = self.etree.tostring
1079 parser = self.etree.XMLParser(strip_cdata=False)
1080 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
1081
1082 self.assertEquals('test', root.text)
1083 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
1084 tostring(root))
1085
1086 # TypeError in etree, AssertionError in ElementTree;
1088 Element = self.etree.Element
1089 SubElement = self.etree.SubElement
1090
1091 a = Element('a')
1092 b = SubElement(a, 'b')
1093
1094 self.assertRaises(TypeError,
1095 a.__setitem__, 0, 'foo')
1096
1098 # raises AssertionError in ElementTree
1099 Element = self.etree.Element
1100 self.assertRaises(TypeError, Element('a').append, None)
1101
1103 Element = self.etree.Element
1104 SubElement = self.etree.SubElement
1105 root = Element('root')
1106 SubElement(root, 'a')
1107 SubElement(root, 'b')
1108
1109 self.assertEquals(['a', 'b'],
1110 [c.tag for c in root])
1111 root[1].addnext(root[0])
1112 self.assertEquals(['b', 'a'],
1113 [c.tag for c in root])
1114
1116 Element = self.etree.Element
1117 SubElement = self.etree.SubElement
1118 root = Element('root')
1119 SubElement(root, 'a')
1120 SubElement(root, 'b')
1121
1122 self.assertEquals(['a', 'b'],
1123 [c.tag for c in root])
1124 root[0].addprevious(root[1])
1125 self.assertEquals(['b', 'a'],
1126 [c.tag for c in root])
1127
1129 Element = self.etree.Element
1130 a = Element('a')
1131 b = Element('b')
1132 self.assertRaises(TypeError, a.addnext, b)
1133
1135 Element = self.etree.Element
1136 a = Element('a')
1137 b = Element('b')
1138 self.assertRaises(TypeError, a.addnext, b)
1139
1141 Element = self.etree.Element
1142 SubElement = self.etree.SubElement
1143 PI = self.etree.PI
1144 root = Element('root')
1145 SubElement(root, 'a')
1146 pi = PI('TARGET', 'TEXT')
1147 pi.tail = "TAIL"
1148
1149 self.assertEquals(_bytes('<root><a></a></root>'),
1150 self._writeElement(root))
1151 root[0].addprevious(pi)
1152 self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'),
1153 self._writeElement(root))
1154
1156 Element = self.etree.Element
1157 PI = self.etree.PI
1158 root = Element('root')
1159 pi = PI('TARGET', 'TEXT')
1160 pi.tail = "TAIL"
1161
1162 self.assertEquals(_bytes('<root></root>'),
1163 self._writeElement(root))
1164 root.addprevious(pi)
1165 self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'),
1166 self._writeElement(root))
1167
1169 Element = self.etree.Element
1170 SubElement = self.etree.SubElement
1171 PI = self.etree.PI
1172 root = Element('root')
1173 SubElement(root, 'a')
1174 pi = PI('TARGET', 'TEXT')
1175 pi.tail = "TAIL"
1176
1177 self.assertEquals(_bytes('<root><a></a></root>'),
1178 self._writeElement(root))
1179 root[0].addnext(pi)
1180 self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'),
1181 self._writeElement(root))
1182
1184 Element = self.etree.Element
1185 PI = self.etree.PI
1186 root = Element('root')
1187 pi = PI('TARGET', 'TEXT')
1188 pi.tail = "TAIL"
1189
1190 self.assertEquals(_bytes('<root></root>'),
1191 self._writeElement(root))
1192 root.addnext(pi)
1193 self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'),
1194 self._writeElement(root))
1195
1197 Element = self.etree.Element
1198 SubElement = self.etree.SubElement
1199 Comment = self.etree.Comment
1200 root = Element('root')
1201 SubElement(root, 'a')
1202 comment = Comment('TEXT ')
1203 comment.tail = "TAIL"
1204
1205 self.assertEquals(_bytes('<root><a></a></root>'),
1206 self._writeElement(root))
1207 root[0].addnext(comment)
1208 self.assertEquals(_bytes('<root><a></a><!--TEXT -->TAIL</root>'),
1209 self._writeElement(root))
1210
1212 Element = self.etree.Element
1213 Comment = self.etree.Comment
1214 root = Element('root')
1215 comment = Comment('TEXT ')
1216 comment.tail = "TAIL"
1217
1218 self.assertEquals(_bytes('<root></root>'),
1219 self._writeElement(root))
1220 root.addnext(comment)
1221 self.assertEquals(_bytes('<root></root>\n<!--TEXT -->'),
1222 self._writeElement(root))
1223
1225 Element = self.etree.Element
1226 SubElement = self.etree.SubElement
1227 Comment = self.etree.Comment
1228 root = Element('root')
1229 SubElement(root, 'a')
1230 comment = Comment('TEXT ')
1231 comment.tail = "TAIL"
1232
1233 self.assertEquals(_bytes('<root><a></a></root>'),
1234 self._writeElement(root))
1235 root[0].addprevious(comment)
1236 self.assertEquals(_bytes('<root><!--TEXT -->TAIL<a></a></root>'),
1237 self._writeElement(root))
1238
1240 Element = self.etree.Element
1241 Comment = self.etree.Comment
1242 root = Element('root')
1243 comment = Comment('TEXT ')
1244 comment.tail = "TAIL"
1245
1246 self.assertEquals(_bytes('<root></root>'),
1247 self._writeElement(root))
1248 root.addprevious(comment)
1249 self.assertEquals(_bytes('<!--TEXT -->\n<root></root>'),
1250 self._writeElement(root))
1251
1252 # ET's Elements have items() and key(), but not values()
1254 XML = self.etree.XML
1255
1256 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
1257 values = root.values()
1258 values.sort()
1259 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
1260
1261 # gives error in ElementTree
1263 Element = self.etree.Element
1264 Comment = self.etree.Comment
1265
1266 a = Element('a')
1267 a.append(Comment())
1268 self.assertEquals(
1269 _bytes('<a><!----></a>'),
1270 self._writeElement(a))
1271
1272 # ElementTree ignores comments
1274 ElementTree = self.etree.ElementTree
1275 tostring = self.etree.tostring
1276
1277 xml = _bytes('<a><b/><!----><c/></a>')
1278 f = BytesIO(xml)
1279 doc = ElementTree(file=f)
1280 a = doc.getroot()
1281 self.assertEquals(
1282 '',
1283 a[1].text)
1284 self.assertEquals(
1285 xml,
1286 tostring(a))
1287
1288 # ElementTree ignores comments
1290 ElementTree = self.etree.ElementTree
1291
1292 f = BytesIO('<a><b></b><!-- hoi --><c></c></a>')
1293 doc = ElementTree(file=f)
1294 a = doc.getroot()
1295 self.assertEquals(
1296 ' hoi ',
1297 a[1].text)
1298
1299 # does not raise an exception in ElementTree
1301 Element = self.etree.Element
1302 Comment = self.etree.Comment
1303
1304 c = Comment()
1305 el = Element('myel')
1306
1307 self.assertRaises(TypeError, c.append, el)
1308 self.assertRaises(TypeError, c.insert, 0, el)
1309 self.assertRaises(TypeError, c.set, "myattr", "test")
1310
1311 # test passing 'None' to dump
1314
1316 ElementTree = self.etree.ElementTree
1317
1318 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>')
1319 doc = ElementTree(file=f)
1320 a = doc.getroot()
1321 self.assertEquals(
1322 None,
1323 a.prefix)
1324 self.assertEquals(
1325 'foo',
1326 a[0].prefix)
1327
1329 ElementTree = self.etree.ElementTree
1330
1331 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>')
1332 doc = ElementTree(file=f)
1333 a = doc.getroot()
1334 self.assertEquals(
1335 None,
1336 a.prefix)
1337 self.assertEquals(
1338 None,
1339 a[0].prefix)
1340
1342 Element = self.etree.Element
1343 SubElement = self.etree.SubElement
1344
1345 a = Element('a')
1346 b = SubElement(a, 'b')
1347 c = SubElement(a, 'c')
1348 d = SubElement(b, 'd')
1349 self.assertEquals(
1350 None,
1351 a.getparent())
1352 self.assertEquals(
1353 a,
1354 b.getparent())
1355 self.assertEquals(
1356 b.getparent(),
1357 c.getparent())
1358 self.assertEquals(
1359 b,
1360 d.getparent())
1361
1363 XML = self.etree.XML
1364
1365 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1366 result = []
1367 for el in root.iterchildren():
1368 result.append(el.tag)
1369 self.assertEquals(['one', 'two', 'three'], result)
1370
1372 XML = self.etree.XML
1373
1374 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1375 result = []
1376 for el in root.iterchildren(reversed=True):
1377 result.append(el.tag)
1378 self.assertEquals(['three', 'two', 'one'], result)
1379
1381 XML = self.etree.XML
1382
1383 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1384 result = []
1385 for el in root.iterchildren(tag='two'):
1386 result.append(el.text)
1387 self.assertEquals(['Two', 'Bla'], result)
1388
1390 XML = self.etree.XML
1391
1392 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1393 result = []
1394 for el in root.iterchildren(reversed=True, tag='two'):
1395 result.append(el.text)
1396 self.assertEquals(['Bla', 'Two'], result)
1397
1399 Element = self.etree.Element
1400 SubElement = self.etree.SubElement
1401
1402 a = Element('a')
1403 b = SubElement(a, 'b')
1404 c = SubElement(a, 'c')
1405 d = SubElement(b, 'd')
1406 self.assertEquals(
1407 [],
1408 list(a.iterancestors()))
1409 self.assertEquals(
1410 [a],
1411 list(b.iterancestors()))
1412 self.assertEquals(
1413 [a],
1414 list(c.iterancestors()))
1415 self.assertEquals(
1416 [b, a],
1417 list(d.iterancestors()))
1418
1420 Element = self.etree.Element
1421 SubElement = self.etree.SubElement
1422
1423 a = Element('a')
1424 b = SubElement(a, 'b')
1425 c = SubElement(a, 'c')
1426 d = SubElement(b, 'd')
1427 self.assertEquals(
1428 [a],
1429 list(d.iterancestors(tag='a')))
1430
1432 Element = self.etree.Element
1433 SubElement = self.etree.SubElement
1434
1435 a = Element('a')
1436 b = SubElement(a, 'b')
1437 c = SubElement(a, 'c')
1438 d = SubElement(b, 'd')
1439 e = SubElement(c, 'e')
1440
1441 self.assertEquals(
1442 [b, d, c, e],
1443 list(a.iterdescendants()))
1444 self.assertEquals(
1445 [],
1446 list(d.iterdescendants()))
1447
1449 Element = self.etree.Element
1450 SubElement = self.etree.SubElement
1451
1452 a = Element('a')
1453 b = SubElement(a, 'b')
1454 c = SubElement(a, 'c')
1455 d = SubElement(b, 'd')
1456 e = SubElement(c, 'e')
1457
1458 self.assertEquals(
1459 [],
1460 list(a.iterdescendants('a')))
1461 a2 = SubElement(e, 'a')
1462 self.assertEquals(
1463 [a2],
1464 list(a.iterdescendants('a')))
1465 self.assertEquals(
1466 [a2],
1467 list(c.iterdescendants('a')))
1468
1470 Element = self.etree.Element
1471 SubElement = self.etree.SubElement
1472
1473 a = Element('a')
1474 b = SubElement(a, 'b')
1475 c = SubElement(a, 'c')
1476 d = SubElement(b, 'd')
1477 self.assertEquals(
1478 a,
1479 a.getroottree().getroot())
1480 self.assertEquals(
1481 a,
1482 b.getroottree().getroot())
1483 self.assertEquals(
1484 a,
1485 d.getroottree().getroot())
1486
1488 Element = self.etree.Element
1489 SubElement = self.etree.SubElement
1490
1491 a = Element('a')
1492 b = SubElement(a, 'b')
1493 c = SubElement(a, 'c')
1494 self.assertEquals(
1495 None,
1496 a.getnext())
1497 self.assertEquals(
1498 c,
1499 b.getnext())
1500 self.assertEquals(
1501 None,
1502 c.getnext())
1503
1505 Element = self.etree.Element
1506 SubElement = self.etree.SubElement
1507
1508 a = Element('a')
1509 b = SubElement(a, 'b')
1510 c = SubElement(a, 'c')
1511 d = SubElement(b, 'd')
1512 self.assertEquals(
1513 None,
1514 a.getprevious())
1515 self.assertEquals(
1516 b,
1517 c.getprevious())
1518 self.assertEquals(
1519 None,
1520 b.getprevious())
1521
1523 Element = self.etree.Element
1524 SubElement = self.etree.SubElement
1525
1526 a = Element('a')
1527 b = SubElement(a, 'b')
1528 c = SubElement(a, 'c')
1529 d = SubElement(b, 'd')
1530 self.assertEquals(
1531 [],
1532 list(a.itersiblings()))
1533 self.assertEquals(
1534 [c],
1535 list(b.itersiblings()))
1536 self.assertEquals(
1537 [],
1538 list(c.itersiblings()))
1539 self.assertEquals(
1540 [b],
1541 list(c.itersiblings(preceding=True)))
1542 self.assertEquals(
1543 [],
1544 list(b.itersiblings(preceding=True)))
1545
1547 Element = self.etree.Element
1548 SubElement = self.etree.SubElement
1549
1550 a = Element('a')
1551 b = SubElement(a, 'b')
1552 c = SubElement(a, 'c')
1553 d = SubElement(b, 'd')
1554 self.assertEquals(
1555 [],
1556 list(a.itersiblings(tag='XXX')))
1557 self.assertEquals(
1558 [c],
1559 list(b.itersiblings(tag='c')))
1560 self.assertEquals(
1561 [b],
1562 list(c.itersiblings(preceding=True, tag='b')))
1563 self.assertEquals(
1564 [],
1565 list(c.itersiblings(preceding=True, tag='c')))
1566
1568 parseid = self.etree.parseid
1569 XML = self.etree.XML
1570 xml_text = _bytes('''
1571 <!DOCTYPE document [
1572 <!ELEMENT document (h1,p)*>
1573 <!ELEMENT h1 (#PCDATA)>
1574 <!ATTLIST h1 myid ID #REQUIRED>
1575 <!ELEMENT p (#PCDATA)>
1576 <!ATTLIST p someid ID #REQUIRED>
1577 ]>
1578 <document>
1579 <h1 myid="chapter1">...</h1>
1580 <p id="note1" class="note">...</p>
1581 <p>Regular paragraph.</p>
1582 <p xml:id="xmlid">XML:ID paragraph.</p>
1583 <p someid="warn1" class="warning">...</p>
1584 </document>
1585 ''')
1586
1587 tree, dic = parseid(BytesIO(xml_text))
1588 root = tree.getroot()
1589 root2 = XML(xml_text)
1590 self.assertEquals(self._writeElement(root),
1591 self._writeElement(root2))
1592 expected = {
1593 "chapter1" : root[0],
1594 "xmlid" : root[3],
1595 "warn1" : root[4]
1596 }
1597 self.assert_("chapter1" in dic)
1598 self.assert_("warn1" in dic)
1599 self.assert_("xmlid" in dic)
1600 self._checkIDDict(dic, expected)
1601
1603 XMLDTDID = self.etree.XMLDTDID
1604 XML = self.etree.XML
1605 xml_text = _bytes('''
1606 <!DOCTYPE document [
1607 <!ELEMENT document (h1,p)*>
1608 <!ELEMENT h1 (#PCDATA)>
1609 <!ATTLIST h1 myid ID #REQUIRED>
1610 <!ELEMENT p (#PCDATA)>
1611 <!ATTLIST p someid ID #REQUIRED>
1612 ]>
1613 <document>
1614 <h1 myid="chapter1">...</h1>
1615 <p id="note1" class="note">...</p>
1616 <p>Regular paragraph.</p>
1617 <p xml:id="xmlid">XML:ID paragraph.</p>
1618 <p someid="warn1" class="warning">...</p>
1619 </document>
1620 ''')
1621
1622 root, dic = XMLDTDID(xml_text)
1623 root2 = XML(xml_text)
1624 self.assertEquals(self._writeElement(root),
1625 self._writeElement(root2))
1626 expected = {
1627 "chapter1" : root[0],
1628 "xmlid" : root[3],
1629 "warn1" : root[4]
1630 }
1631 self.assert_("chapter1" in dic)
1632 self.assert_("warn1" in dic)
1633 self.assert_("xmlid" in dic)
1634 self._checkIDDict(dic, expected)
1635
1637 XMLDTDID = self.etree.XMLDTDID
1638 XML = self.etree.XML
1639 xml_text = _bytes('''
1640 <document>
1641 <h1 myid="chapter1">...</h1>
1642 <p id="note1" class="note">...</p>
1643 <p>Regular paragraph.</p>
1644 <p someid="warn1" class="warning">...</p>
1645 </document>
1646 ''')
1647
1648 root, dic = XMLDTDID(xml_text)
1649 root2 = XML(xml_text)
1650 self.assertEquals(self._writeElement(root),
1651 self._writeElement(root2))
1652 expected = {}
1653 self._checkIDDict(dic, expected)
1654
1656 self.assertEquals(len(dic),
1657 len(expected))
1658 self.assertEquals(sorted(dic.items()),
1659 sorted(expected.items()))
1660 if sys.version_info < (3,):
1661 self.assertEquals(sorted(dic.iteritems()),
1662 sorted(expected.iteritems()))
1663 self.assertEquals(sorted(dic.keys()),
1664 sorted(expected.keys()))
1665 if sys.version_info < (3,):
1666 self.assertEquals(sorted(dic.iterkeys()),
1667 sorted(expected.iterkeys()))
1668 if sys.version_info < (3,):
1669 self.assertEquals(sorted(dic.values()),
1670 sorted(expected.values()))
1671 self.assertEquals(sorted(dic.itervalues()),
1672 sorted(expected.itervalues()))
1673
1675 etree = self.etree
1676
1677 r = {'foo': 'http://ns.infrae.com/foo'}
1678 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1679 self.assertEquals(
1680 'foo',
1681 e.prefix)
1682 self.assertEquals(
1683 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'),
1684 self._writeElement(e))
1685
1687 etree = self.etree
1688
1689 r = {None: 'http://ns.infrae.com/foo'}
1690 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1691 self.assertEquals(
1692 None,
1693 e.prefix)
1694 self.assertEquals(
1695 '{http://ns.infrae.com/foo}bar',
1696 e.tag)
1697 self.assertEquals(
1698 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'),
1699 self._writeElement(e))
1700
1702 etree = self.etree
1703
1704 r = {None: 'http://ns.infrae.com/foo',
1705 'hoi': 'http://ns.infrae.com/hoi'}
1706 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1707 e.set('{http://ns.infrae.com/hoi}test', 'value')
1708 self.assertEquals(
1709 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'),
1710 self._writeElement(e))
1711
1713 etree = self.etree
1714 r = {None: 'http://ns.infrae.com/foo',
1715 'hoi': 'http://ns.infrae.com/hoi'}
1716 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r)
1717 tree = etree.ElementTree(element=e)
1718 etree.SubElement(e, '{http://ns.infrae.com/hoi}x')
1719 self.assertEquals(
1720 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'),
1721 self._writeElement(e))
1722
1724 etree = self.etree
1725
1726 r = {None: 'http://ns.infrae.com/foo'}
1727 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1728 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1729
1730 e1.append(e2)
1731
1732 self.assertEquals(
1733 None,
1734 e1.prefix)
1735 self.assertEquals(
1736 None,
1737 e1[0].prefix)
1738 self.assertEquals(
1739 '{http://ns.infrae.com/foo}bar',
1740 e1.tag)
1741 self.assertEquals(
1742 '{http://ns.infrae.com/foo}bar',
1743 e1[0].tag)
1744
1746 etree = self.etree
1747
1748 r = {None: 'http://ns.infrae.com/BAR'}
1749 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r)
1750 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1751
1752 e1.append(e2)
1753
1754 self.assertEquals(
1755 None,
1756 e1.prefix)
1757 self.assertNotEquals(
1758 None,
1759 e2.prefix)
1760 self.assertEquals(
1761 '{http://ns.infrae.com/BAR}bar',
1762 e1.tag)
1763 self.assertEquals(
1764 '{http://ns.infrae.com/foo}bar',
1765 e2.tag)
1766
1768 ns_href = "http://a.b.c"
1769 one = self.etree.fromstring(
1770 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
1771 baz = one[0][0]
1772
1773 two = self.etree.fromstring(
1774 _bytes('<root xmlns:ns="%s"/>' % ns_href))
1775 two.append(baz)
1776 del one # make sure the source document is deallocated
1777
1778 self.assertEquals('{%s}baz' % ns_href, baz.tag)
1779 self.assertEquals(
1780 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href),
1781 self.etree.tostring(two))
1782
1784 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>')
1785 root = self.etree.fromstring(xml)
1786 self.assertEquals(xml,
1787 self.etree.tostring(root))
1788 self.etree.cleanup_namespaces(root)
1789 self.assertEquals(
1790 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'),
1791 self.etree.tostring(root))
1792
1794 etree = self.etree
1795
1796 r = {None: 'http://ns.infrae.com/foo',
1797 'hoi': 'http://ns.infrae.com/hoi'}
1798 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1799 self.assertEquals(
1800 r,
1801 e.nsmap)
1802
1804 etree = self.etree
1805
1806 re = {None: 'http://ns.infrae.com/foo',
1807 'hoi': 'http://ns.infrae.com/hoi'}
1808 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re)
1809
1810 rs = {None: 'http://ns.infrae.com/honk',
1811 'top': 'http://ns.infrae.com/top'}
1812 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs)
1813
1814 r = re.copy()
1815 r.update(rs)
1816 self.assertEquals(
1817 re,
1818 e.nsmap)
1819 self.assertEquals(
1820 r,
1821 s.nsmap)
1822
1824 Element = self.etree.Element
1825 SubElement = self.etree.SubElement
1826
1827 a = Element('{a}a')
1828 b = SubElement(a, '{a}b')
1829 c = SubElement(a, '{a}c')
1830 d = SubElement(b, '{b}d')
1831 e = SubElement(c, '{a}e')
1832 f = SubElement(c, '{b}f')
1833
1834 self.assertEquals(
1835 [a],
1836 list(a.getiterator('{a}a')))
1837 self.assertEquals(
1838 [],
1839 list(a.getiterator('{b}a')))
1840 self.assertEquals(
1841 [],
1842 list(a.getiterator('a')))
1843 self.assertEquals(
1844 [f],
1845 list(c.getiterator('{b}*')))
1846 self.assertEquals(
1847 [d, f],
1848 list(a.getiterator('{b}*')))
1849
1851 Element = self.etree.Element
1852 Entity = self.etree.Entity
1853 SubElement = self.etree.SubElement
1854
1855 a = Element('a')
1856 b = SubElement(a, 'b')
1857 entity_b = Entity("TEST-b")
1858 b.append(entity_b)
1859
1860 self.assertEquals(
1861 [entity_b],
1862 list(a.getiterator(Entity)))
1863
1864 entity_a = Entity("TEST-a")
1865 a.append(entity_a)
1866
1867 self.assertEquals(
1868 [entity_b, entity_a],
1869 list(a.getiterator(Entity)))
1870
1871 self.assertEquals(
1872 [entity_b],
1873 list(b.getiterator(Entity)))
1874
1876 Element = self.etree.Element
1877 Comment = self.etree.Comment
1878 PI = self.etree.PI
1879 SubElement = self.etree.SubElement
1880
1881 a = Element('a')
1882 b = SubElement(a, 'b')
1883 a.append(Comment("test"))
1884 a.append(PI("pi", "content"))
1885 c = SubElement(a, 'c')
1886
1887 self.assertEquals(
1888 [a, b, c],
1889 list(a.getiterator(Element)))
1890
1892 # ElementTree iterates over everything here
1893 Element = self.etree.Element
1894 Comment = self.etree.Comment
1895 PI = self.etree.PI
1896 SubElement = self.etree.SubElement
1897
1898 a = Element('a')
1899 b = SubElement(a, 'b')
1900 a.append(Comment("test"))
1901 a.append(PI("pi", "content"))
1902 c = SubElement(a, 'c')
1903
1904 self.assertEquals(
1905 [a, b, c],
1906 list(a.getiterator('*')))
1907
1909 XML = self.etree.XML
1910 ElementTree = self.etree.ElementTree
1911 QName = self.etree.QName
1912 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
1913 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])
1914
1916 XML = self.etree.XML
1917 ElementTree = self.etree.ElementTree
1918 QName = self.etree.QName
1919 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
1920 self.assertEquals(len(list(tree.findall(QName("c")))), 1)
1921
1923 XML = self.etree.XML
1924 ElementTree = self.etree.ElementTree
1925 QName = self.etree.QName
1926 tree = ElementTree(XML(
1927 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')))
1928 self.assertEquals(len(list(tree.findall(QName("b")))), 2)
1929 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)
1930
1932 XML = self.etree.XML
1933 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
1934 self.assertEquals(len(root.findall(".//{X}b")), 2)
1935 self.assertEquals(len(root.findall(".//{X}*")), 2)
1936 self.assertEquals(len(root.findall(".//b")), 3)
1937
1939 etree = self.etree
1940 e = etree.Element('foo')
1941 for i in range(10):
1942 etree.SubElement(e, 'a%s' % i)
1943 for i in range(10):
1944 self.assertEquals(
1945 i,
1946 e.index(e[i]))
1947 self.assertEquals(
1948 3, e.index(e[3], 3))
1949 self.assertRaises(
1950 ValueError, e.index, e[3], 4)
1951 self.assertRaises(
1952 ValueError, e.index, e[3], 0, 2)
1953 self.assertRaises(
1954 ValueError, e.index, e[8], 0, -3)
1955 self.assertRaises(
1956 ValueError, e.index, e[8], -5, -3)
1957 self.assertEquals(
1958 8, e.index(e[8], 0, -1))
1959 self.assertEquals(
1960 8, e.index(e[8], -12, -1))
1961 self.assertEquals(
1962 0, e.index(e[0], -12, -1))
1963
1965 etree = self.etree
1966 e = etree.Element('foo')
1967 for i in range(10):
1968 el = etree.SubElement(e, 'a%s' % i)
1969 el.text = "text%d" % i
1970 el.tail = "tail%d" % i
1971
1972 child0 = e[0]
1973 child1 = e[1]
1974 child2 = e[2]
1975
1976 e.replace(e[0], e[1])
1977 self.assertEquals(
1978 9, len(e))
1979 self.assertEquals(
1980 child1, e[0])
1981 self.assertEquals(
1982 child1.text, "text1")
1983 self.assertEquals(
1984 child1.tail, "tail1")
1985 self.assertEquals(
1986 child0.tail, "tail0")
1987 self.assertEquals(
1988 child2, e[1])
1989
1990 e.replace(e[-1], e[0])
1991 self.assertEquals(
1992 child1, e[-1])
1993 self.assertEquals(
1994 child1.text, "text1")
1995 self.assertEquals(
1996 child1.tail, "tail1")
1997 self.assertEquals(
1998 child2, e[0])
1999
2001 etree = self.etree
2002 e = etree.Element('foo')
2003 for i in range(10):
2004 etree.SubElement(e, 'a%s' % i)
2005
2006 new_element = etree.Element("test")
2007 new_element.text = "TESTTEXT"
2008 new_element.tail = "TESTTAIL"
2009 child1 = e[1]
2010 e.replace(e[0], new_element)
2011 self.assertEquals(
2012 new_element, e[0])
2013 self.assertEquals(
2014 "TESTTEXT",
2015 e[0].text)
2016 self.assertEquals(
2017 "TESTTAIL",
2018 e[0].tail)
2019 self.assertEquals(
2020 child1, e[1])
2021
2023 Element = self.etree.Element
2024 SubElement = self.etree.SubElement
2025
2026 a = Element('a')
2027
2028 e = Element('e')
2029 f = Element('f')
2030 g = Element('g')
2031
2032 s = [e, f, g]
2033 a[::-1] = s
2034 self.assertEquals(
2035 [g, f, e],
2036 list(a))
2037
2039 Element = self.etree.Element
2040 SubElement = self.etree.SubElement
2041
2042 a = Element('a')
2043 b = SubElement(a, 'b')
2044 c = SubElement(a, 'c')
2045 d = SubElement(a, 'd')
2046 e = SubElement(a, 'e')
2047
2048 x = Element('x')
2049 y = Element('y')
2050
2051 a[1::2] = [x, y]
2052 self.assertEquals(
2053 [b, x, d, y],
2054 list(a))
2055
2057 Element = self.etree.Element
2058 SubElement = self.etree.SubElement
2059
2060 a = Element('a')
2061 b = SubElement(a, 'b')
2062 c = SubElement(a, 'c')
2063 d = SubElement(a, 'd')
2064 e = SubElement(a, 'e')
2065
2066 x = Element('x')
2067 y = Element('y')
2068
2069 a[1::-1] = [x, y]
2070 self.assertEquals(
2071 [y, x, d, e],
2072 list(a))
2073
2075 Element = self.etree.Element
2076 SubElement = self.etree.SubElement
2077
2078 a = Element('a')
2079 b = SubElement(a, 'b')
2080 c = SubElement(a, 'c')
2081 d = SubElement(a, 'd')
2082 e = SubElement(a, 'e')
2083
2084 x = Element('x')
2085 y = Element('y')
2086
2087 a[::-2] = [x, y]
2088 self.assertEquals(
2089 [b, y, d, x],
2090 list(a))
2091
2093 Element = self.etree.Element
2094 SubElement = self.etree.SubElement
2095 try:
2096 slice
2097 except NameError:
2098 print("slice() not found")
2099 return
2100
2101 a = Element('a')
2102 b = SubElement(a, 'b')
2103 c = SubElement(a, 'c')
2104 d = SubElement(a, 'd')
2105 e = SubElement(a, 'e')
2106
2107 x = Element('x')
2108 y = Element('y')
2109 z = Element('z')
2110
2111 self.assertRaises(
2112 ValueError,
2113 operator.setitem, a, slice(1,None,2), [x, y, z])
2114
2115 self.assertEquals(
2116 [b, c, d, e],
2117 list(a))
2118
2120 XML = self.etree.XML
2121 root = XML(_bytes('''<?xml version="1.0"?>
2122 <root><test>
2123
2124 <bla/></test>
2125 </root>
2126 '''))
2127
2128 self.assertEquals(
2129 [2, 2, 4],
2130 [ el.sourceline for el in root.getiterator() ])
2131
2133 parse = self.etree.parse
2134 tree = parse(fileInTestDir('include/test_xinclude.xml'))
2135
2136 self.assertEquals(
2137 [1, 2, 3],
2138 [ el.sourceline for el in tree.getiterator() ])
2139
2141 iterparse = self.etree.iterparse
2142 lines = [ el.sourceline for (event, el) in
2143 iterparse(fileInTestDir('include/test_xinclude.xml')) ]
2144
2145 self.assertEquals(
2146 [2, 3, 1],
2147 lines)
2148
2150 iterparse = self.etree.iterparse
2151 lines = [ el.sourceline for (event, el) in
2152 iterparse(fileInTestDir('include/test_xinclude.xml'),
2153 events=("start",)) ]
2154
2155 self.assertEquals(
2156 [1, 2, 3],
2157 lines)
2158
2160 Element = self.etree.Element
2161 SubElement = self.etree.SubElement
2162 el = Element("test")
2163 self.assertEquals(None, el.sourceline)
2164
2165 child = SubElement(el, "test")
2166 self.assertEquals(None, el.sourceline)
2167 self.assertEquals(None, child.sourceline)
2168
2170 etree = self.etree
2171 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2172 docinfo = root.getroottree().docinfo
2173 self.assertEquals(docinfo.URL, "http://no/such/url")
2174
2176 etree = self.etree
2177 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2178 docinfo = root.getroottree().docinfo
2179 self.assertEquals(docinfo.URL, "http://no/such/url")
2180 docinfo.URL = "https://secret/url"
2181 self.assertEquals(docinfo.URL, "https://secret/url")
2182
2184 etree = self.etree
2185 tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url")
2186 docinfo = tree.docinfo
2187 self.assertEquals(docinfo.URL, "http://no/such/url")
2188
2190 etree = self.etree
2191 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2192 base_url="http://no/such/url")
2193 docinfo = tree.docinfo
2194 self.assertEquals(docinfo.URL, "http://no/such/url")
2195
2197 etree = self.etree
2198 root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url")
2199 docinfo = root.getroottree().docinfo
2200 self.assertEquals(docinfo.URL, "http://no/such/url")
2201
2203 etree = self.etree
2204 xml_header = '<?xml version="1.0" encoding="ascii"?>'
2205 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN"
2206 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
2207 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)
2208
2209 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2210
2211 tree = etree.parse(BytesIO(xml))
2212 docinfo = tree.docinfo
2213 self.assertEquals(docinfo.encoding, "ascii")
2214 self.assertEquals(docinfo.xml_version, "1.0")
2215 self.assertEquals(docinfo.public_id, pub_id)
2216 self.assertEquals(docinfo.system_url, sys_id)
2217 self.assertEquals(docinfo.root_name, 'html')
2218 self.assertEquals(docinfo.doctype, doctype_string)
2219
2221 etree = self.etree
2222 xml_header = '<?xml version="1.0" encoding="UTF-8"?>'
2223 sys_id = "some.dtd"
2224 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id
2225 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2226
2227 tree = etree.parse(BytesIO(xml))
2228 docinfo = tree.docinfo
2229 self.assertEquals(docinfo.encoding, "UTF-8")
2230 self.assertEquals(docinfo.xml_version, "1.0")
2231 self.assertEquals(docinfo.public_id, None)
2232 self.assertEquals(docinfo.system_url, sys_id)
2233 self.assertEquals(docinfo.root_name, 'html')
2234 self.assertEquals(docinfo.doctype, doctype_string)
2235
2237 etree = self.etree
2238 xml = _bytes('<html><body></body></html>')
2239 tree = etree.parse(BytesIO(xml))
2240 docinfo = tree.docinfo
2241 self.assertEquals(docinfo.encoding, "UTF-8")
2242 self.assertEquals(docinfo.xml_version, "1.0")
2243 self.assertEquals(docinfo.public_id, None)
2244 self.assertEquals(docinfo.system_url, None)
2245 self.assertEquals(docinfo.root_name, 'html')
2246 self.assertEquals(docinfo.doctype, '')
2247
2249 etree = self.etree
2250 xml = _bytes('<!DOCTYPE root><root></root>')
2251 tree = etree.parse(BytesIO(xml))
2252 docinfo = tree.docinfo
2253 self.assertEquals(docinfo.encoding, "UTF-8")
2254 self.assertEquals(docinfo.xml_version, "1.0")
2255 self.assertEquals(docinfo.public_id, None)
2256 self.assertEquals(docinfo.system_url, None)
2257 self.assertEquals(docinfo.root_name, 'root')
2258 self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')
2259
2261 etree = self.etree
2262 xml = _bytes('<!DOCTYPE root>\n<root/>')
2263 tree = etree.parse(BytesIO(xml))
2264 self.assertEquals(xml, etree.tostring(tree))
2265
2267 etree = self.etree
2268 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2269 self.assertEquals(root.base, "http://no/such/url")
2270 self.assertEquals(
2271 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2272 root.base = "https://secret/url"
2273 self.assertEquals(root.base, "https://secret/url")
2274 self.assertEquals(
2275 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2276 "https://secret/url")
2277
2279 etree = self.etree
2280 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2281 self.assertEquals(root.base, "http://no/such/url")
2282 self.assertEquals(
2283 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2284 root.set('{http://www.w3.org/XML/1998/namespace}base',
2285 "https://secret/url")
2286 self.assertEquals(root.base, "https://secret/url")
2287 self.assertEquals(
2288 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2289 "https://secret/url")
2290
2292 etree = self.etree
2293 root = etree.HTML(_bytes("<html><body></body></html>"),
2294 base_url="http://no/such/url")
2295 self.assertEquals(root.base, "http://no/such/url")
2296
2298 etree = self.etree
2299 root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>'))
2300 self.assertEquals(root.base, "http://no/such/url")
2301
2303 # parse from a file object that returns unicode strings
2304 f = LargeFileLikeUnicode()
2305 tree = self.etree.parse(f)
2306 root = tree.getroot()
2307 self.assert_(root.tag.endswith('root'))
2308
2310 # check that DTDs that go in also go back out
2311 xml = _bytes('''\
2312 <!DOCTYPE test SYSTEM "test.dtd" [
2313 <!ENTITY entity "tasty">
2314 <!ELEMENT test (a)>
2315 <!ELEMENT a (#PCDATA)>
2316 ]>
2317 <test><a>test-test</a></test>\
2318 ''')
2319 tree = self.etree.parse(BytesIO(xml))
2320 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")),
2321 xml.replace(_bytes(" "), _bytes("")))
2322
2324 Element = self.etree.Element
2325
2326 a = Element('a')
2327 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho')
2328 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho')
2329
2330 self.assertRaises(ValueError, Element, 'ha\0ho')
2331
2333 Element = self.etree.Element
2334
2335 a = Element('a')
2336 self.assertRaises(ValueError, setattr, a, "text",
2337 _str('ha\0ho'))
2338 self.assertRaises(ValueError, setattr, a, "tail",
2339 _str('ha\0ho'))
2340
2341 self.assertRaises(ValueError, Element,
2342 _str('ha\0ho'))
2343
2345 Element = self.etree.Element
2346
2347 a = Element('a')
2348 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho')
2349 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho')
2350
2351 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho')
2352 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho')
2353
2354 self.assertRaises(ValueError, Element, 'ha\x07ho')
2355 self.assertRaises(ValueError, Element, 'ha\x02ho')
2356
2358 Element = self.etree.Element
2359
2360 a = Element('a')
2361 self.assertRaises(ValueError, setattr, a, "text",
2362 _str('ha\x07ho'))
2363 self.assertRaises(ValueError, setattr, a, "text",
2364 _str('ha\x02ho'))
2365
2366 self.assertRaises(ValueError, setattr, a, "tail",
2367 _str('ha\x07ho'))
2368 self.assertRaises(ValueError, setattr, a, "tail",
2369 _str('ha\x02ho'))
2370
2371 self.assertRaises(ValueError, Element,
2372 _str('ha\x07ho'))
2373 self.assertRaises(ValueError, Element,
2374 _str('ha\x02ho'))
2375
2377 # ElementTree fails to serialize this
2378 tostring = self.etree.tostring
2379 Element = self.etree.Element
2380 SubElement = self.etree.SubElement
2381
2382 a = Element('a')
2383 b = SubElement(a, 'b')
2384 c = SubElement(a, 'c')
2385
2386 result = tostring(a, encoding='UTF-16')
2387 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2388 canonicalize(result))
2389
2391 # ElementTree raises an AssertionError here
2392 tostring = self.etree.tostring
2393 self.assertRaises(TypeError, self.etree.tostring, None)
2394
2396 tostring = self.etree.tostring
2397 Element = self.etree.Element
2398 SubElement = self.etree.SubElement
2399
2400 a = Element('a')
2401 b = SubElement(a, 'b')
2402 c = SubElement(a, 'c')
2403
2404 result = tostring(a)
2405 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2406
2407 result = tostring(a, pretty_print=False)
2408 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2409
2410 result = tostring(a, pretty_print=True)
2411 self.assertEquals(result, _bytes("<a>\n <b/>\n <c/>\n</a>\n"))
2412
2414 tostring = self.etree.tostring
2415 Element = self.etree.Element
2416 SubElement = self.etree.SubElement
2417
2418 a = Element('a')
2419 a.tail = "aTAIL"
2420 b = SubElement(a, 'b')
2421 b.tail = "bTAIL"
2422 c = SubElement(a, 'c')
2423
2424 result = tostring(a)
2425 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2426
2427 result = tostring(a, with_tail=False)
2428 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>"))
2429
2430 result = tostring(a, with_tail=True)
2431 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2432
2434 tostring = self.etree.tostring
2435 XML = self.etree.XML
2436 ElementTree = self.etree.ElementTree
2437 Element = self.etree.Element
2438
2439 tree = Element("root").getroottree()
2440 self.assertEquals(None, tree.docinfo.standalone)
2441
2442 tree = XML(_bytes("<root/>")).getroottree()
2443 self.assertEquals(None, tree.docinfo.standalone)
2444
2445 tree = XML(_bytes(
2446 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"
2447 )).getroottree()
2448 self.assertEquals(True, tree.docinfo.standalone)
2449
2450 tree = XML(_bytes(
2451 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"
2452 )).getroottree()
2453 self.assertEquals(False, tree.docinfo.standalone)
2454
2456 tostring = self.etree.tostring
2457 XML = self.etree.XML
2458 ElementTree = self.etree.ElementTree
2459
2460 root = XML(_bytes("<root/>"))
2461
2462 tree = ElementTree(root)
2463 self.assertEquals(None, tree.docinfo.standalone)
2464
2465 result = tostring(root, xml_declaration=True, encoding="ASCII")
2466 self.assertEquals(result, _bytes(
2467 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2468
2469 result = tostring(root, xml_declaration=True, encoding="ASCII",
2470 standalone=True)
2471 self.assertEquals(result, _bytes(
2472 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2473
2474 tree = ElementTree(XML(result))
2475 self.assertEquals(True, tree.docinfo.standalone)
2476
2477 result = tostring(root, xml_declaration=True, encoding="ASCII",
2478 standalone=False)
2479 self.assertEquals(result, _bytes(
2480 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"))
2481
2482 tree = ElementTree(XML(result))
2483 self.assertEquals(False, tree.docinfo.standalone)
2484
2486 tostring = self.etree.tostring
2487 XML = self.etree.XML
2488 ElementTree = self.etree.ElementTree
2489
2490 root = XML(_bytes(
2491 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>"))
2492
2493 tree = ElementTree(root)
2494 self.assertEquals(True, tree.docinfo.standalone)
2495
2496 result = tostring(root, xml_declaration=True, encoding="ASCII")
2497 self.assertEquals(result, _bytes(
2498 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2499
2500 result = tostring(root, xml_declaration=True, encoding="ASCII",
2501 standalone=True)
2502 self.assertEquals(result, _bytes(
2503 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2504
2506 tostring = self.etree.tostring
2507 Element = self.etree.Element
2508 SubElement = self.etree.SubElement
2509
2510 a = Element('a')
2511 a.text = "A"
2512 a.tail = "tail"
2513 b = SubElement(a, 'b')
2514 b.text = "B"
2515 b.tail = _str("Søk på nettet")
2516 c = SubElement(a, 'c')
2517 c.text = "C"
2518
2519 result = tostring(a, method="text", encoding="UTF-16")
2520
2521 self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"),
2522 result)
2523
2525 tostring = self.etree.tostring
2526 Element = self.etree.Element
2527 SubElement = self.etree.SubElement
2528
2529 a = Element('a')
2530 a.text = _str('Søk på nettetA')
2531 a.tail = "tail"
2532 b = SubElement(a, 'b')
2533 b.text = "B"
2534 b.tail = _str('Søk på nettetB')
2535 c = SubElement(a, 'c')
2536 c.text = "C"
2537
2538 self.assertRaises(UnicodeEncodeError,
2539 tostring, a, method="text")
2540
2541 self.assertEquals(
2542 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'),
2543 tostring(a, encoding="UTF-8", method="text"))
2544
2546 tounicode = self.etree.tounicode
2547 Element = self.etree.Element
2548 SubElement = self.etree.SubElement
2549
2550 a = Element('a')
2551 b = SubElement(a, 'b')
2552 c = SubElement(a, 'c')
2553
2554 self.assert_(isinstance(tounicode(a), _unicode))
2555 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2556 canonicalize(tounicode(a)))
2557
2559 tounicode = self.etree.tounicode
2560 Element = self.etree.Element
2561 SubElement = self.etree.SubElement
2562
2563 a = Element('a')
2564 b = SubElement(a, 'b')
2565 c = SubElement(a, 'c')
2566 d = SubElement(c, 'd')
2567 self.assert_(isinstance(tounicode(b), _unicode))
2568 self.assert_(isinstance(tounicode(c), _unicode))
2569 self.assertEquals(_bytes('<b></b>'),
2570 canonicalize(tounicode(b)))
2571 self.assertEquals(_bytes('<c><d></d></c>'),
2572 canonicalize(tounicode(c)))
2573
2577
2579 tounicode = self.etree.tounicode
2580 Element = self.etree.Element
2581 SubElement = self.etree.SubElement
2582
2583 a = Element('a')
2584 b = SubElement(a, 'b')
2585 c = SubElement(a, 'c')
2586 d = SubElement(c, 'd')
2587 b.tail = 'Foo'
2588
2589 self.assert_(isinstance(tounicode(b), _unicode))
2590 self.assert_(tounicode(b) == '<b/>Foo' or
2591 tounicode(b) == '<b />Foo')
2592
2594 tounicode = self.etree.tounicode
2595 Element = self.etree.Element
2596 SubElement = self.etree.SubElement
2597
2598 a = Element('a')
2599 b = SubElement(a, 'b')
2600 c = SubElement(a, 'c')
2601
2602 result = tounicode(a)
2603 self.assertEquals(result, "<a><b/><c/></a>")
2604
2605 result = tounicode(a, pretty_print=False)
2606 self.assertEquals(result, "<a><b/><c/></a>")
2607
2608 result = tounicode(a, pretty_print=True)
2609 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2610
2612 tostring = self.etree.tostring
2613 Element = self.etree.Element
2614 SubElement = self.etree.SubElement
2615
2616 a = Element('a')
2617 b = SubElement(a, 'b')
2618 c = SubElement(a, 'c')
2619
2620 self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode))
2621 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2622 canonicalize(tostring(a, encoding=_unicode)))
2623
2625 tostring = self.etree.tostring
2626 Element = self.etree.Element
2627 SubElement = self.etree.SubElement
2628
2629 a = Element('a')
2630 b = SubElement(a, 'b')
2631 c = SubElement(a, 'c')
2632 d = SubElement(c, 'd')
2633 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2634 self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode))
2635 self.assertEquals(_bytes('<b></b>'),
2636 canonicalize(tostring(b, encoding=_unicode)))
2637 self.assertEquals(_bytes('<c><d></d></c>'),
2638 canonicalize(tostring(c, encoding=_unicode)))
2639
2641 tostring = self.etree.tostring
2642 self.assertRaises(TypeError, self.etree.tostring,
2643 None, encoding=_unicode)
2644
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 d = SubElement(c, 'd')
2654 b.tail = 'Foo'
2655
2656 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2657 self.assert_(tostring(b, encoding=_unicode) == '<b/>Foo' or
2658 tostring(b, encoding=_unicode) == '<b />Foo')
2659
2661 tostring = self.etree.tostring
2662 Element = self.etree.Element
2663 SubElement = self.etree.SubElement
2664
2665 a = Element('a')
2666 b = SubElement(a, 'b')
2667 c = SubElement(a, 'c')
2668
2669 result = tostring(a, encoding=_unicode)
2670 self.assertEquals(result, "<a><b/><c/></a>")
2671
2672 result = tostring(a, encoding=_unicode, pretty_print=False)
2673 self.assertEquals(result, "<a><b/><c/></a>")
2674
2675 result = tostring(a, encoding=_unicode, pretty_print=True)
2676 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2677
2678 # helper methods
2679
2681 """Write out element for comparison.
2682 """
2683 ElementTree = self.etree.ElementTree
2684 f = BytesIO()
2685 tree = ElementTree(element=element)
2686 tree.write(f, encoding=encoding, compression=compression)
2687 data = f.getvalue()
2688 if compression:
2689 data = zlib.decompress(data)
2690 return canonicalize(data)
2691
2692
2695 filename = fileInTestDir('test_broken.xml')
2696 root = etree.XML(_bytes('''\
2697 <doc xmlns:xi="http://www.w3.org/2001/XInclude">
2698 <xi:include href="%s" parse="text"/>
2699 </doc>
2700 ''' % filename))
2701 old_text = root.text
2702 content = open(filename).read()
2703 old_tail = root[0].tail
2704
2705 self.include( etree.ElementTree(root) )
2706 self.assertEquals(old_text + content + old_tail,
2707 root.text)
2708
2710 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'))
2711 self.assertNotEquals(
2712 'a',
2713 tree.getroot()[1].tag)
2714 # process xincludes
2715 self.include( tree )
2716 # check whether we find it replaced with included data
2717 self.assertEquals(
2718 'a',
2719 tree.getroot()[1].tag)
2720
2722 class res(etree.Resolver):
2723 include_text = open(fileInTestDir('test.xml')).read()
2724 called = {}
2725 def resolve(self, url, id, context):
2726 if url.endswith(".dtd"):
2727 self.called["dtd"] = True
2728 return self.resolve_filename(
2729 fileInTestDir('test.dtd'), context)
2730 elif url.endswith("test_xinclude.xml"):
2731 self.called["input"] = True
2732 return None # delegate to default resolver
2733 else:
2734 self.called["include"] = True
2735 return self.resolve_string(self.include_text, context)
2736
2737 res_instance = res()
2738 parser = etree.XMLParser(load_dtd = True)
2739 parser.resolvers.add(res_instance)
2740
2741 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2742 parser = parser)
2743
2744 self.include(tree)
2745
2746 called = list(res_instance.called.items())
2747 called.sort()
2748 self.assertEquals(
2749 [("dtd", True), ("include", True), ("input", True)],
2750 called)
2751
2755
2756
2761
2762
2765 tree = self.parse(_bytes('<a><b/></a>'))
2766 f = BytesIO()
2767 tree.write_c14n(f)
2768 s = f.getvalue()
2769 self.assertEquals(_bytes('<a><b></b></a>'),
2770 s)
2771
2773 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2774 f = BytesIO()
2775 tree.write_c14n(f, compression=9)
2776 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read()
2777 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
2778 s)
2779
2781 tree = self.parse(_bytes('<a><b/></a>'))
2782 handle, filename = tempfile.mkstemp()
2783 try:
2784 tree.write_c14n(filename)
2785 f = open(filename, 'rb')
2786 data = f.read()
2787 f.close()
2788 finally:
2789 os.close(handle)
2790 os.remove(filename)
2791 self.assertEquals(_bytes('<a><b></b></a>'),
2792 data)
2793
2795 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2796 handle, filename = tempfile.mkstemp()
2797 try:
2798 tree.write_c14n(filename, compression=9)
2799 f = gzip.open(filename, 'rb')
2800 data = f.read()
2801 f.close()
2802 finally:
2803 os.close(handle)
2804 os.remove(filename)
2805 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
2806 data)
2807
2809 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
2810 f = BytesIO()
2811 tree.write_c14n(f)
2812 s = f.getvalue()
2813 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
2814 s)
2815 f = BytesIO()
2816 tree.write_c14n(f, with_comments=True)
2817 s = f.getvalue()
2818 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
2819 s)
2820 f = BytesIO()
2821 tree.write_c14n(f, with_comments=False)
2822 s = f.getvalue()
2823 self.assertEquals(_bytes('<a><b></b></a>'),
2824 s)
2825
2827 tree = self.parse(_bytes(
2828 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
2829 f = BytesIO()
2830 tree.write_c14n(f)
2831 s = f.getvalue()
2832 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
2833 s)
2834 f = BytesIO()
2835 tree.write_c14n(f, exclusive=False)
2836 s = f.getvalue()
2837 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
2838 s)
2839 f = BytesIO()
2840 tree.write_c14n(f, exclusive=True)
2841 s = f.getvalue()
2842 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
2843 s)
2844
2845
2848 tree = self.parse(_bytes('<a><b/></a>'))
2849 f = BytesIO()
2850 tree.write(f)
2851 s = f.getvalue()
2852 self.assertEquals(_bytes('<a><b/></a>'),
2853 s)
2854
2856 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2857 f = BytesIO()
2858 tree.write(f, compression=9)
2859 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read()
2860 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2861 s)
2862
2864 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2865 f = BytesIO()
2866 tree.write(f, compression=0)
2867 s0 = f.getvalue()
2868
2869 f = BytesIO()
2870 tree.write(f)
2871 self.assertEquals(f.getvalue(), s0)
2872
2873 f = BytesIO()
2874 tree.write(f, compression=1)
2875 s = f.getvalue()
2876 self.assert_(len(s) <= len(s0))
2877 s1 = gzip.GzipFile(fileobj=BytesIO(s)).read()
2878
2879 f = BytesIO()
2880 tree.write(f, compression=9)
2881 s = f.getvalue()
2882 self.assert_(len(s) <= len(s0))
2883 s9 = gzip.GzipFile(fileobj=BytesIO(s)).read()
2884
2885 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2886 s0)
2887 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2888 s1)
2889 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2890 s9)
2891
2893 tree = self.parse(_bytes('<a><b/></a>'))
2894 handle, filename = tempfile.mkstemp()
2895 try:
2896 tree.write(filename)
2897 f = open(filename, 'rb')
2898 data = f.read()
2899 f.close()
2900 finally:
2901 os.close(handle)
2902 os.remove(filename)
2903 self.assertEquals(_bytes('<a><b/></a>'),
2904 data)
2905
2907 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2908 handle, filename = tempfile.mkstemp()
2909 try:
2910 tree.write(filename, compression=9)
2911 f = gzip.open(filename, 'rb')
2912 data = f.read()
2913 f.close()
2914 finally:
2915 os.close(handle)
2916 os.remove(filename)
2917 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2918 data)
2919
2921 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2922 handle, filename = tempfile.mkstemp()
2923 try:
2924 tree.write(filename, compression=9)
2925 data = etree.tostring(etree.parse(filename))
2926 finally:
2927 os.close(handle)
2928 os.remove(filename)
2929 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2930 data)
2931
2933 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2934 handle, filename = tempfile.mkstemp()
2935 try:
2936 tree.write(filename, compression=9)
2937 data = etree.tostring(etree.parse(
2938 gzip.GzipFile(filename)))
2939 finally:
2940 os.close(handle)
2941 os.remove(filename)
2942 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2943 data)
2944
2945
2947 suite = unittest.TestSuite()
2948 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)])
2949 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)])
2950 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)])
2951 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)])
2952 suite.addTests([unittest.makeSuite(ETreeWriteTestCase)])
2953 suite.addTests(
2954 [make_doctest('../../../doc/tutorial.txt')])
2955 suite.addTests(
2956 [make_doctest('../../../doc/api.txt')])
2957 suite.addTests(
2958 [make_doctest('../../../doc/FAQ.txt')])
2959 suite.addTests(
2960 [make_doctest('../../../doc/parsing.txt')])
2961 suite.addTests(
2962 [make_doctest('../../../doc/resolvers.txt')])
2963 return suite
2964
2965 if __name__ == '__main__':
2966 print('to test use test.py %s' % __file__)
2967
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0 on Sun Jun 21 09:44:44 2009 | http://epydoc.sourceforge.net |