| 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 # lxml.etree separates target and text
210 Element = self.etree.Element
211 SubElement = self.etree.SubElement
212 ProcessingInstruction = self.etree.ProcessingInstruction
213
214 a = Element('a')
215 a.append(ProcessingInstruction('foo', 'some more text'))
216 self.assertEquals(a[0].target, 'foo')
217 self.assertEquals(a[0].text, 'some more text')
218
220 XML = self.etree.XML
221 root = XML(_bytes("<test><?mypi my test ?></test>"))
222 self.assertEquals(root[0].target, "mypi")
223 self.assertEquals(root[0].text, "my test ")
224
226 # previously caused a crash
227 ProcessingInstruction = self.etree.ProcessingInstruction
228
229 a = ProcessingInstruction("PI", "ONE")
230 b = copy.deepcopy(a)
231 b.text = "ANOTHER"
232
233 self.assertEquals('ONE', a.text)
234 self.assertEquals('ANOTHER', b.text)
235
237 XML = self.etree.XML
238 tostring = self.etree.tostring
239 root = XML(_bytes("<?mypi my test ?><test/><!--comment -->"))
240 tree1 = self.etree.ElementTree(root)
241 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
242 tostring(tree1))
243
244 tree2 = copy.deepcopy(tree1)
245 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
246 tostring(tree2))
247
248 root2 = copy.deepcopy(tree1.getroot())
249 self.assertEquals(_bytes("<test/>"),
250 tostring(root2))
251
253 XML = self.etree.XML
254 tostring = self.etree.tostring
255 xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>')
256 root = XML(xml)
257 tree1 = self.etree.ElementTree(root)
258 self.assertEquals(xml, tostring(tree1))
259
260 tree2 = copy.deepcopy(tree1)
261 self.assertEquals(xml, tostring(tree2))
262
263 root2 = copy.deepcopy(tree1.getroot())
264 self.assertEquals(_bytes("<test/>"),
265 tostring(root2))
266
268 # ElementTree accepts arbitrary attribute values
269 # lxml.etree allows only strings
270 Element = self.etree.Element
271
272 root = Element("root")
273 root.set("attr", "TEST")
274 self.assertEquals("TEST", root.get("attr"))
275 self.assertRaises(TypeError, root.set, "newattr", 5)
276
278 fromstring = self.etree.fromstring
279 tostring = self.etree.tostring
280 XMLParser = self.etree.XMLParser
281
282 xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
283 parser = XMLParser(remove_comments=True)
284 root = fromstring(xml, parser)
285 self.assertEquals(
286 _bytes('<a><b><c/></b></a>'),
287 tostring(root))
288
290 parse = self.etree.parse
291 tostring = self.etree.tostring
292 XMLParser = self.etree.XMLParser
293
294 xml = _bytes('<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>')
295
296 f = BytesIO(xml)
297 tree = parse(f)
298 self.assertEquals(
299 xml,
300 tostring(tree))
301
302 parser = XMLParser(remove_pis=True)
303 tree = parse(f, parser)
304 self.assertEquals(
305 _bytes('<a><b><c/></b></a>'),
306 tostring(tree))
307
309 # ET raises IOError only
310 parse = self.etree.parse
311 self.assertRaises(TypeError, parse, 'notthere.xml', object())
312
314 parse = self.etree.parse
315 f = BytesIO('<a><b></c></b></a>')
316 self.etree.clear_error_log()
317 try:
318 parse(f)
319 logs = None
320 except SyntaxError:
321 e = sys.exc_info()[1]
322 logs = e.error_log
323 f.close()
324 self.assert_([ log for log in logs
325 if 'mismatch' in log.message ])
326 self.assert_([ log for log in logs
327 if 'PARSER' in log.domain_name])
328 self.assert_([ log for log in logs
329 if 'TAG_NAME_MISMATCH' in log.type_name ])
330 self.assert_([ log for log in logs
331 if 1 == log.line ])
332 self.assert_([ log for log in logs
333 if 15 == log.column ])
334
336 # ET removes comments
337 iterparse = self.etree.iterparse
338 tostring = self.etree.tostring
339
340 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
341 events = list(iterparse(f))
342 root = events[-1][1]
343 self.assertEquals(3, len(events))
344 self.assertEquals(
345 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
346 tostring(root))
347
349 # ET removes comments
350 iterparse = self.etree.iterparse
351 tostring = self.etree.tostring
352
353 def name(event, el):
354 if event == 'comment':
355 return el.text
356 else:
357 return el.tag
358
359 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
360 events = list(iterparse(f, events=('end', 'comment')))
361 root = events[-1][1]
362 self.assertEquals(6, len(events))
363 self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'],
364 [ name(*item) for item in events ])
365 self.assertEquals(
366 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
367 tostring(root))
368
370 # ET removes pis
371 iterparse = self.etree.iterparse
372 tostring = self.etree.tostring
373 ElementTree = self.etree.ElementTree
374
375 def name(event, el):
376 if event == 'pi':
377 return (el.target, el.text)
378 else:
379 return el.tag
380
381 f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>')
382 events = list(iterparse(f, events=('end', 'pi')))
383 root = events[-2][1]
384 self.assertEquals(8, len(events))
385 self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b',
386 ('pid','d'), 'a', ('pie','e')],
387 [ name(*item) for item in events ])
388 self.assertEquals(
389 _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'),
390 tostring(ElementTree(root)))
391
393 iterparse = self.etree.iterparse
394 tostring = self.etree.tostring
395
396 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
397 events = list(iterparse(f, remove_comments=True,
398 events=('end', 'comment')))
399 root = events[-1][1]
400 self.assertEquals(3, len(events))
401 self.assertEquals(['c', 'b', 'a'],
402 [ el.tag for (event, el) in events ])
403 self.assertEquals(
404 _bytes('<a><b><c/></b></a>'),
405 tostring(root))
406
408 iterparse = self.etree.iterparse
409 f = BytesIO('<a><b><c/></a>')
410 # ET raises ExpatError, lxml raises XMLSyntaxError
411 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))
412
414 iterparse = self.etree.iterparse
415 f = BytesIO("""
416 <a> \n \n <b> b test </b> \n
417
418 \n\t <c> \n </c> </a> \n """)
419 iterator = iterparse(f, remove_blank_text=True)
420 text = [ (element.text, element.tail)
421 for event, element in iterator ]
422 self.assertEquals(
423 [(" b test ", None), (" \n ", None), (None, None)],
424 text)
425
427 iterparse = self.etree.iterparse
428 f = BytesIO('<a><b><d/></b><c/></a>')
429
430 iterator = iterparse(f, tag="b", events=('start', 'end'))
431 events = list(iterator)
432 root = iterator.root
433 self.assertEquals(
434 [('start', root[0]), ('end', root[0])],
435 events)
436
438 iterparse = self.etree.iterparse
439 f = BytesIO('<a><b><d/></b><c/></a>')
440
441 iterator = iterparse(f, tag="*", events=('start', 'end'))
442 events = list(iterator)
443 self.assertEquals(
444 8,
445 len(events))
446
448 text = _str('Søk på nettet')
449 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
450 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
451 ).encode('iso-8859-1')
452
453 self.assertRaises(self.etree.ParseError,
454 list, self.etree.iterparse(BytesIO(xml_latin1)))
455
457 text = _str('Søk på nettet', encoding="UTF-8")
458 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
459 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
460 ).encode('iso-8859-1')
461
462 iterator = self.etree.iterparse(BytesIO(xml_latin1),
463 encoding="iso-8859-1")
464 self.assertEquals(1, len(list(iterator)))
465
466 a = iterator.root
467 self.assertEquals(a.text, text)
468
470 tostring = self.etree.tostring
471 f = BytesIO('<root><![CDATA[test]]></root>')
472 context = self.etree.iterparse(f, strip_cdata=False)
473 content = [ el.text for event,el in context ]
474
475 self.assertEquals(['test'], content)
476 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
477 tostring(context.root))
478
482
484 self.etree.XMLParser(encoding="ascii")
485 self.etree.XMLParser(encoding="utf-8")
486 self.etree.XMLParser(encoding="iso-8859-1")
487
489 assertEquals = self.assertEquals
490 assertFalse = self.assertFalse
491
492 events = []
493 class Target(object):
494 def start(self, tag, attrib):
495 events.append("start")
496 assertFalse(attrib)
497 assertEquals("TAG", tag)
498 def end(self, tag):
499 events.append("end")
500 assertEquals("TAG", tag)
501 def close(self):
502 return "DONE" # no Element!
503
504 parser = self.etree.XMLParser(target=Target())
505 tree = self.etree.ElementTree()
506
507 self.assertRaises(TypeError,
508 tree.parse, BytesIO("<TAG/>"), parser=parser)
509 self.assertEquals(["start", "end"], events)
510
512 events = []
513 class Target(object):
514 def start(self, tag, attrib):
515 events.append("start-" + tag)
516 def end(self, tag):
517 events.append("end-" + tag)
518 def data(self, data):
519 events.append("data-" + data)
520 def comment(self, text):
521 events.append("comment-" + text)
522 def close(self):
523 return "DONE"
524
525 parser = self.etree.XMLParser(target=Target())
526
527 parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->'))
528 done = parser.close()
529
530 self.assertEquals("DONE", done)
531 self.assertEquals(["comment-a", "start-root", "data-A", "comment-b",
532 "start-sub", "end-sub", "comment-c", "data-B",
533 "end-root", "comment-d"],
534 events)
535
537 events = []
538 class Target(object):
539 def start(self, tag, attrib):
540 events.append("start-" + tag)
541 def end(self, tag):
542 events.append("end-" + tag)
543 def data(self, data):
544 events.append("data-" + data)
545 def pi(self, target, data):
546 events.append("pi-" + target + "-" + data)
547 def close(self):
548 return "DONE"
549
550 parser = self.etree.XMLParser(target=Target())
551
552 parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>'))
553 done = parser.close()
554
555 self.assertEquals("DONE", done)
556 self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b",
557 "data-B", "end-root", "pi-test-c"],
558 events)
559
561 events = []
562 class Target(object):
563 def start(self, tag, attrib):
564 events.append("start-" + tag)
565 def end(self, tag):
566 events.append("end-" + tag)
567 def data(self, data):
568 events.append("data-" + data)
569 def close(self):
570 return "DONE"
571
572 parser = self.etree.XMLParser(target=Target(),
573 strip_cdata=False)
574
575 parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>'))
576 done = parser.close()
577
578 self.assertEquals("DONE", done)
579 self.assertEquals(["start-root", "data-A", "start-a",
580 "data-ca", "end-a", "data-B", "end-root"],
581 events)
582
584 events = []
585 class Target(object):
586 def start(self, tag, attrib):
587 events.append("start-" + tag)
588 def end(self, tag):
589 events.append("end-" + tag)
590 def data(self, data):
591 events.append("data-" + data)
592 def close(self):
593 events.append("close")
594 return "DONE"
595
596 parser = self.etree.XMLParser(target=Target(),
597 recover=True)
598
599 parser.feed(_bytes('<root>A<a>ca</a>B</not-root>'))
600 done = parser.close()
601
602 self.assertEquals("DONE", done)
603 self.assertEquals(["start-root", "data-A", "start-a",
604 "data-ca", "end-a", "data-B",
605 "end-root", "close"],
606 events)
607
609 iterwalk = self.etree.iterwalk
610 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
611
612 iterator = iterwalk(root, tag="b", events=('start', 'end'))
613 events = list(iterator)
614 self.assertEquals(
615 [('start', root[0]), ('end', root[0])],
616 events)
617
619 iterwalk = self.etree.iterwalk
620 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
621
622 iterator = iterwalk(root, tag="*", events=('start', 'end'))
623 events = list(iterator)
624 self.assertEquals(
625 8,
626 len(events))
627
629 iterwalk = self.etree.iterwalk
630 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
631
632 events = list(iterwalk(root))
633 self.assertEquals(
634 [('end', root[0]), ('end', root[1]), ('end', root)],
635 events)
636
638 iterwalk = self.etree.iterwalk
639 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
640
641 iterator = iterwalk(root, events=('start',))
642 events = list(iterator)
643 self.assertEquals(
644 [('start', root), ('start', root[0]), ('start', root[1])],
645 events)
646
648 iterwalk = self.etree.iterwalk
649 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
650
651 iterator = iterwalk(root, events=('start','end'))
652 events = list(iterator)
653 self.assertEquals(
654 [('start', root), ('start', root[0]), ('end', root[0]),
655 ('start', root[1]), ('end', root[1]), ('end', root)],
656 events)
657
659 iterwalk = self.etree.iterwalk
660 root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
661
662 iterator = iterwalk(root)
663 for event, elem in iterator:
664 elem.clear()
665
666 self.assertEquals(0,
667 len(root))
668
670 iterwalk = self.etree.iterwalk
671 root = self.etree.XML(_bytes('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>'))
672
673 attr_name = '{testns}bla'
674 events = []
675 iterator = iterwalk(root, events=('start','end','start-ns','end-ns'))
676 for event, elem in iterator:
677 events.append(event)
678 if event == 'start':
679 if elem.tag != '{ns1}a':
680 elem.set(attr_name, 'value')
681
682 self.assertEquals(
683 ['start-ns', 'start', 'start', 'start-ns', 'start',
684 'end', 'end-ns', 'end', 'end', 'end-ns'],
685 events)
686
687 self.assertEquals(
688 None,
689 root.get(attr_name))
690 self.assertEquals(
691 'value',
692 root[0].get(attr_name))
693
695 iterwalk = self.etree.iterwalk
696 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>'))
697
698 counts = []
699 for event, elem in iterwalk(root):
700 counts.append(len(list(elem.getiterator())))
701 self.assertEquals(
702 [1,2,1,4],
703 counts)
704
706 parse = self.etree.parse
707 parser = self.etree.XMLParser(dtd_validation=True)
708 assertEqual = self.assertEqual
709 test_url = _str("__nosuch.dtd")
710
711 class MyResolver(self.etree.Resolver):
712 def resolve(self, url, id, context):
713 assertEqual(url, test_url)
714 return self.resolve_string(
715 _str('''<!ENTITY myentity "%s">
716 <!ELEMENT doc ANY>''') % url, context)
717
718 parser.resolvers.add(MyResolver())
719
720 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
721 tree = parse(StringIO(xml), parser)
722 root = tree.getroot()
723 self.assertEquals(root.text, test_url)
724
726 parse = self.etree.parse
727 parser = self.etree.XMLParser(dtd_validation=True)
728 assertEqual = self.assertEqual
729 test_url = _str("__nosuch.dtd")
730
731 class MyResolver(self.etree.Resolver):
732 def resolve(self, url, id, context):
733 assertEqual(url, test_url)
734 return self.resolve_string(
735 (_str('''<!ENTITY myentity "%s">
736 <!ELEMENT doc ANY>''') % url).encode('utf-8'),
737 context)
738
739 parser.resolvers.add(MyResolver())
740
741 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
742 tree = parse(StringIO(xml), parser)
743 root = tree.getroot()
744 self.assertEquals(root.text, test_url)
745
747 parse = self.etree.parse
748 parser = self.etree.XMLParser(dtd_validation=True)
749 assertEqual = self.assertEqual
750 test_url = _str("__nosuch.dtd")
751
752 class MyResolver(self.etree.Resolver):
753 def resolve(self, url, id, context):
754 assertEqual(url, test_url)
755 return self.resolve_file(
756 SillyFileLike(
757 _str('''<!ENTITY myentity "%s">
758 <!ELEMENT doc ANY>''') % url), context)
759
760 parser.resolvers.add(MyResolver())
761
762 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
763 tree = parse(StringIO(xml), parser)
764 root = tree.getroot()
765 self.assertEquals(root.text, test_url)
766
768 parse = self.etree.parse
769 parser = self.etree.XMLParser(attribute_defaults=True)
770 assertEqual = self.assertEqual
771 test_url = _str("__nosuch.dtd")
772
773 class MyResolver(self.etree.Resolver):
774 def resolve(self, url, id, context):
775 assertEqual(url, test_url)
776 return self.resolve_filename(
777 fileInTestDir('test.dtd'), context)
778
779 parser.resolvers.add(MyResolver())
780
781 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
782 tree = parse(StringIO(xml), parser)
783 root = tree.getroot()
784 self.assertEquals(
785 root.attrib, {'default': 'valueA'})
786 self.assertEquals(
787 root[0].attrib, {'default': 'valueB'})
788
790 parse = self.etree.parse
791 parser = self.etree.XMLParser(attribute_defaults=True)
792 assertEqual = self.assertEqual
793 test_url = _str("__nosuch.dtd")
794
795 class MyResolver(self.etree.Resolver):
796 def resolve(self, url, id, context):
797 assertEqual(url, fileInTestDir(test_url))
798 return self.resolve_filename(
799 fileInTestDir('test.dtd'), context)
800
801 parser.resolvers.add(MyResolver())
802
803 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
804 tree = parse(StringIO(xml), parser,
805 base_url=fileInTestDir('__test.xml'))
806 root = tree.getroot()
807 self.assertEquals(
808 root.attrib, {'default': 'valueA'})
809 self.assertEquals(
810 root[0].attrib, {'default': 'valueB'})
811
813 parse = self.etree.parse
814 parser = self.etree.XMLParser(attribute_defaults=True)
815 assertEqual = self.assertEqual
816 test_url = _str("__nosuch.dtd")
817
818 class MyResolver(self.etree.Resolver):
819 def resolve(self, url, id, context):
820 assertEqual(url, test_url)
821 return self.resolve_file(
822 open(fileInTestDir('test.dtd'), 'rb'), context)
823
824 parser.resolvers.add(MyResolver())
825
826 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
827 tree = parse(StringIO(xml), parser)
828 root = tree.getroot()
829 self.assertEquals(
830 root.attrib, {'default': 'valueA'})
831 self.assertEquals(
832 root[0].attrib, {'default': 'valueB'})
833
835 parse = self.etree.parse
836 parser = self.etree.XMLParser(load_dtd=True)
837 assertEqual = self.assertEqual
838 test_url = _str("__nosuch.dtd")
839
840 class check(object):
841 resolved = False
842
843 class MyResolver(self.etree.Resolver):
844 def resolve(self, url, id, context):
845 assertEqual(url, test_url)
846 check.resolved = True
847 return self.resolve_empty(context)
848
849 parser.resolvers.add(MyResolver())
850
851 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
852 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser)
853 self.assert_(check.resolved)
854
856 parse = self.etree.parse
857 parser = self.etree.XMLParser(dtd_validation=True)
858
859 class _LocalException(Exception):
860 pass
861
862 class MyResolver(self.etree.Resolver):
863 def resolve(self, url, id, context):
864 raise _LocalException
865
866 parser.resolvers.add(MyResolver())
867
868 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
869 self.assertRaises(_LocalException, parse, BytesIO(xml), parser)
870
871 if etree.LIBXML_VERSION > (2,6,20):
873 parse = self.etree.parse
874 tostring = self.etree.tostring
875 parser = self.etree.XMLParser(resolve_entities=False)
876 Entity = self.etree.Entity
877
878 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
879 tree = parse(BytesIO(xml), parser)
880 root = tree.getroot()
881 self.assertEquals(root[0].tag, Entity)
882 self.assertEquals(root[0].text, "&myentity;")
883 self.assertEquals(root[0].tail, None)
884 self.assertEquals(root[0].name, "myentity")
885
886 self.assertEquals(_bytes('<doc>&myentity;</doc>'),
887 tostring(root))
888
890 Entity = self.etree.Entity
891 Element = self.etree.Element
892 tostring = self.etree.tostring
893
894 root = Element("root")
895 root.append( Entity("test") )
896
897 self.assertEquals(root[0].tag, Entity)
898 self.assertEquals(root[0].text, "&test;")
899 self.assertEquals(root[0].tail, None)
900 self.assertEquals(root[0].name, "test")
901
902 self.assertEquals(_bytes('<root>&test;</root>'),
903 tostring(root))
904
906 Entity = self.etree.Entity
907 self.assertEquals(Entity("test").text, '&test;')
908 self.assertEquals(Entity("#17683").text, '䔓')
909 self.assertEquals(Entity("#x1768").text, 'ᝨ')
910 self.assertEquals(Entity("#x98AF").text, '颯')
911
913 Entity = self.etree.Entity
914 self.assertRaises(ValueError, Entity, 'a b c')
915 self.assertRaises(ValueError, Entity, 'a,b')
916 self.assertRaises(ValueError, Entity, 'a\0b')
917 self.assertRaises(ValueError, Entity, '#abc')
918 self.assertRaises(ValueError, Entity, '#xxyz')
919
921 CDATA = self.etree.CDATA
922 Element = self.etree.Element
923 tostring = self.etree.tostring
924
925 root = Element("root")
926 root.text = CDATA('test')
927
928 self.assertEquals('test',
929 root.text)
930 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
931 tostring(root))
932
934 CDATA = self.etree.CDATA
935 Element = self.etree.Element
936 root = Element("root")
937
938 root.text = CDATA("test")
939 self.assertEquals('test', root.text)
940
941 root.text = CDATA(_str("test"))
942 self.assertEquals('test', root.text)
943
944 self.assertRaises(TypeError, CDATA, 1)
945
947 CDATA = self.etree.CDATA
948 Element = self.etree.Element
949
950 root = Element("root")
951 cdata = CDATA('test')
952
953 self.assertRaises(TypeError,
954 setattr, root, 'tail', cdata)
955 self.assertRaises(TypeError,
956 root.set, 'attr', cdata)
957 self.assertRaises(TypeError,
958 operator.setitem, root.attrib, 'attr', cdata)
959
961 tostring = self.etree.tostring
962 parser = self.etree.XMLParser(strip_cdata=False)
963 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
964
965 self.assertEquals('test', root.text)
966 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
967 tostring(root))
968
969 # TypeError in etree, AssertionError in ElementTree;
971 Element = self.etree.Element
972 SubElement = self.etree.SubElement
973
974 a = Element('a')
975 b = SubElement(a, 'b')
976
977 self.assertRaises(TypeError,
978 a.__setitem__, 0, 'foo')
979
981 # raises AssertionError in ElementTree
982 Element = self.etree.Element
983 self.assertRaises(TypeError, Element('a').append, None)
984
986 Element = self.etree.Element
987 SubElement = self.etree.SubElement
988 root = Element('root')
989 SubElement(root, 'a')
990 SubElement(root, 'b')
991
992 self.assertEquals(['a', 'b'],
993 [c.tag for c in root])
994 root[1].addnext(root[0])
995 self.assertEquals(['b', 'a'],
996 [c.tag for c in root])
997
999 Element = self.etree.Element
1000 SubElement = self.etree.SubElement
1001 root = Element('root')
1002 SubElement(root, 'a')
1003 SubElement(root, 'b')
1004
1005 self.assertEquals(['a', 'b'],
1006 [c.tag for c in root])
1007 root[0].addprevious(root[1])
1008 self.assertEquals(['b', 'a'],
1009 [c.tag for c in root])
1010
1012 Element = self.etree.Element
1013 a = Element('a')
1014 b = Element('b')
1015 self.assertRaises(TypeError, a.addnext, b)
1016
1018 Element = self.etree.Element
1019 a = Element('a')
1020 b = Element('b')
1021 self.assertRaises(TypeError, a.addnext, b)
1022
1024 Element = self.etree.Element
1025 SubElement = self.etree.SubElement
1026 PI = self.etree.PI
1027 root = Element('root')
1028 SubElement(root, 'a')
1029 pi = PI('TARGET', 'TEXT')
1030 pi.tail = "TAIL"
1031
1032 self.assertEquals(_bytes('<root><a></a></root>'),
1033 self._writeElement(root))
1034 root[0].addprevious(pi)
1035 self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'),
1036 self._writeElement(root))
1037
1039 Element = self.etree.Element
1040 PI = self.etree.PI
1041 root = Element('root')
1042 pi = PI('TARGET', 'TEXT')
1043 pi.tail = "TAIL"
1044
1045 self.assertEquals(_bytes('<root></root>'),
1046 self._writeElement(root))
1047 root.addprevious(pi)
1048 self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'),
1049 self._writeElement(root))
1050
1052 Element = self.etree.Element
1053 SubElement = self.etree.SubElement
1054 PI = self.etree.PI
1055 root = Element('root')
1056 SubElement(root, 'a')
1057 pi = PI('TARGET', 'TEXT')
1058 pi.tail = "TAIL"
1059
1060 self.assertEquals(_bytes('<root><a></a></root>'),
1061 self._writeElement(root))
1062 root[0].addnext(pi)
1063 self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'),
1064 self._writeElement(root))
1065
1067 Element = self.etree.Element
1068 PI = self.etree.PI
1069 root = Element('root')
1070 pi = PI('TARGET', 'TEXT')
1071 pi.tail = "TAIL"
1072
1073 self.assertEquals(_bytes('<root></root>'),
1074 self._writeElement(root))
1075 root.addnext(pi)
1076 self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'),
1077 self._writeElement(root))
1078
1080 Element = self.etree.Element
1081 SubElement = self.etree.SubElement
1082 Comment = self.etree.Comment
1083 root = Element('root')
1084 SubElement(root, 'a')
1085 comment = Comment('TEXT ')
1086 comment.tail = "TAIL"
1087
1088 self.assertEquals(_bytes('<root><a></a></root>'),
1089 self._writeElement(root))
1090 root[0].addnext(comment)
1091 self.assertEquals(_bytes('<root><a></a><!--TEXT -->TAIL</root>'),
1092 self._writeElement(root))
1093
1095 Element = self.etree.Element
1096 Comment = self.etree.Comment
1097 root = Element('root')
1098 comment = Comment('TEXT ')
1099 comment.tail = "TAIL"
1100
1101 self.assertEquals(_bytes('<root></root>'),
1102 self._writeElement(root))
1103 root.addnext(comment)
1104 self.assertEquals(_bytes('<root></root>\n<!--TEXT -->'),
1105 self._writeElement(root))
1106
1108 Element = self.etree.Element
1109 SubElement = self.etree.SubElement
1110 Comment = self.etree.Comment
1111 root = Element('root')
1112 SubElement(root, 'a')
1113 comment = Comment('TEXT ')
1114 comment.tail = "TAIL"
1115
1116 self.assertEquals(_bytes('<root><a></a></root>'),
1117 self._writeElement(root))
1118 root[0].addprevious(comment)
1119 self.assertEquals(_bytes('<root><!--TEXT -->TAIL<a></a></root>'),
1120 self._writeElement(root))
1121
1123 Element = self.etree.Element
1124 Comment = self.etree.Comment
1125 root = Element('root')
1126 comment = Comment('TEXT ')
1127 comment.tail = "TAIL"
1128
1129 self.assertEquals(_bytes('<root></root>'),
1130 self._writeElement(root))
1131 root.addprevious(comment)
1132 self.assertEquals(_bytes('<!--TEXT -->\n<root></root>'),
1133 self._writeElement(root))
1134
1135 # ET's Elements have items() and key(), but not values()
1137 XML = self.etree.XML
1138
1139 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
1140 values = root.values()
1141 values.sort()
1142 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
1143
1144 # gives error in ElementTree
1146 Element = self.etree.Element
1147 Comment = self.etree.Comment
1148
1149 a = Element('a')
1150 a.append(Comment())
1151 self.assertEquals(
1152 _bytes('<a><!----></a>'),
1153 self._writeElement(a))
1154
1155 # ElementTree ignores comments
1157 ElementTree = self.etree.ElementTree
1158 tostring = self.etree.tostring
1159
1160 xml = _bytes('<a><b/><!----><c/></a>')
1161 f = BytesIO(xml)
1162 doc = ElementTree(file=f)
1163 a = doc.getroot()
1164 self.assertEquals(
1165 '',
1166 a[1].text)
1167 self.assertEquals(
1168 xml,
1169 tostring(a))
1170
1171 # ElementTree ignores comments
1173 ElementTree = self.etree.ElementTree
1174
1175 f = BytesIO('<a><b></b><!-- hoi --><c></c></a>')
1176 doc = ElementTree(file=f)
1177 a = doc.getroot()
1178 self.assertEquals(
1179 ' hoi ',
1180 a[1].text)
1181
1182 # does not raise an exception in ElementTree
1184 Element = self.etree.Element
1185 Comment = self.etree.Comment
1186
1187 c = Comment()
1188 el = Element('myel')
1189
1190 self.assertRaises(TypeError, c.append, el)
1191 self.assertRaises(TypeError, c.insert, 0, el)
1192 self.assertRaises(TypeError, c.set, "myattr", "test")
1193
1194 # test passing 'None' to dump
1197
1199 ElementTree = self.etree.ElementTree
1200
1201 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>')
1202 doc = ElementTree(file=f)
1203 a = doc.getroot()
1204 self.assertEquals(
1205 None,
1206 a.prefix)
1207 self.assertEquals(
1208 'foo',
1209 a[0].prefix)
1210
1212 ElementTree = self.etree.ElementTree
1213
1214 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>')
1215 doc = ElementTree(file=f)
1216 a = doc.getroot()
1217 self.assertEquals(
1218 None,
1219 a.prefix)
1220 self.assertEquals(
1221 None,
1222 a[0].prefix)
1223
1225 Element = self.etree.Element
1226 SubElement = self.etree.SubElement
1227
1228 a = Element('a')
1229 b = SubElement(a, 'b')
1230 c = SubElement(a, 'c')
1231 d = SubElement(b, 'd')
1232 self.assertEquals(
1233 None,
1234 a.getparent())
1235 self.assertEquals(
1236 a,
1237 b.getparent())
1238 self.assertEquals(
1239 b.getparent(),
1240 c.getparent())
1241 self.assertEquals(
1242 b,
1243 d.getparent())
1244
1246 XML = self.etree.XML
1247
1248 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1249 result = []
1250 for el in root.iterchildren():
1251 result.append(el.tag)
1252 self.assertEquals(['one', 'two', 'three'], result)
1253
1255 XML = self.etree.XML
1256
1257 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
1258 result = []
1259 for el in root.iterchildren(reversed=True):
1260 result.append(el.tag)
1261 self.assertEquals(['three', 'two', 'one'], result)
1262
1264 XML = self.etree.XML
1265
1266 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1267 result = []
1268 for el in root.iterchildren(tag='two'):
1269 result.append(el.text)
1270 self.assertEquals(['Two', 'Bla'], result)
1271
1273 XML = self.etree.XML
1274
1275 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>'))
1276 result = []
1277 for el in root.iterchildren(reversed=True, tag='two'):
1278 result.append(el.text)
1279 self.assertEquals(['Bla', 'Two'], result)
1280
1282 Element = self.etree.Element
1283 SubElement = self.etree.SubElement
1284
1285 a = Element('a')
1286 b = SubElement(a, 'b')
1287 c = SubElement(a, 'c')
1288 d = SubElement(b, 'd')
1289 self.assertEquals(
1290 [],
1291 list(a.iterancestors()))
1292 self.assertEquals(
1293 [a],
1294 list(b.iterancestors()))
1295 self.assertEquals(
1296 [a],
1297 list(c.iterancestors()))
1298 self.assertEquals(
1299 [b, a],
1300 list(d.iterancestors()))
1301
1303 Element = self.etree.Element
1304 SubElement = self.etree.SubElement
1305
1306 a = Element('a')
1307 b = SubElement(a, 'b')
1308 c = SubElement(a, 'c')
1309 d = SubElement(b, 'd')
1310 self.assertEquals(
1311 [a],
1312 list(d.iterancestors(tag='a')))
1313
1315 Element = self.etree.Element
1316 SubElement = self.etree.SubElement
1317
1318 a = Element('a')
1319 b = SubElement(a, 'b')
1320 c = SubElement(a, 'c')
1321 d = SubElement(b, 'd')
1322 e = SubElement(c, 'e')
1323
1324 self.assertEquals(
1325 [b, d, c, e],
1326 list(a.iterdescendants()))
1327 self.assertEquals(
1328 [],
1329 list(d.iterdescendants()))
1330
1332 Element = self.etree.Element
1333 SubElement = self.etree.SubElement
1334
1335 a = Element('a')
1336 b = SubElement(a, 'b')
1337 c = SubElement(a, 'c')
1338 d = SubElement(b, 'd')
1339 e = SubElement(c, 'e')
1340
1341 self.assertEquals(
1342 [],
1343 list(a.iterdescendants('a')))
1344 a2 = SubElement(e, 'a')
1345 self.assertEquals(
1346 [a2],
1347 list(a.iterdescendants('a')))
1348 self.assertEquals(
1349 [a2],
1350 list(c.iterdescendants('a')))
1351
1353 Element = self.etree.Element
1354 SubElement = self.etree.SubElement
1355
1356 a = Element('a')
1357 b = SubElement(a, 'b')
1358 c = SubElement(a, 'c')
1359 d = SubElement(b, 'd')
1360 self.assertEquals(
1361 a,
1362 a.getroottree().getroot())
1363 self.assertEquals(
1364 a,
1365 b.getroottree().getroot())
1366 self.assertEquals(
1367 a,
1368 d.getroottree().getroot())
1369
1371 Element = self.etree.Element
1372 SubElement = self.etree.SubElement
1373
1374 a = Element('a')
1375 b = SubElement(a, 'b')
1376 c = SubElement(a, 'c')
1377 self.assertEquals(
1378 None,
1379 a.getnext())
1380 self.assertEquals(
1381 c,
1382 b.getnext())
1383 self.assertEquals(
1384 None,
1385 c.getnext())
1386
1388 Element = self.etree.Element
1389 SubElement = self.etree.SubElement
1390
1391 a = Element('a')
1392 b = SubElement(a, 'b')
1393 c = SubElement(a, 'c')
1394 d = SubElement(b, 'd')
1395 self.assertEquals(
1396 None,
1397 a.getprevious())
1398 self.assertEquals(
1399 b,
1400 c.getprevious())
1401 self.assertEquals(
1402 None,
1403 b.getprevious())
1404
1406 Element = self.etree.Element
1407 SubElement = self.etree.SubElement
1408
1409 a = Element('a')
1410 b = SubElement(a, 'b')
1411 c = SubElement(a, 'c')
1412 d = SubElement(b, 'd')
1413 self.assertEquals(
1414 [],
1415 list(a.itersiblings()))
1416 self.assertEquals(
1417 [c],
1418 list(b.itersiblings()))
1419 self.assertEquals(
1420 [],
1421 list(c.itersiblings()))
1422 self.assertEquals(
1423 [b],
1424 list(c.itersiblings(preceding=True)))
1425 self.assertEquals(
1426 [],
1427 list(b.itersiblings(preceding=True)))
1428
1430 Element = self.etree.Element
1431 SubElement = self.etree.SubElement
1432
1433 a = Element('a')
1434 b = SubElement(a, 'b')
1435 c = SubElement(a, 'c')
1436 d = SubElement(b, 'd')
1437 self.assertEquals(
1438 [],
1439 list(a.itersiblings(tag='XXX')))
1440 self.assertEquals(
1441 [c],
1442 list(b.itersiblings(tag='c')))
1443 self.assertEquals(
1444 [b],
1445 list(c.itersiblings(preceding=True, tag='b')))
1446 self.assertEquals(
1447 [],
1448 list(c.itersiblings(preceding=True, tag='c')))
1449
1451 parseid = self.etree.parseid
1452 XML = self.etree.XML
1453 xml_text = _bytes('''
1454 <!DOCTYPE document [
1455 <!ELEMENT document (h1,p)*>
1456 <!ELEMENT h1 (#PCDATA)>
1457 <!ATTLIST h1 myid ID #REQUIRED>
1458 <!ELEMENT p (#PCDATA)>
1459 <!ATTLIST p someid ID #REQUIRED>
1460 ]>
1461 <document>
1462 <h1 myid="chapter1">...</h1>
1463 <p id="note1" class="note">...</p>
1464 <p>Regular paragraph.</p>
1465 <p xml:id="xmlid">XML:ID paragraph.</p>
1466 <p someid="warn1" class="warning">...</p>
1467 </document>
1468 ''')
1469
1470 tree, dic = parseid(BytesIO(xml_text))
1471 root = tree.getroot()
1472 root2 = XML(xml_text)
1473 self.assertEquals(self._writeElement(root),
1474 self._writeElement(root2))
1475 expected = {
1476 "chapter1" : root[0],
1477 "xmlid" : root[3],
1478 "warn1" : root[4]
1479 }
1480 self.assert_("chapter1" in dic)
1481 self.assert_("warn1" in dic)
1482 self.assert_("xmlid" in dic)
1483 self._checkIDDict(dic, expected)
1484
1486 XMLDTDID = self.etree.XMLDTDID
1487 XML = self.etree.XML
1488 xml_text = _bytes('''
1489 <!DOCTYPE document [
1490 <!ELEMENT document (h1,p)*>
1491 <!ELEMENT h1 (#PCDATA)>
1492 <!ATTLIST h1 myid ID #REQUIRED>
1493 <!ELEMENT p (#PCDATA)>
1494 <!ATTLIST p someid ID #REQUIRED>
1495 ]>
1496 <document>
1497 <h1 myid="chapter1">...</h1>
1498 <p id="note1" class="note">...</p>
1499 <p>Regular paragraph.</p>
1500 <p xml:id="xmlid">XML:ID paragraph.</p>
1501 <p someid="warn1" class="warning">...</p>
1502 </document>
1503 ''')
1504
1505 root, dic = XMLDTDID(xml_text)
1506 root2 = XML(xml_text)
1507 self.assertEquals(self._writeElement(root),
1508 self._writeElement(root2))
1509 expected = {
1510 "chapter1" : root[0],
1511 "xmlid" : root[3],
1512 "warn1" : root[4]
1513 }
1514 self.assert_("chapter1" in dic)
1515 self.assert_("warn1" in dic)
1516 self.assert_("xmlid" in dic)
1517 self._checkIDDict(dic, expected)
1518
1520 XMLDTDID = self.etree.XMLDTDID
1521 XML = self.etree.XML
1522 xml_text = _bytes('''
1523 <document>
1524 <h1 myid="chapter1">...</h1>
1525 <p id="note1" class="note">...</p>
1526 <p>Regular paragraph.</p>
1527 <p someid="warn1" class="warning">...</p>
1528 </document>
1529 ''')
1530
1531 root, dic = XMLDTDID(xml_text)
1532 root2 = XML(xml_text)
1533 self.assertEquals(self._writeElement(root),
1534 self._writeElement(root2))
1535 expected = {}
1536 self._checkIDDict(dic, expected)
1537
1539 self.assertEquals(len(dic),
1540 len(expected))
1541 self.assertEquals(sorted(dic.items()),
1542 sorted(expected.items()))
1543 if sys.version_info < (3,):
1544 self.assertEquals(sorted(dic.iteritems()),
1545 sorted(expected.iteritems()))
1546 self.assertEquals(sorted(dic.keys()),
1547 sorted(expected.keys()))
1548 if sys.version_info < (3,):
1549 self.assertEquals(sorted(dic.iterkeys()),
1550 sorted(expected.iterkeys()))
1551 if sys.version_info < (3,):
1552 self.assertEquals(sorted(dic.values()),
1553 sorted(expected.values()))
1554 self.assertEquals(sorted(dic.itervalues()),
1555 sorted(expected.itervalues()))
1556
1558 etree = self.etree
1559
1560 r = {'foo': 'http://ns.infrae.com/foo'}
1561 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1562 self.assertEquals(
1563 'foo',
1564 e.prefix)
1565 self.assertEquals(
1566 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'),
1567 self._writeElement(e))
1568
1570 etree = self.etree
1571
1572 r = {None: 'http://ns.infrae.com/foo'}
1573 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1574 self.assertEquals(
1575 None,
1576 e.prefix)
1577 self.assertEquals(
1578 '{http://ns.infrae.com/foo}bar',
1579 e.tag)
1580 self.assertEquals(
1581 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'),
1582 self._writeElement(e))
1583
1585 etree = self.etree
1586
1587 r = {None: 'http://ns.infrae.com/foo',
1588 'hoi': 'http://ns.infrae.com/hoi'}
1589 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1590 e.set('{http://ns.infrae.com/hoi}test', 'value')
1591 self.assertEquals(
1592 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'),
1593 self._writeElement(e))
1594
1596 etree = self.etree
1597 r = {None: 'http://ns.infrae.com/foo',
1598 'hoi': 'http://ns.infrae.com/hoi'}
1599 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r)
1600 tree = etree.ElementTree(element=e)
1601 etree.SubElement(e, '{http://ns.infrae.com/hoi}x')
1602 self.assertEquals(
1603 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'),
1604 self._writeElement(e))
1605
1607 etree = self.etree
1608
1609 r = {None: 'http://ns.infrae.com/foo'}
1610 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1611 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1612
1613 e1.append(e2)
1614
1615 self.assertEquals(
1616 None,
1617 e1.prefix)
1618 self.assertEquals(
1619 None,
1620 e1[0].prefix)
1621 self.assertEquals(
1622 '{http://ns.infrae.com/foo}bar',
1623 e1.tag)
1624 self.assertEquals(
1625 '{http://ns.infrae.com/foo}bar',
1626 e1[0].tag)
1627
1629 etree = self.etree
1630
1631 r = {None: 'http://ns.infrae.com/BAR'}
1632 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r)
1633 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1634
1635 e1.append(e2)
1636
1637 self.assertEquals(
1638 None,
1639 e1.prefix)
1640 self.assertNotEquals(
1641 None,
1642 e2.prefix)
1643 self.assertEquals(
1644 '{http://ns.infrae.com/BAR}bar',
1645 e1.tag)
1646 self.assertEquals(
1647 '{http://ns.infrae.com/foo}bar',
1648 e2.tag)
1649
1651 ns_href = "http://a.b.c"
1652 one = self.etree.fromstring(
1653 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
1654 baz = one[0][0]
1655
1656 two = self.etree.fromstring(
1657 _bytes('<root xmlns:ns="%s"/>' % ns_href))
1658 two.append(baz)
1659 del one # make sure the source document is deallocated
1660
1661 self.assertEquals('{%s}baz' % ns_href, baz.tag)
1662 self.assertEquals(
1663 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href),
1664 self.etree.tostring(two))
1665
1667 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>')
1668 root = self.etree.fromstring(xml)
1669 self.assertEquals(xml,
1670 self.etree.tostring(root))
1671 self.etree.cleanup_namespaces(root)
1672 self.assertEquals(
1673 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'),
1674 self.etree.tostring(root))
1675
1677 etree = self.etree
1678
1679 r = {None: 'http://ns.infrae.com/foo',
1680 'hoi': 'http://ns.infrae.com/hoi'}
1681 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1682 self.assertEquals(
1683 r,
1684 e.nsmap)
1685
1687 etree = self.etree
1688
1689 re = {None: 'http://ns.infrae.com/foo',
1690 'hoi': 'http://ns.infrae.com/hoi'}
1691 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re)
1692
1693 rs = {None: 'http://ns.infrae.com/honk',
1694 'top': 'http://ns.infrae.com/top'}
1695 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs)
1696
1697 r = re.copy()
1698 r.update(rs)
1699 self.assertEquals(
1700 re,
1701 e.nsmap)
1702 self.assertEquals(
1703 r,
1704 s.nsmap)
1705
1707 Element = self.etree.Element
1708 SubElement = self.etree.SubElement
1709
1710 a = Element('{a}a')
1711 b = SubElement(a, '{a}b')
1712 c = SubElement(a, '{a}c')
1713 d = SubElement(b, '{b}d')
1714 e = SubElement(c, '{a}e')
1715 f = SubElement(c, '{b}f')
1716
1717 self.assertEquals(
1718 [a],
1719 list(a.getiterator('{a}a')))
1720 self.assertEquals(
1721 [],
1722 list(a.getiterator('{b}a')))
1723 self.assertEquals(
1724 [],
1725 list(a.getiterator('a')))
1726 self.assertEquals(
1727 [f],
1728 list(c.getiterator('{b}*')))
1729 self.assertEquals(
1730 [d, f],
1731 list(a.getiterator('{b}*')))
1732
1734 Element = self.etree.Element
1735 Entity = self.etree.Entity
1736 SubElement = self.etree.SubElement
1737
1738 a = Element('a')
1739 b = SubElement(a, 'b')
1740 entity_b = Entity("TEST-b")
1741 b.append(entity_b)
1742
1743 self.assertEquals(
1744 [entity_b],
1745 list(a.getiterator(Entity)))
1746
1747 entity_a = Entity("TEST-a")
1748 a.append(entity_a)
1749
1750 self.assertEquals(
1751 [entity_b, entity_a],
1752 list(a.getiterator(Entity)))
1753
1754 self.assertEquals(
1755 [entity_b],
1756 list(b.getiterator(Entity)))
1757
1759 Element = self.etree.Element
1760 Comment = self.etree.Comment
1761 PI = self.etree.PI
1762 SubElement = self.etree.SubElement
1763
1764 a = Element('a')
1765 b = SubElement(a, 'b')
1766 a.append(Comment("test"))
1767 a.append(PI("pi", "content"))
1768 c = SubElement(a, 'c')
1769
1770 self.assertEquals(
1771 [a, b, c],
1772 list(a.getiterator(Element)))
1773
1775 # ElementTree iterates over everything here
1776 Element = self.etree.Element
1777 Comment = self.etree.Comment
1778 PI = self.etree.PI
1779 SubElement = self.etree.SubElement
1780
1781 a = Element('a')
1782 b = SubElement(a, 'b')
1783 a.append(Comment("test"))
1784 a.append(PI("pi", "content"))
1785 c = SubElement(a, 'c')
1786
1787 self.assertEquals(
1788 [a, b, c],
1789 list(a.getiterator('*')))
1790
1792 XML = self.etree.XML
1793 ElementTree = self.etree.ElementTree
1794 QName = self.etree.QName
1795 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
1796 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])
1797
1799 XML = self.etree.XML
1800 ElementTree = self.etree.ElementTree
1801 QName = self.etree.QName
1802 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
1803 self.assertEquals(len(list(tree.findall(QName("c")))), 1)
1804
1806 XML = self.etree.XML
1807 ElementTree = self.etree.ElementTree
1808 QName = self.etree.QName
1809 tree = ElementTree(XML(
1810 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')))
1811 self.assertEquals(len(list(tree.findall(QName("b")))), 2)
1812 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)
1813
1815 XML = self.etree.XML
1816 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
1817 self.assertEquals(len(root.findall(".//{X}b")), 2)
1818 self.assertEquals(len(root.findall(".//{X}*")), 2)
1819 self.assertEquals(len(root.findall(".//b")), 3)
1820
1822 etree = self.etree
1823 e = etree.Element('foo')
1824 for i in range(10):
1825 etree.SubElement(e, 'a%s' % i)
1826 for i in range(10):
1827 self.assertEquals(
1828 i,
1829 e.index(e[i]))
1830 self.assertEquals(
1831 3, e.index(e[3], 3))
1832 self.assertRaises(
1833 ValueError, e.index, e[3], 4)
1834 self.assertRaises(
1835 ValueError, e.index, e[3], 0, 2)
1836 self.assertRaises(
1837 ValueError, e.index, e[8], 0, -3)
1838 self.assertRaises(
1839 ValueError, e.index, e[8], -5, -3)
1840 self.assertEquals(
1841 8, e.index(e[8], 0, -1))
1842 self.assertEquals(
1843 8, e.index(e[8], -12, -1))
1844 self.assertEquals(
1845 0, e.index(e[0], -12, -1))
1846
1848 etree = self.etree
1849 e = etree.Element('foo')
1850 for i in range(10):
1851 el = etree.SubElement(e, 'a%s' % i)
1852 el.text = "text%d" % i
1853 el.tail = "tail%d" % i
1854
1855 child0 = e[0]
1856 child1 = e[1]
1857 child2 = e[2]
1858
1859 e.replace(e[0], e[1])
1860 self.assertEquals(
1861 9, len(e))
1862 self.assertEquals(
1863 child1, e[0])
1864 self.assertEquals(
1865 child1.text, "text1")
1866 self.assertEquals(
1867 child1.tail, "tail1")
1868 self.assertEquals(
1869 child0.tail, "tail0")
1870 self.assertEquals(
1871 child2, e[1])
1872
1873 e.replace(e[-1], e[0])
1874 self.assertEquals(
1875 child1, e[-1])
1876 self.assertEquals(
1877 child1.text, "text1")
1878 self.assertEquals(
1879 child1.tail, "tail1")
1880 self.assertEquals(
1881 child2, e[0])
1882
1884 etree = self.etree
1885 e = etree.Element('foo')
1886 for i in range(10):
1887 etree.SubElement(e, 'a%s' % i)
1888
1889 new_element = etree.Element("test")
1890 new_element.text = "TESTTEXT"
1891 new_element.tail = "TESTTAIL"
1892 child1 = e[1]
1893 e.replace(e[0], new_element)
1894 self.assertEquals(
1895 new_element, e[0])
1896 self.assertEquals(
1897 "TESTTEXT",
1898 e[0].text)
1899 self.assertEquals(
1900 "TESTTAIL",
1901 e[0].tail)
1902 self.assertEquals(
1903 child1, e[1])
1904
1906 Element = self.etree.Element
1907 SubElement = self.etree.SubElement
1908
1909 a = Element('a')
1910
1911 e = Element('e')
1912 f = Element('f')
1913 g = Element('g')
1914
1915 s = [e, f, g]
1916 a[::-1] = s
1917 self.assertEquals(
1918 [g, f, e],
1919 list(a))
1920
1922 Element = self.etree.Element
1923 SubElement = self.etree.SubElement
1924
1925 a = Element('a')
1926 b = SubElement(a, 'b')
1927 c = SubElement(a, 'c')
1928 d = SubElement(a, 'd')
1929 e = SubElement(a, 'e')
1930
1931 x = Element('x')
1932 y = Element('y')
1933
1934 a[1::2] = [x, y]
1935 self.assertEquals(
1936 [b, x, d, y],
1937 list(a))
1938
1940 Element = self.etree.Element
1941 SubElement = self.etree.SubElement
1942
1943 a = Element('a')
1944 b = SubElement(a, 'b')
1945 c = SubElement(a, 'c')
1946 d = SubElement(a, 'd')
1947 e = SubElement(a, 'e')
1948
1949 x = Element('x')
1950 y = Element('y')
1951
1952 a[1::-1] = [x, y]
1953 self.assertEquals(
1954 [y, x, d, e],
1955 list(a))
1956
1958 Element = self.etree.Element
1959 SubElement = self.etree.SubElement
1960
1961 a = Element('a')
1962 b = SubElement(a, 'b')
1963 c = SubElement(a, 'c')
1964 d = SubElement(a, 'd')
1965 e = SubElement(a, 'e')
1966
1967 x = Element('x')
1968 y = Element('y')
1969
1970 a[::-2] = [x, y]
1971 self.assertEquals(
1972 [b, y, d, x],
1973 list(a))
1974
1976 Element = self.etree.Element
1977 SubElement = self.etree.SubElement
1978 try:
1979 slice
1980 except NameError:
1981 print("slice() not found")
1982 return
1983
1984 a = Element('a')
1985 b = SubElement(a, 'b')
1986 c = SubElement(a, 'c')
1987 d = SubElement(a, 'd')
1988 e = SubElement(a, 'e')
1989
1990 x = Element('x')
1991 y = Element('y')
1992 z = Element('z')
1993
1994 self.assertRaises(
1995 ValueError,
1996 operator.setitem, a, slice(1,None,2), [x, y, z])
1997
1998 self.assertEquals(
1999 [b, c, d, e],
2000 list(a))
2001
2003 XML = self.etree.XML
2004 root = XML(_bytes('''<?xml version="1.0"?>
2005 <root><test>
2006
2007 <bla/></test>
2008 </root>
2009 '''))
2010
2011 self.assertEquals(
2012 [2, 2, 4],
2013 [ el.sourceline for el in root.getiterator() ])
2014
2016 parse = self.etree.parse
2017 tree = parse(fileInTestDir('include/test_xinclude.xml'))
2018
2019 self.assertEquals(
2020 [1, 2, 3],
2021 [ el.sourceline for el in tree.getiterator() ])
2022
2024 iterparse = self.etree.iterparse
2025 lines = [ el.sourceline for (event, el) in
2026 iterparse(fileInTestDir('include/test_xinclude.xml')) ]
2027
2028 self.assertEquals(
2029 [2, 3, 1],
2030 lines)
2031
2033 iterparse = self.etree.iterparse
2034 lines = [ el.sourceline for (event, el) in
2035 iterparse(fileInTestDir('include/test_xinclude.xml'),
2036 events=("start",)) ]
2037
2038 self.assertEquals(
2039 [1, 2, 3],
2040 lines)
2041
2043 Element = self.etree.Element
2044 SubElement = self.etree.SubElement
2045 el = Element("test")
2046 self.assertEquals(None, el.sourceline)
2047
2048 child = SubElement(el, "test")
2049 self.assertEquals(None, el.sourceline)
2050 self.assertEquals(None, child.sourceline)
2051
2053 etree = self.etree
2054 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2055 docinfo = root.getroottree().docinfo
2056 self.assertEquals(docinfo.URL, "http://no/such/url")
2057
2059 etree = self.etree
2060 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2061 docinfo = root.getroottree().docinfo
2062 self.assertEquals(docinfo.URL, "http://no/such/url")
2063 docinfo.URL = "https://secret/url"
2064 self.assertEquals(docinfo.URL, "https://secret/url")
2065
2067 etree = self.etree
2068 tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url")
2069 docinfo = tree.docinfo
2070 self.assertEquals(docinfo.URL, "http://no/such/url")
2071
2073 etree = self.etree
2074 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2075 base_url="http://no/such/url")
2076 docinfo = tree.docinfo
2077 self.assertEquals(docinfo.URL, "http://no/such/url")
2078
2080 etree = self.etree
2081 root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url")
2082 docinfo = root.getroottree().docinfo
2083 self.assertEquals(docinfo.URL, "http://no/such/url")
2084
2086 etree = self.etree
2087 xml_header = '<?xml version="1.0" encoding="ascii"?>'
2088 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN"
2089 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
2090 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)
2091
2092 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2093
2094 tree = etree.parse(BytesIO(xml))
2095 docinfo = tree.docinfo
2096 self.assertEquals(docinfo.encoding, "ascii")
2097 self.assertEquals(docinfo.xml_version, "1.0")
2098 self.assertEquals(docinfo.public_id, pub_id)
2099 self.assertEquals(docinfo.system_url, sys_id)
2100 self.assertEquals(docinfo.root_name, 'html')
2101 self.assertEquals(docinfo.doctype, doctype_string)
2102
2104 etree = self.etree
2105 xml_header = '<?xml version="1.0" encoding="UTF-8"?>'
2106 sys_id = "some.dtd"
2107 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id
2108 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>')
2109
2110 tree = etree.parse(BytesIO(xml))
2111 docinfo = tree.docinfo
2112 self.assertEquals(docinfo.encoding, "UTF-8")
2113 self.assertEquals(docinfo.xml_version, "1.0")
2114 self.assertEquals(docinfo.public_id, None)
2115 self.assertEquals(docinfo.system_url, sys_id)
2116 self.assertEquals(docinfo.root_name, 'html')
2117 self.assertEquals(docinfo.doctype, doctype_string)
2118
2120 etree = self.etree
2121 xml = _bytes('<html><body></body></html>')
2122 tree = etree.parse(BytesIO(xml))
2123 docinfo = tree.docinfo
2124 self.assertEquals(docinfo.encoding, "UTF-8")
2125 self.assertEquals(docinfo.xml_version, "1.0")
2126 self.assertEquals(docinfo.public_id, None)
2127 self.assertEquals(docinfo.system_url, None)
2128 self.assertEquals(docinfo.root_name, 'html')
2129 self.assertEquals(docinfo.doctype, '')
2130
2132 etree = self.etree
2133 xml = _bytes('<!DOCTYPE root><root></root>')
2134 tree = etree.parse(BytesIO(xml))
2135 docinfo = tree.docinfo
2136 self.assertEquals(docinfo.encoding, "UTF-8")
2137 self.assertEquals(docinfo.xml_version, "1.0")
2138 self.assertEquals(docinfo.public_id, None)
2139 self.assertEquals(docinfo.system_url, None)
2140 self.assertEquals(docinfo.root_name, 'root')
2141 self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')
2142
2144 etree = self.etree
2145 xml = _bytes('<!DOCTYPE root>\n<root/>')
2146 tree = etree.parse(BytesIO(xml))
2147 self.assertEquals(xml, etree.tostring(tree))
2148
2150 etree = self.etree
2151 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2152 self.assertEquals(root.base, "http://no/such/url")
2153 self.assertEquals(
2154 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2155 root.base = "https://secret/url"
2156 self.assertEquals(root.base, "https://secret/url")
2157 self.assertEquals(
2158 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2159 "https://secret/url")
2160
2162 etree = self.etree
2163 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2164 self.assertEquals(root.base, "http://no/such/url")
2165 self.assertEquals(
2166 root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2167 root.set('{http://www.w3.org/XML/1998/namespace}base',
2168 "https://secret/url")
2169 self.assertEquals(root.base, "https://secret/url")
2170 self.assertEquals(
2171 root.get('{http://www.w3.org/XML/1998/namespace}base'),
2172 "https://secret/url")
2173
2175 etree = self.etree
2176 root = etree.HTML(_bytes("<html><body></body></html>"),
2177 base_url="http://no/such/url")
2178 self.assertEquals(root.base, "http://no/such/url")
2179
2181 etree = self.etree
2182 root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>'))
2183 self.assertEquals(root.base, "http://no/such/url")
2184
2186 # parse from a file object that returns unicode strings
2187 f = LargeFileLikeUnicode()
2188 tree = self.etree.parse(f)
2189 root = tree.getroot()
2190 self.assert_(root.tag.endswith('root'))
2191
2193 # check that DTDs that go in also go back out
2194 xml = _bytes('''\
2195 <!DOCTYPE test SYSTEM "test.dtd" [
2196 <!ENTITY entity "tasty">
2197 <!ELEMENT test (a)>
2198 <!ELEMENT a (#PCDATA)>
2199 ]>
2200 <test><a>test-test</a></test>\
2201 ''')
2202 tree = self.etree.parse(BytesIO(xml))
2203 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")),
2204 xml.replace(_bytes(" "), _bytes("")))
2205
2207 Element = self.etree.Element
2208
2209 a = Element('a')
2210 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho')
2211 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho')
2212
2213 self.assertRaises(ValueError, Element, 'ha\0ho')
2214
2216 Element = self.etree.Element
2217
2218 a = Element('a')
2219 self.assertRaises(ValueError, setattr, a, "text",
2220 _str('ha\0ho'))
2221 self.assertRaises(ValueError, setattr, a, "tail",
2222 _str('ha\0ho'))
2223
2224 self.assertRaises(ValueError, Element,
2225 _str('ha\0ho'))
2226
2228 Element = self.etree.Element
2229
2230 a = Element('a')
2231 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho')
2232 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho')
2233
2234 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho')
2235 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho')
2236
2237 self.assertRaises(ValueError, Element, 'ha\x07ho')
2238 self.assertRaises(ValueError, Element, 'ha\x02ho')
2239
2241 Element = self.etree.Element
2242
2243 a = Element('a')
2244 self.assertRaises(ValueError, setattr, a, "text",
2245 _str('ha\x07ho'))
2246 self.assertRaises(ValueError, setattr, a, "text",
2247 _str('ha\x02ho'))
2248
2249 self.assertRaises(ValueError, setattr, a, "tail",
2250 _str('ha\x07ho'))
2251 self.assertRaises(ValueError, setattr, a, "tail",
2252 _str('ha\x02ho'))
2253
2254 self.assertRaises(ValueError, Element,
2255 _str('ha\x07ho'))
2256 self.assertRaises(ValueError, Element,
2257 _str('ha\x02ho'))
2258
2260 # ElementTree fails to serialize this
2261 tostring = self.etree.tostring
2262 Element = self.etree.Element
2263 SubElement = self.etree.SubElement
2264
2265 a = Element('a')
2266 b = SubElement(a, 'b')
2267 c = SubElement(a, 'c')
2268
2269 result = tostring(a, encoding='UTF-16')
2270 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2271 canonicalize(result))
2272
2274 # ElementTree raises an AssertionError here
2275 tostring = self.etree.tostring
2276 self.assertRaises(TypeError, self.etree.tostring, None)
2277
2279 tostring = self.etree.tostring
2280 Element = self.etree.Element
2281 SubElement = self.etree.SubElement
2282
2283 a = Element('a')
2284 b = SubElement(a, 'b')
2285 c = SubElement(a, 'c')
2286
2287 result = tostring(a)
2288 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2289
2290 result = tostring(a, pretty_print=False)
2291 self.assertEquals(result, _bytes("<a><b/><c/></a>"))
2292
2293 result = tostring(a, pretty_print=True)
2294 self.assertEquals(result, _bytes("<a>\n <b/>\n <c/>\n</a>\n"))
2295
2297 tostring = self.etree.tostring
2298 Element = self.etree.Element
2299 SubElement = self.etree.SubElement
2300
2301 a = Element('a')
2302 a.tail = "aTAIL"
2303 b = SubElement(a, 'b')
2304 b.tail = "bTAIL"
2305 c = SubElement(a, 'c')
2306
2307 result = tostring(a)
2308 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2309
2310 result = tostring(a, with_tail=False)
2311 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>"))
2312
2313 result = tostring(a, with_tail=True)
2314 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2315
2317 tostring = self.etree.tostring
2318 XML = self.etree.XML
2319 ElementTree = self.etree.ElementTree
2320 Element = self.etree.Element
2321
2322 tree = Element("root").getroottree()
2323 self.assertEquals(None, tree.docinfo.standalone)
2324
2325 tree = XML(_bytes("<root/>")).getroottree()
2326 self.assertEquals(None, tree.docinfo.standalone)
2327
2328 tree = XML(_bytes(
2329 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"
2330 )).getroottree()
2331 self.assertEquals(True, tree.docinfo.standalone)
2332
2333 tree = XML(_bytes(
2334 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"
2335 )).getroottree()
2336 self.assertEquals(False, tree.docinfo.standalone)
2337
2339 tostring = self.etree.tostring
2340 XML = self.etree.XML
2341 ElementTree = self.etree.ElementTree
2342
2343 root = XML(_bytes("<root/>"))
2344
2345 tree = ElementTree(root)
2346 self.assertEquals(None, tree.docinfo.standalone)
2347
2348 result = tostring(root, xml_declaration=True, encoding="ASCII")
2349 self.assertEquals(result, _bytes(
2350 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2351
2352 result = tostring(root, xml_declaration=True, encoding="ASCII",
2353 standalone=True)
2354 self.assertEquals(result, _bytes(
2355 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2356
2357 tree = ElementTree(XML(result))
2358 self.assertEquals(True, tree.docinfo.standalone)
2359
2360 result = tostring(root, xml_declaration=True, encoding="ASCII",
2361 standalone=False)
2362 self.assertEquals(result, _bytes(
2363 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"))
2364
2365 tree = ElementTree(XML(result))
2366 self.assertEquals(False, tree.docinfo.standalone)
2367
2369 tostring = self.etree.tostring
2370 XML = self.etree.XML
2371 ElementTree = self.etree.ElementTree
2372
2373 root = XML(_bytes(
2374 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>"))
2375
2376 tree = ElementTree(root)
2377 self.assertEquals(True, tree.docinfo.standalone)
2378
2379 result = tostring(root, xml_declaration=True, encoding="ASCII")
2380 self.assertEquals(result, _bytes(
2381 "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2382
2383 result = tostring(root, xml_declaration=True, encoding="ASCII",
2384 standalone=True)
2385 self.assertEquals(result, _bytes(
2386 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2387
2389 tostring = self.etree.tostring
2390 Element = self.etree.Element
2391 SubElement = self.etree.SubElement
2392
2393 a = Element('a')
2394 a.text = "A"
2395 a.tail = "tail"
2396 b = SubElement(a, 'b')
2397 b.text = "B"
2398 b.tail = _str("Søk på nettet")
2399 c = SubElement(a, 'c')
2400 c.text = "C"
2401
2402 result = tostring(a, method="text", encoding="UTF-16")
2403
2404 self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"),
2405 result)
2406
2408 tostring = self.etree.tostring
2409 Element = self.etree.Element
2410 SubElement = self.etree.SubElement
2411
2412 a = Element('a')
2413 a.text = _str('Søk på nettetA')
2414 a.tail = "tail"
2415 b = SubElement(a, 'b')
2416 b.text = "B"
2417 b.tail = _str('Søk på nettetB')
2418 c = SubElement(a, 'c')
2419 c.text = "C"
2420
2421 self.assertRaises(UnicodeEncodeError,
2422 tostring, a, method="text")
2423
2424 self.assertEquals(
2425 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'),
2426 tostring(a, encoding="UTF-8", method="text"))
2427
2429 tounicode = self.etree.tounicode
2430 Element = self.etree.Element
2431 SubElement = self.etree.SubElement
2432
2433 a = Element('a')
2434 b = SubElement(a, 'b')
2435 c = SubElement(a, 'c')
2436
2437 self.assert_(isinstance(tounicode(a), _unicode))
2438 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2439 canonicalize(tounicode(a)))
2440
2442 tounicode = self.etree.tounicode
2443 Element = self.etree.Element
2444 SubElement = self.etree.SubElement
2445
2446 a = Element('a')
2447 b = SubElement(a, 'b')
2448 c = SubElement(a, 'c')
2449 d = SubElement(c, 'd')
2450 self.assert_(isinstance(tounicode(b), _unicode))
2451 self.assert_(isinstance(tounicode(c), _unicode))
2452 self.assertEquals(_bytes('<b></b>'),
2453 canonicalize(tounicode(b)))
2454 self.assertEquals(_bytes('<c><d></d></c>'),
2455 canonicalize(tounicode(c)))
2456
2460
2462 tounicode = self.etree.tounicode
2463 Element = self.etree.Element
2464 SubElement = self.etree.SubElement
2465
2466 a = Element('a')
2467 b = SubElement(a, 'b')
2468 c = SubElement(a, 'c')
2469 d = SubElement(c, 'd')
2470 b.tail = 'Foo'
2471
2472 self.assert_(isinstance(tounicode(b), _unicode))
2473 self.assert_(tounicode(b) == '<b/>Foo' or
2474 tounicode(b) == '<b />Foo')
2475
2477 tounicode = self.etree.tounicode
2478 Element = self.etree.Element
2479 SubElement = self.etree.SubElement
2480
2481 a = Element('a')
2482 b = SubElement(a, 'b')
2483 c = SubElement(a, 'c')
2484
2485 result = tounicode(a)
2486 self.assertEquals(result, "<a><b/><c/></a>")
2487
2488 result = tounicode(a, pretty_print=False)
2489 self.assertEquals(result, "<a><b/><c/></a>")
2490
2491 result = tounicode(a, pretty_print=True)
2492 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2493
2495 tostring = self.etree.tostring
2496 Element = self.etree.Element
2497 SubElement = self.etree.SubElement
2498
2499 a = Element('a')
2500 b = SubElement(a, 'b')
2501 c = SubElement(a, 'c')
2502
2503 self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode))
2504 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2505 canonicalize(tostring(a, encoding=_unicode)))
2506
2508 tostring = self.etree.tostring
2509 Element = self.etree.Element
2510 SubElement = self.etree.SubElement
2511
2512 a = Element('a')
2513 b = SubElement(a, 'b')
2514 c = SubElement(a, 'c')
2515 d = SubElement(c, 'd')
2516 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2517 self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode))
2518 self.assertEquals(_bytes('<b></b>'),
2519 canonicalize(tostring(b, encoding=_unicode)))
2520 self.assertEquals(_bytes('<c><d></d></c>'),
2521 canonicalize(tostring(c, encoding=_unicode)))
2522
2524 tostring = self.etree.tostring
2525 self.assertRaises(TypeError, self.etree.tostring,
2526 None, encoding=_unicode)
2527
2529 tostring = self.etree.tostring
2530 Element = self.etree.Element
2531 SubElement = self.etree.SubElement
2532
2533 a = Element('a')
2534 b = SubElement(a, 'b')
2535 c = SubElement(a, 'c')
2536 d = SubElement(c, 'd')
2537 b.tail = 'Foo'
2538
2539 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
2540 self.assert_(tostring(b, encoding=_unicode) == '<b/>Foo' or
2541 tostring(b, encoding=_unicode) == '<b />Foo')
2542
2544 tostring = self.etree.tostring
2545 Element = self.etree.Element
2546 SubElement = self.etree.SubElement
2547
2548 a = Element('a')
2549 b = SubElement(a, 'b')
2550 c = SubElement(a, 'c')
2551
2552 result = tostring(a, encoding=_unicode)
2553 self.assertEquals(result, "<a><b/><c/></a>")
2554
2555 result = tostring(a, encoding=_unicode, pretty_print=False)
2556 self.assertEquals(result, "<a><b/><c/></a>")
2557
2558 result = tostring(a, encoding=_unicode, pretty_print=True)
2559 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2560
2561 # helper methods
2562
2564 """Write out element for comparison.
2565 """
2566 ElementTree = self.etree.ElementTree
2567 f = BytesIO()
2568 tree = ElementTree(element=element)
2569 tree.write(f, encoding=encoding, compression=compression)
2570 data = f.getvalue()
2571 if compression:
2572 data = zlib.decompress(data)
2573 return canonicalize(data)
2574
2575
2578 filename = fileInTestDir('test_broken.xml')
2579 root = etree.XML(_bytes('''\
2580 <doc xmlns:xi="http://www.w3.org/2001/XInclude">
2581 <xi:include href="%s" parse="text"/>
2582 </doc>
2583 ''' % filename))
2584 old_text = root.text
2585 content = open(filename).read()
2586 old_tail = root[0].tail
2587
2588 self.include( etree.ElementTree(root) )
2589 self.assertEquals(old_text + content + old_tail,
2590 root.text)
2591
2593 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'))
2594 self.assertNotEquals(
2595 'a',
2596 tree.getroot()[1].tag)
2597 # process xincludes
2598 self.include( tree )
2599 # check whether we find it replaced with included data
2600 self.assertEquals(
2601 'a',
2602 tree.getroot()[1].tag)
2603
2605 class res(etree.Resolver):
2606 include_text = open(fileInTestDir('test.xml')).read()
2607 called = {}
2608 def resolve(self, url, id, context):
2609 if url.endswith(".dtd"):
2610 self.called["dtd"] = True
2611 return self.resolve_filename(
2612 fileInTestDir('test.dtd'), context)
2613 elif url.endswith("test_xinclude.xml"):
2614 self.called["input"] = True
2615 return None # delegate to default resolver
2616 else:
2617 self.called["include"] = True
2618 return self.resolve_string(self.include_text, context)
2619
2620 res_instance = res()
2621 parser = etree.XMLParser(load_dtd = True)
2622 parser.resolvers.add(res_instance)
2623
2624 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2625 parser = parser)
2626
2627 self.include(tree)
2628
2629 called = list(res_instance.called.items())
2630 called.sort()
2631 self.assertEquals(
2632 [("dtd", True), ("include", True), ("input", True)],
2633 called)
2634
2638
2639
2644
2645
2648 tree = self.parse(_bytes('<a><b/></a>'))
2649 f = BytesIO()
2650 tree.write_c14n(f)
2651 s = f.getvalue()
2652 self.assertEquals(_bytes('<a><b></b></a>'),
2653 s)
2654
2656 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2657 f = BytesIO()
2658 tree.write_c14n(f, compression=9)
2659 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read()
2660 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
2661 s)
2662
2664 tree = self.parse(_bytes('<a><b/></a>'))
2665 handle, filename = tempfile.mkstemp()
2666 try:
2667 tree.write_c14n(filename)
2668 f = open(filename, 'rb')
2669 data = f.read()
2670 f.close()
2671 finally:
2672 os.close(handle)
2673 os.remove(filename)
2674 self.assertEquals(_bytes('<a><b></b></a>'),
2675 data)
2676
2678 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2679 handle, filename = tempfile.mkstemp()
2680 try:
2681 tree.write_c14n(filename, compression=9)
2682 f = gzip.open(filename, 'rb')
2683 data = f.read()
2684 f.close()
2685 finally:
2686 os.close(handle)
2687 os.remove(filename)
2688 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
2689 data)
2690
2692 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
2693 f = BytesIO()
2694 tree.write_c14n(f)
2695 s = f.getvalue()
2696 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
2697 s)
2698 f = BytesIO()
2699 tree.write_c14n(f, with_comments=True)
2700 s = f.getvalue()
2701 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
2702 s)
2703 f = BytesIO()
2704 tree.write_c14n(f, with_comments=False)
2705 s = f.getvalue()
2706 self.assertEquals(_bytes('<a><b></b></a>'),
2707 s)
2708
2710 tree = self.parse(_bytes(
2711 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
2712 f = BytesIO()
2713 tree.write_c14n(f)
2714 s = f.getvalue()
2715 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
2716 s)
2717 f = BytesIO()
2718 tree.write_c14n(f, exclusive=False)
2719 s = f.getvalue()
2720 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
2721 s)
2722 f = BytesIO()
2723 tree.write_c14n(f, exclusive=True)
2724 s = f.getvalue()
2725 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
2726 s)
2727
2728
2731 tree = self.parse(_bytes('<a><b/></a>'))
2732 f = BytesIO()
2733 tree.write(f)
2734 s = f.getvalue()
2735 self.assertEquals(_bytes('<a><b/></a>'),
2736 s)
2737
2739 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2740 f = BytesIO()
2741 tree.write(f, compression=9)
2742 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read()
2743 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2744 s)
2745
2747 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2748 f = BytesIO()
2749 tree.write(f, compression=0)
2750 s0 = f.getvalue()
2751
2752 f = BytesIO()
2753 tree.write(f)
2754 self.assertEquals(f.getvalue(), s0)
2755
2756 f = BytesIO()
2757 tree.write(f, compression=1)
2758 s = f.getvalue()
2759 self.assert_(len(s) <= len(s0))
2760 s1 = gzip.GzipFile(fileobj=BytesIO(s)).read()
2761
2762 f = BytesIO()
2763 tree.write(f, compression=9)
2764 s = f.getvalue()
2765 self.assert_(len(s) <= len(s0))
2766 s9 = gzip.GzipFile(fileobj=BytesIO(s)).read()
2767
2768 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2769 s0)
2770 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2771 s1)
2772 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2773 s9)
2774
2776 tree = self.parse(_bytes('<a><b/></a>'))
2777 handle, filename = tempfile.mkstemp()
2778 try:
2779 tree.write(filename)
2780 f = open(filename, 'rb')
2781 data = f.read()
2782 f.close()
2783 finally:
2784 os.close(handle)
2785 os.remove(filename)
2786 self.assertEquals(_bytes('<a><b/></a>'),
2787 data)
2788
2790 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2791 handle, filename = tempfile.mkstemp()
2792 try:
2793 tree.write(filename, compression=9)
2794 f = gzip.open(filename, 'rb')
2795 data = f.read()
2796 f.close()
2797 finally:
2798 os.close(handle)
2799 os.remove(filename)
2800 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2801 data)
2802
2804 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2805 handle, filename = tempfile.mkstemp()
2806 try:
2807 tree.write(filename, compression=9)
2808 data = etree.tostring(etree.parse(filename))
2809 finally:
2810 os.close(handle)
2811 os.remove(filename)
2812 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2813 data)
2814
2816 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>'))
2817 handle, filename = tempfile.mkstemp()
2818 try:
2819 tree.write(filename, compression=9)
2820 data = etree.tostring(etree.parse(
2821 gzip.GzipFile(filename)))
2822 finally:
2823 os.close(handle)
2824 os.remove(filename)
2825 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
2826 data)
2827
2828
2830 suite = unittest.TestSuite()
2831 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)])
2832 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)])
2833 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)])
2834 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)])
2835 suite.addTests([unittest.makeSuite(ETreeWriteTestCase)])
2836 suite.addTests(
2837 [make_doctest('../../../doc/tutorial.txt')])
2838 suite.addTests(
2839 [make_doctest('../../../doc/api.txt')])
2840 suite.addTests(
2841 [make_doctest('../../../doc/FAQ.txt')])
2842 suite.addTests(
2843 [make_doctest('../../../doc/parsing.txt')])
2844 suite.addTests(
2845 [make_doctest('../../../doc/resolvers.txt')])
2846 return suite
2847
2848 if __name__ == '__main__':
2849 print('to test use test.py %s' % __file__)
2850
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0 on Tue Jun 2 22:04:01 2009 | http://epydoc.sourceforge.net |