| Home | Trees | Indices | Help |
|
|---|
|
|
1 # -*- coding: utf-8 -*-
2
3 """
4 Tests for the ElementTree API
5
6 Only test cases that apply equally well to etree and ElementTree
7 belong here. Note that there is a second test module called test_io.py
8 for IO related test cases.
9 """
10
11 import unittest
12 import os, re, tempfile, copy, operator, gc, sys
13
14 this_dir = os.path.dirname(__file__)
15 if this_dir not in sys.path:
16 sys.path.insert(0, this_dir) # needed for Py3
17
18 from common_imports import StringIO, BytesIO, etree, ElementTree, cElementTree
19 from common_imports import fileInTestDir, canonicalize, HelperTestCase
20 from common_imports import _str, _bytes
21
22 if cElementTree is not None:
23 if tuple([int(n) for n in
24 getattr(cElementTree, "VERSION", "0.0").split(".")]) <= (1,0,7):
25 cElementTree = None
26
27 try:
28 reversed
29 except NameError:
30 # Python 2.3
34
36 etree = None
37
39 for i in range(10):
40 e = self.etree.Element('foo')
41 self.assertEquals(e.tag, 'foo')
42 self.assertEquals(e.text, None)
43 self.assertEquals(e.tail, None)
44
46 Element = self.etree.Element
47
48 root = Element('root')
49 root.append(Element('one'))
50 root.append(Element('two'))
51 root.append(Element('three'))
52 self.assertEquals(3, len(root))
53 self.assertEquals('one', root[0].tag)
54 self.assertEquals('two', root[1].tag)
55 self.assertEquals('three', root[2].tag)
56 self.assertRaises(IndexError, operator.getitem, root, 3)
57
58 # test weird dictionary interaction leading to segfault previously
60 root = self.etree.Element('root')
61 self.assertEquals(root.tag, "root")
62 add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>'))
63 self.assertEquals(add.getroot().tag, "foo")
64 self.assertEquals(add.getroot().text, "Foo")
65 root.append(self.etree.Element('baz'))
66 self.assertEquals(root.tag, "root")
67 self.assertEquals(root[0].tag, "baz")
68
70 Element = self.etree.Element
71 SubElement = self.etree.SubElement
72
73 root = Element('root')
74 SubElement(root, 'one')
75 SubElement(root, 'two')
76 SubElement(root, 'three')
77 self.assertEquals(3, len(root))
78 self.assertEquals('one', root[0].tag)
79 self.assertEquals('two', root[1].tag)
80 self.assertEquals('three', root[2].tag)
81
83 Element = self.etree.Element
84 SubElement = self.etree.SubElement
85
86 root1 = Element('root')
87 SubElement(root1, 'one')
88 self.assert_(root1[0] in root1)
89
90 root2 = Element('root')
91 SubElement(root2, 'two')
92 SubElement(root2, 'three')
93 self.assert_(root2[0] in root2)
94 self.assert_(root2[1] in root2)
95
96 self.assertFalse(root1[0] in root2)
97 self.assertFalse(root2[0] in root1)
98 self.assertFalse(None in root2)
99
101 ElementTree = self.etree.ElementTree
102
103 f = BytesIO('<doc>Test<one>One</one></doc>')
104 doc = ElementTree(file=f)
105 root = doc.getroot()
106 self.assertEquals(1, len(root))
107 self.assertEquals('one', root[0].tag)
108 self.assertRaises(IndexError, operator.getitem, root, 1)
109
111 ElementTree = self.etree.ElementTree
112
113 f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
114 doc = ElementTree(file=f)
115 root = doc.getroot()
116 self.assertEquals(3, len(root))
117 self.assertEquals('one', root[0].tag)
118 self.assertEquals('two', root[1].tag)
119 self.assertEquals('three', root[2].tag)
120
122 ElementTree = self.etree.ElementTree
123
124 f = BytesIO('<doc>Test</doc>')
125 doc = ElementTree(file=f)
126 root = doc.getroot()
127 self.assertEquals(0, len(root))
128
130 Element = self.etree.Element
131 SubElement = self.etree.SubElement
132 a = Element('a')
133 b = SubElement(a, 'b')
134 c = SubElement(a, 'c')
135 d = SubElement(a, 'd')
136 self.assertEquals(d, a[-1])
137 self.assertEquals(c, a[-2])
138 self.assertEquals(b, a[-3])
139 self.assertRaises(IndexError, operator.getitem, a, -4)
140 a[-1] = e = Element('e')
141 self.assertEquals(e, a[-1])
142 del a[-1]
143 self.assertEquals(2, len(a))
144
146 ElementTree = self.etree.ElementTree
147
148 f = BytesIO('<doc><one>One</one><two>Two</two></doc>')
149 doc = ElementTree(file=f)
150 root = doc.getroot()
151 self.assertEquals(2, len(root))
152 self.assertEquals('one', root[0].tag)
153 self.assertEquals('two', root[1].tag)
154
156 ElementTree = self.etree.ElementTree
157
158 f = BytesIO('<doc>This is a text</doc>')
159 doc = ElementTree(file=f)
160 root = doc.getroot()
161 self.assertEquals('This is a text', root.text)
162
164 ElementTree = self.etree.ElementTree
165
166 f = BytesIO('<doc></doc>')
167 doc = ElementTree(file=f)
168 root = doc.getroot()
169 self.assertEquals(None, root.text)
170
172 ElementTree = self.etree.ElementTree
173
174 f = BytesIO('<doc><one>One</one></doc>')
175 doc = ElementTree(file=f)
176 root = doc.getroot()
177 self.assertEquals(None, root.text)
178 self.assertEquals('One', root[0].text)
179
181 ElementTree = self.etree.ElementTree
182
183 f = BytesIO('<doc>This is > than a text</doc>')
184 doc = ElementTree(file=f)
185 root = doc.getroot()
186 self.assertEquals('This is > than a text', root.text)
187
189 Element = self.etree.Element
190
191 a = Element("a")
192 a.text = "<>&"
193 self.assertXML(_bytes('<a><>&</a>'),
194 a)
195
197 tostring = self.etree.tostring
198 Element = self.etree.Element
199
200 a = Element("a")
201 a.text = "<>&"
202 self.assertEquals(_bytes('<a><>&</a>'),
203 tostring(a))
204
210
211 a = Element("a")
212 a.text = strTest("text")
213 self.assertXML(_bytes('<a>text</a>'),
214 a)
215
217 ElementTree = self.etree.ElementTree
218
219 f = BytesIO('<doc>This is <i>mixed</i> content.</doc>')
220 doc = ElementTree(file=f)
221 root = doc.getroot()
222 self.assertEquals(1, len(root))
223 self.assertEquals('This is ', root.text)
224 self.assertEquals(None, root.tail)
225 self.assertEquals('mixed', root[0].text)
226 self.assertEquals(' content.', root[0].tail)
227
229 Element = self.etree.Element
230 SubElement = self.etree.SubElement
231
232 class strTest(str):
233 pass
234
235 a = Element("a")
236 SubElement(a, "t").tail = strTest("tail")
237 self.assertXML(_bytes('<a><t></t>tail</a>'),
238 a)
239
241 # this is discouraged for ET compat, should not be tested...
242 XML = self.etree.XML
243
244 root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>'))
245 self.assertEquals(1, len(root))
246 self.assertEquals('This is ', root.text)
247 self.assertEquals(None, root.tail)
248 self.assertEquals('mixed', root[0].text)
249 self.assertEquals(' content.', root[0].tail)
250
251 del root[0].tail
252
253 self.assertEquals(1, len(root))
254 self.assertEquals('This is ', root.text)
255 self.assertEquals(None, root.tail)
256 self.assertEquals('mixed', root[0].text)
257 self.assertEquals(None, root[0].tail)
258
259 root[0].tail = "TAIL"
260
261 self.assertEquals(1, len(root))
262 self.assertEquals('This is ', root.text)
263 self.assertEquals(None, root.tail)
264 self.assertEquals('mixed', root[0].text)
265 self.assertEquals('TAIL', root[0].tail)
266
268 Element = self.etree.Element
269 ElementTree = self.etree.ElementTree
270
271 el = Element('hoi')
272 doc = ElementTree(el)
273 root = doc.getroot()
274 self.assertEquals(None, root.text)
275 self.assertEquals('hoi', root.tag)
276
278 ElementTree = self.etree.ElementTree
279
280 f = BytesIO('<doc one="One" two="Two"/>')
281 doc = ElementTree(file=f)
282 root = doc.getroot()
283 self.assertEquals('One', root.attrib['one'])
284 self.assertEquals('Two', root.attrib['two'])
285 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')
286
288 ElementTree = self.etree.ElementTree
289
290 f = BytesIO('<doc one="One" two="Two"/>')
291 doc = ElementTree(file=f)
292 root = doc.getroot()
293 self.assertEquals('One', root.attrib.get('one'))
294 self.assertEquals('Two', root.attrib.get('two'))
295 self.assertEquals(None, root.attrib.get('three'))
296 self.assertEquals('foo', root.attrib.get('three', 'foo'))
297
299 ElementTree = self.etree.ElementTree
300
301 f = BytesIO('<doc one="One" two="Two"/>')
302 doc = ElementTree(file=f)
303 root = doc.getroot()
304 self.assertEquals('One', root.get('one'))
305 self.assertEquals('Two', root.get('two'))
306 self.assertEquals(None, root.get('three'))
307 self.assertEquals('foo', root.get('three', 'foo'))
308
310 XML = self.etree.XML
311
312 root = XML(_bytes('<doc one="One" two="Two"/>'))
313 self.assertEquals('One', root.get('one'))
314 self.assertEquals('Two', root.get('two'))
315 root.attrib.clear()
316 self.assertEquals(None, root.get('one'))
317 self.assertEquals(None, root.get('two'))
318
320 Element = self.etree.Element
321
322 root = Element("root", one="One")
323 root.set("two", "Two")
324 self.assertEquals('One', root.get('one'))
325 self.assertEquals('Two', root.get('two'))
326 root.attrib.clear()
327 self.assertEquals(None, root.get('one'))
328 self.assertEquals(None, root.get('two'))
329
331 Element = self.etree.Element
332 SubElement = self.etree.SubElement
333
334 attribNS = '{http://foo/bar}x'
335
336 parent = Element('parent')
337 parent.set(attribNS, 'a')
338 child = SubElement(parent, 'child')
339 child.set(attribNS, 'b')
340
341 self.assertEquals('a', parent.get(attribNS))
342 self.assertEquals('b', child.get(attribNS))
343
344 parent.clear()
345 self.assertEquals(None, parent.get(attribNS))
346 self.assertEquals('b', child.get(attribNS))
347
349 ElementTree = self.etree.ElementTree
350
351 f = BytesIO('<doc one="One" two="Two"/>')
352 doc = ElementTree(file=f)
353 root = doc.getroot()
354 self.assertEquals('One', root.attrib['one'])
355 self.assertEquals('Two', root.attrib['two'])
356
357 self.assertEquals('One', root.attrib.pop('one'))
358
359 self.assertEquals(None, root.attrib.get('one'))
360 self.assertEquals('Two', root.attrib['two'])
361
363 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
364 self.assertRaises(KeyError, root.attrib.pop, 'NONE')
365
366 self.assertEquals('One', root.attrib['one'])
367 self.assertEquals('Two', root.attrib['two'])
368
370 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
371 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
372
374 root = self.etree.XML(_bytes('<doc/>'))
375 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
376
378 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
379 self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)
380
382 XML = self.etree.XML
383
384 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
385 items = list(root.attrib.items())
386 items.sort()
387 self.assertEquals(
388 [('alpha', 'Alpha'), ('beta', 'Beta')],
389 items)
390
391 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
392
393 items = list(root.attrib.items())
394 items.sort()
395 self.assertEquals(
396 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
397 items)
398
400 XML = self.etree.XML
401
402 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
403 items = list(root.attrib.items())
404 items.sort()
405 self.assertEquals(
406 [('alpha', 'Alpha'), ('beta', 'Beta')],
407 items)
408
409 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
410
411 items = list(root.attrib.items())
412 items.sort()
413 self.assertEquals(
414 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
415 items)
416
418 XML = self.etree.XML
419
420 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
421 items = list(root.attrib.items())
422 items.sort()
423 self.assertEquals(
424 [('alpha', 'Alpha'), ('beta', 'Beta')],
425 items)
426
427 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
428
429 items = list(root.attrib.items())
430 items.sort()
431 self.assertEquals(
432 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
433 items)
434
436 XML = self.etree.XML
437
438 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
439 keys = root.attrib.keys()
440 keys.sort()
441 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
442
444 XML = self.etree.XML
445
446 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
447 keys = root.keys()
448 keys.sort()
449 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
450
452 XML = self.etree.XML
453
454 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
455 items = list(root.items())
456 items.sort()
457 self.assertEquals(
458 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
459 items)
460
462 XML = self.etree.XML
463
464 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
465 keys = root.keys()
466 keys.sort()
467 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
468 keys)
469
471 XML = self.etree.XML
472
473 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
474 values = root.attrib.values()
475 values.sort()
476 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
477
479 XML = self.etree.XML
480
481 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
482 values = root.attrib.values()
483 values.sort()
484 self.assertEquals(
485 ['Bar', 'Baz'], values)
486
488 XML = self.etree.XML
489
490 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
491 items = list(root.attrib.items())
492 items.sort()
493 self.assertEquals([
494 ('alpha', 'Alpha'),
495 ('beta', 'Beta'),
496 ('gamma', 'Gamma'),
497 ],
498 items)
499
501 XML = self.etree.XML
502
503 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
504 items = list(root.attrib.items())
505 items.sort()
506 self.assertEquals(
507 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
508 items)
509
511 XML = self.etree.XML
512
513 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
514 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
515
516 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
517 try:
518 self.assertEquals(expected, str(root.attrib))
519 except AssertionError:
520 self.assertEquals(alternative, str(root.attrib))
521
523 XML = self.etree.XML
524
525 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
526 self.assertEquals(
527 True, root.attrib.has_key('bar'))
528 self.assertEquals(
529 False, root.attrib.has_key('baz'))
530 self.assertEquals(
531 False, root.attrib.has_key('hah'))
532 self.assertEquals(
533 True,
534 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
535
537 XML = self.etree.XML
538
539 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
540 self.assertEquals(
541 True, 'bar' in root.attrib)
542 self.assertEquals(
543 False, 'baz' in root.attrib)
544 self.assertEquals(
545 False, 'hah' in root.attrib)
546 self.assertEquals(
547 True,
548 '{http://ns.codespeak.net/test}baz' in root.attrib)
549
551 Element = self.etree.Element
552
553 root = Element("root")
554 root.set("attr", "TEST")
555 self.assertEquals("TEST", root.get("attr"))
556
558 Element = self.etree.Element
559
560 a = Element('a')
561 a.attrib['{http://a/}foo'] = 'Foo'
562 a.attrib['{http://a/}bar'] = 'Bar'
563 self.assertEquals(None, a.get('foo'))
564 self.assertEquals('Foo', a.get('{http://a/}foo'))
565 self.assertEquals('Foo', a.attrib['{http://a/}foo'])
566
567 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
568 self.assertEquals('Foo', a.attrib['{http://a/}foo'])
569
570 del a.attrib['{http://a/}foo']
571 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
572
574 XML = self.etree.XML
575
576 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />'))
577
578 self.assertEquals('Foo', a.attrib['foo'])
579 self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
580
581 del a.attrib['foo']
582 self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
583 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
584 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
585
586 del a.attrib['{http://a/}foo']
587 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
588 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
589
590 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />'))
591
592 self.assertEquals('Foo', a.attrib['foo'])
593 self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
594
595 del a.attrib['foo']
596 self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
597 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
598
599 del a.attrib['{http://a/}foo']
600 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
601 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
602
604 XML = self.etree.XML
605
606 root = XML(_bytes('<doc>This is a text.</doc>'))
607 self.assertEquals(0, len(root))
608 self.assertEquals('This is a text.', root.text)
609
611 XMLID = self.etree.XMLID
612 XML = self.etree.XML
613 xml_text = _bytes('''
614 <document>
615 <h1 id="chapter1">...</h1>
616 <p id="note1" class="note">...</p>
617 <p>Regular paragraph.</p>
618 <p xml:id="xmlid">XML:ID paragraph.</p>
619 <p id="warn1" class="warning">...</p>
620 </document>
621 ''')
622
623 root, dic = XMLID(xml_text)
624 root2 = XML(xml_text)
625 self.assertEquals(self._writeElement(root),
626 self._writeElement(root2))
627 expected = {
628 "chapter1" : root[0],
629 "note1" : root[1],
630 "warn1" : root[4]
631 }
632 self.assertEquals(dic, expected)
633
635 fromstring = self.etree.fromstring
636
637 root = fromstring('<doc>This is a text.</doc>')
638 self.assertEquals(0, len(root))
639 self.assertEquals('This is a text.', root.text)
640
642 fromstringlist = self.etree.fromstringlist
643
644 root = fromstringlist(["<do", "c>T", "hi", "s is",
645 " a text.<", "/doc", ">"])
646 self.assertEquals(0, len(root))
647 self.assertEquals('This is a text.', root.text)
648
650 fromstringlist = self.etree.fromstringlist
651
652 root = fromstringlist(list('<doc>This is a text.</doc>'))
653 self.assertEquals(0, len(root))
654 self.assertEquals('This is a text.', root.text)
655
657 fromstringlist = self.etree.fromstringlist
658
659 root = fromstringlist(['<doc>This is a text.</doc>'])
660 self.assertEquals(0, len(root))
661 self.assertEquals('This is a text.', root.text)
662
664 iselement = self.etree.iselement
665 Element = self.etree.Element
666 ElementTree = self.etree.ElementTree
667 XML = self.etree.XML
668 Comment = self.etree.Comment
669 ProcessingInstruction = self.etree.ProcessingInstruction
670
671 el = Element('hoi')
672 self.assert_(iselement(el))
673
674 el2 = XML(_bytes('<foo/>'))
675 self.assert_(iselement(el2))
676
677 tree = ElementTree(element=Element('dag'))
678 self.assert_(not iselement(tree))
679 self.assert_(iselement(tree.getroot()))
680
681 c = Comment('test')
682 self.assert_(iselement(c))
683
684 p = ProcessingInstruction("test", "some text")
685 self.assert_(iselement(p))
686
688 XML = self.etree.XML
689
690 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
691 result = []
692 for el in root:
693 result.append(el.tag)
694 self.assertEquals(['one', 'two', 'three'], result)
695
697 XML = self.etree.XML
698
699 root = XML(_bytes('<doc></doc>'))
700 result = []
701 for el in root:
702 result.append(el.tag)
703 self.assertEquals([], result)
704
706 XML = self.etree.XML
707
708 root = XML(_bytes('<doc>Text</doc>'))
709 result = []
710 for el in root:
711 result.append(el.tag)
712 self.assertEquals([], result)
713
715 # this would cause a crash in the past
716 fromstring = self.etree.fromstring
717 root = etree.fromstring('<html><p></p>x</html>')
718 for elem in root:
719 elem.tail = ''
720
722 XML = self.etree.XML
723 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
724 result = []
725 for el in reversed(root):
726 result.append(el.tag)
727 self.assertEquals(['three', 'two', 'one'], result)
728
730 XML = self.etree.XML
731
732 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
733 result = []
734 add = True
735 for el in root:
736 result.append(el.tag)
737 if add:
738 self.etree.SubElement(root, 'four')
739 add = False
740 self.assertEquals(['one', 'two', 'three', 'four'], result)
741
743 XML = self.etree.XML
744
745 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
746 result = []
747 for el in root:
748 result.append(el.tag)
749 del root[-1]
750 self.assertEquals(['one', 'two'], result)
751
753 XML = self.etree.XML
754
755 root = XML(_bytes('<doc><one/><two/></doc>'))
756 result = []
757 for el0 in root:
758 result.append(el0.tag)
759 for el1 in root:
760 result.append(el1.tag)
761 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
762
764 XML = self.etree.XML
765
766 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />'))
767 result = []
768 for key in root.attrib:
769 result.append(key)
770 result.sort()
771 self.assertEquals(['alpha', 'beta', 'gamma'], result)
772
774 # ET 1.3+
775 XML = self.etree.XML
776 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
777
778 text = list(root.itertext())
779 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"],
780 text)
781
783 # ET 1.3+
784 XML = self.etree.XML
785 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
786
787 text = list(root[2].itertext())
788 self.assertEquals(["CTEXT"],
789 text)
790
792 XML = self.etree.XML
793 root = XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))
794 self.assertEquals(len(list(root.findall("c"))), 1)
795 self.assertEquals(len(list(root.findall(".//c"))), 2)
796 self.assertEquals(len(list(root.findall(".//b"))), 3)
797 self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
798 self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
799 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
800
802 XML = self.etree.XML
803 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
804 self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
805 self.assertEquals(len(list(root.findall(".//b"))), 3)
806 self.assertEquals(len(list(root.findall("b"))), 2)
807
809 Element = self.etree.Element
810
811 el = Element('tag', foo='Foo', bar='Bar')
812 self.assertEquals('Foo', el.attrib['foo'])
813 self.assertEquals('Bar', el.attrib['bar'])
814
816 Element = self.etree.Element
817
818 el = Element('tag', {'foo':'Foo', 'bar':'Bar'})
819 self.assertEquals('Foo', el.attrib['foo'])
820 self.assertEquals('Bar', el.attrib['bar'])
821
823 Element = self.etree.Element
824
825 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
826 self.assertEquals('Foo', el.attrib['{ns1}foo'])
827 self.assertEquals('Bar', el.attrib['{ns2}bar'])
828
830 Element = self.etree.Element
831 SubElement = self.etree.SubElement
832
833 el = Element('tag')
834 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz")
835 self.assertEquals("Baz", el[0].attrib['baz'])
836 self.assertEquals('Foo', el[0].attrib['foo'])
837
839 Element = self.etree.Element
840 SubElement = self.etree.SubElement
841
842 el = Element('tag')
843 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
844 self.assertEquals('Foo', el[0].attrib['{ns1}foo'])
845 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])
846
848 ElementTree = self.etree.ElementTree
849 XML = self.etree.XML
850
851 for i in range(10):
852 f = BytesIO()
853 root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i)))
854 tree = ElementTree(element=root)
855 tree.write(f)
856 data = f.getvalue()
857 self.assertEquals(
858 _bytes('<doc%s>This is a test.</doc%s>' % (i, i)),
859 canonicalize(data))
860
862 ElementTree = self.etree.ElementTree
863 Element = self.etree.Element
864 SubElement = self.etree.SubElement
865
866 html = Element('html')
867 body = SubElement(html, 'body')
868 p = SubElement(body, 'p')
869 p.text = "html"
870 SubElement(p, 'br').tail = "test"
871
872 tree = ElementTree(element=html)
873 f = BytesIO()
874 tree.write(f, method="html")
875 data = f.getvalue().replace(_bytes('\n'),_bytes(''))
876
877 self.assertEquals(_bytes('<html><body><p>html<br>test</p></body></html>'),
878 data)
879
881 ElementTree = self.etree.ElementTree
882 Element = self.etree.Element
883 SubElement = self.etree.SubElement
884
885 a = Element('a')
886 a.text = "A"
887 a.tail = "tail"
888 b = SubElement(a, 'b')
889 b.text = "B"
890 b.tail = "TAIL"
891 c = SubElement(a, 'c')
892 c.text = "C"
893
894 tree = ElementTree(element=a)
895 f = BytesIO()
896 tree.write(f, method="text")
897 data = f.getvalue()
898
899 self.assertEquals(_bytes('ABTAILCtail'),
900 data)
901
903 ElementTree = self.etree.ElementTree
904 XML = self.etree.XML
905
906 tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) )
907 self.assertRaises(IOError, tree.write,
908 "definitely////\\-\\nonexisting\\-\\////FILE")
909
910 # this could trigger a crash, apparently because the document
911 # reference was prematurely garbage collected
913 Element = self.etree.Element
914
915 element = Element('tag')
916 for i in range(10):
917 element.attrib['key'] = 'value'
918 value = element.attrib['key']
919 self.assertEquals(value, 'value')
920
921 # from doctest; for some reason this caused crashes too
923 Element = self.etree.Element
924 ElementTree = self.etree.ElementTree
925
926 f = BytesIO()
927 for i in range(10):
928 element = Element('tag%s' % i)
929 self._check_element(element)
930 tree = ElementTree(element)
931 tree.write(f)
932 self._check_element_tree(tree)
933
935 Element = self.etree.Element
936 SubElement = self.etree.SubElement
937
938 el = Element('foo')
939 el2 = SubElement(el, 'bar')
940 el3 = SubElement(el2, 'baz')
941
942 al = Element('foo2')
943 al2 = SubElement(al, 'bar2')
944 al3 = SubElement(al2, 'baz2')
945
946 # now move al2 into el
947 el.append(al2)
948
949 # now change al3 directly
950 al3.text = 'baz2-modified'
951
952 # it should have changed through this route too
953 self.assertEquals(
954 'baz2-modified',
955 el[1][0].text)
956
958 Element = self.etree.Element
959 SubElement = self.etree.SubElement
960
961 a = Element('a')
962 b = SubElement(a, 'b')
963 a.text = 'hoi'
964 self.assertEquals(
965 'hoi',
966 a.text)
967 self.assertEquals(
968 'b',
969 a[0].tag)
970
972 Element = self.etree.Element
973 SubElement = self.etree.SubElement
974
975 a = Element('a')
976 a.text = 'hoi'
977 b = SubElement(a ,'b')
978 self.assertEquals(
979 'hoi',
980 a.text)
981 self.assertEquals(
982 'b',
983 a[0].tag)
984
986 Element = self.etree.Element
987
988 a = Element('a')
989
990 a.text = 'foo'
991 a.text = None
992
993 self.assertEquals(
994 None,
995 a.text)
996 self.assertXML(_bytes('<a></a>'), a)
997
999 Element = self.etree.Element
1000
1001 a = Element('a')
1002 self.assertEquals(None, a.text)
1003
1004 a.text = ''
1005 self.assertEquals('', a.text)
1006 self.assertXML(_bytes('<a></a>'), a)
1007
1009 Element = self.etree.Element
1010 SubElement = self.etree.SubElement
1011
1012 a = Element('a')
1013 a.tail = 'dag'
1014 self.assertEquals('dag',
1015 a.tail)
1016 b = SubElement(a, 'b')
1017 b.tail = 'hoi'
1018 self.assertEquals('hoi',
1019 b.tail)
1020 self.assertEquals('dag',
1021 a.tail)
1022
1024 Element = self.etree.Element
1025
1026 a = Element('a')
1027 b = Element('b')
1028 b.tail = 'b_tail'
1029 a.append(b)
1030 self.assertEquals('b_tail',
1031 b.tail)
1032
1034 Element = self.etree.Element
1035 SubElement = self.etree.SubElement
1036
1037 a = Element('a')
1038 b = SubElement(a, 'b')
1039 b.tail = 'foo'
1040 b.tail = 'bar'
1041 self.assertEquals('bar',
1042 b.tail)
1043 self.assertXML(_bytes('<a><b></b>bar</a>'), a)
1044
1046 Element = self.etree.Element
1047 a = Element('a')
1048 a.tail = 'foo'
1049 a.tail = None
1050 self.assertEquals(
1051 None,
1052 a.tail)
1053 self.assertXML(_bytes('<a></a>'), a)
1054
1056 root = self.etree.Element('foo')
1057 for i in range(3):
1058 element = self.etree.SubElement(root, 'a%s' % i)
1059 element.text = "text%d" % i
1060 element.tail = "tail%d" % i
1061
1062 elements = []
1063 for i in range(3):
1064 new_element = self.etree.Element("test%s" % i)
1065 new_element.text = "TEXT%s" % i
1066 new_element.tail = "TAIL%s" % i
1067 elements.append(new_element)
1068
1069 root.extend(elements)
1070
1071 self.assertEquals(
1072 ["a0", "a1", "a2", "test0", "test1", "test2"],
1073 [ el.tag for el in root ])
1074 self.assertEquals(
1075 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
1076 [ el.text for el in root ])
1077 self.assertEquals(
1078 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
1079 [ el.tail for el in root ])
1080
1082 Element = self.etree.Element
1083 SubElement = self.etree.SubElement
1084 Comment = self.etree.Comment
1085
1086 a = Element('a')
1087 a.append(Comment('foo'))
1088 self.assertEquals(a[0].tag, Comment)
1089 self.assertEquals(a[0].text, 'foo')
1090
1091 # ElementTree < 1.3 adds whitespace around comments
1093 Element = self.etree.Element
1094 SubElement = self.etree.SubElement
1095 Comment = self.etree.Comment
1096 tostring = self.etree.tostring
1097
1098 a = Element('a')
1099 a.append(Comment('foo'))
1100 self.assertEquals(a[0].text, 'foo')
1101
1102 self.assertEquals(
1103 _bytes('<a><!--foo--></a>'),
1104 tostring(a))
1105
1106 a[0].text = "TEST"
1107 self.assertEquals(a[0].text, 'TEST')
1108
1109 self.assertEquals(
1110 _bytes('<a><!--TEST--></a>'),
1111 tostring(a))
1112
1113 # ElementTree < 1.3 adds whitespace around comments
1115 Element = self.etree.Element
1116 SubElement = self.etree.SubElement
1117 Comment = self.etree.Comment
1118 tostring = self.etree.tostring
1119
1120 a = Element('a')
1121 a.append(Comment(' foo '))
1122 self.assertEquals(a[0].text, ' foo ')
1123 self.assertEquals(
1124 _bytes('<a><!-- foo --></a>'),
1125 tostring(a))
1126
1128 Comment = self.etree.Comment
1129 c = Comment('foo')
1130 self.assertEquals({}, c.attrib)
1131 self.assertEquals([], list(c.keys()))
1132 self.assertEquals([], list(c.items()))
1133 self.assertEquals(None, c.get('hoi'))
1134 self.assertEquals(0, len(c))
1135 # should not iterate
1136 for i in c:
1137 pass
1138
1140 # lxml.etree separates target and text
1141 Element = self.etree.Element
1142 SubElement = self.etree.SubElement
1143 ProcessingInstruction = self.etree.ProcessingInstruction
1144
1145 a = Element('a')
1146 a.append(ProcessingInstruction('foo', 'some more text'))
1147 self.assertEquals(a[0].tag, ProcessingInstruction)
1148 self.assertXML(_bytes("<a><?foo some more text?></a>"),
1149 a)
1150
1152 # lxml.etree separates target and text
1153 Element = self.etree.Element
1154 SubElement = self.etree.SubElement
1155 ProcessingInstruction = self.etree.PI
1156
1157 a = Element('a')
1158 a.append(ProcessingInstruction('foo', 'some more text'))
1159 self.assertEquals(a[0].tag, ProcessingInstruction)
1160 self.assertXML(_bytes("<a><?foo some more text?></a>"),
1161 a)
1162
1164 ProcessingInstruction = self.etree.ProcessingInstruction
1165 pi = ProcessingInstruction('foo')
1166 self.assertEquals({}, pi.attrib)
1167 self.assertEquals([], list(pi.keys()))
1168 self.assertEquals([], list(pi.items()))
1169 self.assertEquals(None, pi.get('hoi'))
1170 self.assertEquals(0, len(pi))
1171 # should not iterate
1172 for i in pi:
1173 pass
1174
1176 Element = self.etree.Element
1177 SubElement = self.etree.SubElement
1178
1179 a = Element('a')
1180 b = SubElement(a, 'b')
1181 c = Element('c')
1182 a[0] = c
1183 self.assertEquals(
1184 c,
1185 a[0])
1186 self.assertXML(_bytes('<a><c></c></a>'),
1187 a)
1188 self.assertXML(_bytes('<b></b>'),
1189 b)
1190
1192 Element = self.etree.Element
1193 SubElement = self.etree.SubElement
1194
1195 a = Element('a')
1196 for i in range(5):
1197 b = SubElement(a, 'b%s' % i)
1198 c = SubElement(b, 'c')
1199 for i in range(5):
1200 d = Element('d')
1201 e = SubElement(d, 'e')
1202 a[i] = d
1203 self.assertXML(
1204 _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'),
1205 a)
1206 self.assertXML(_bytes('<c></c>'),
1207 c)
1208
1210 Element = self.etree.Element
1211 SubElement = self.etree.SubElement
1212
1213 a = Element('a')
1214 SubElement(a, 'b')
1215 d = Element('d')
1216 a[0] = d
1217 self.assertXML(_bytes('<a><d></d></a>'), a)
1218
1220 Element = self.etree.Element
1221 SubElement = self.etree.SubElement
1222
1223 a = Element('a')
1224 b = SubElement(a, 'b')
1225
1226 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))
1227
1229 Element = self.etree.Element
1230 SubElement = self.etree.SubElement
1231
1232 a = Element('a')
1233 b = SubElement(a, 'b')
1234 b.tail = 'B2'
1235 c = Element('c')
1236 c.tail = 'C2'
1237
1238 a[0] = c
1239 self.assertXML(
1240 _bytes('<a><c></c>C2</a>'),
1241 a)
1242
1244 Element = self.etree.Element
1245 SubElement = self.etree.SubElement
1246
1247 a = Element('a')
1248 b = SubElement(a, 'b')
1249
1250 a.tag = 'c'
1251
1252 self.assertEquals(
1253 'c',
1254 a.tag)
1255
1256 self.assertXML(
1257 _bytes('<c><b></b></c>'),
1258 a)
1259
1261 Element = self.etree.Element
1262 SubElement = self.etree.SubElement
1263 tostring = self.etree.tostring
1264
1265 a = Element('{a}a')
1266 b1 = SubElement(a, '{a}b')
1267 b2 = SubElement(a, '{b}b')
1268
1269 self.assertEquals('{a}b', b1.tag)
1270
1271 b1.tag = 'c'
1272
1273 # can't use C14N here!
1274 self.assertEquals('c', b1.tag)
1275 self.assertEquals(_bytes('<c'), tostring(b1)[:2])
1276 self.assert_(_bytes('<c') in tostring(a))
1277
1279 Element = self.etree.Element
1280 SubElement = self.etree.SubElement
1281 tostring = self.etree.tostring
1282
1283 a = Element('{a}a')
1284 b1 = SubElement(a, '{a}b')
1285 b2 = SubElement(a, '{b}b')
1286
1287 a.tag = 'c'
1288
1289 self.assertEquals(
1290 'c',
1291 a.tag)
1292
1293 # can't use C14N here!
1294 self.assertEquals('c', a.tag)
1295 self.assertEquals(_bytes('<c'), tostring(a)[:2])
1296
1302
1303 a = Element("a")
1304 a.tag = strTest("TAG")
1305 self.assertXML(_bytes('<TAG></TAG>'),
1306 a)
1307
1309 Element = self.etree.Element
1310 SubElement = self.etree.SubElement
1311
1312 a = Element('a')
1313 b = SubElement(a, 'b')
1314 c = SubElement(a, 'c')
1315 d = SubElement(a, 'd')
1316
1317 del a[1]
1318 self.assertXML(
1319 _bytes('<a><b></b><d></d></a>'),
1320 a)
1321
1322 del a[0]
1323 self.assertXML(
1324 _bytes('<a><d></d></a>'),
1325 a)
1326
1327 del a[0]
1328 self.assertXML(
1329 _bytes('<a></a>'),
1330 a)
1331 # move deleted element into other tree afterwards
1332 other = Element('other')
1333 other.append(c)
1334 self.assertXML(
1335 _bytes('<other><c></c></other>'),
1336 other)
1337
1339 Element = self.etree.Element
1340 SubElement = self.etree.SubElement
1341
1342 a = Element('a')
1343 b = SubElement(a, 'b')
1344 bs = SubElement(b, 'bs')
1345 c = SubElement(a, 'c')
1346 cs = SubElement(c, 'cs')
1347
1348 el = a[0]
1349 self.assertXML(
1350 _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
1351 a)
1352 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1353 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1354
1355 del a[0]
1356 self.assertXML(
1357 _bytes('<a><c><cs></cs></c></a>'),
1358 a)
1359 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1360 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1361
1362 a.insert(0, el)
1363 self.assertXML(
1364 _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
1365 a)
1366 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1367 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1368
1370 Element = self.etree.Element
1371 SubElement = self.etree.SubElement
1372
1373 a = Element('a')
1374 b = SubElement(a, 'b')
1375 bs = SubElement(b, 'bs')
1376 c = SubElement(a, 'c')
1377 cs = SubElement(c, 'cs')
1378
1379 el = a[0]
1380 del a[0]
1381 a[0] = el
1382 self.assertXML(
1383 _bytes('<a><b><bs></bs></b></a>'),
1384 a)
1385 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1386 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1387
1389 Element = self.etree.Element
1390 SubElement = self.etree.SubElement
1391
1392 a = Element('a')
1393 b = SubElement(a, 'b')
1394 bs = SubElement(b, 'bs')
1395 c = SubElement(a, 'c')
1396 cs = SubElement(c, 'cs')
1397
1398 el = a[0]
1399 del a[0]
1400 a[0:0] = [el]
1401 self.assertXML(
1402 _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
1403 a)
1404 self.assertXML(_bytes('<b><bs></bs></b>'), b)
1405 self.assertXML(_bytes('<c><cs></cs></c>'), c)
1406
1408 XML = self.etree.XML
1409 a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
1410 b, c = a
1411
1412 a[:] = []
1413
1414 self.assertEquals("B2", b.tail)
1415 self.assertEquals("C2", c.tail)
1416
1418 XML = self.etree.XML
1419 root = XML(_bytes(
1420 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>'))
1421 root[:] = root.findall('.//puh') # delete bar from hierarchy
1422
1423 # previously, this lost a namespace declaration on bump2
1424 result = self.etree.tostring(root)
1425 foo = self.etree.fromstring(result)
1426
1427 self.assertEquals('puh', foo[0].tag)
1428 self.assertEquals('{http://huhu}bump1', foo[0][0].tag)
1429 self.assertEquals('{http://huhu}bump2', foo[0][1].tag)
1430
1432 ElementTree = self.etree.ElementTree
1433 f = BytesIO('<a><b></b>B2<c></c>C2</a>')
1434 doc = ElementTree(file=f)
1435 a = doc.getroot()
1436 del a[0]
1437 self.assertXML(
1438 _bytes('<a><c></c>C2</a>'),
1439 a)
1440
1442 Element = self.etree.Element
1443
1444 a = Element('a')
1445 a.text = 'foo'
1446 a.tail = 'bar'
1447 a.set('hoi', 'dag')
1448 a.clear()
1449 self.assertEquals(None, a.text)
1450 self.assertEquals(None, a.tail)
1451 self.assertEquals(None, a.get('hoi'))
1452 self.assertEquals('a', a.tag)
1453
1455 Element = self.etree.Element
1456 SubElement = self.etree.SubElement
1457
1458 a = Element('a')
1459 a.text = 'foo'
1460 a.tail = 'bar'
1461 a.set('hoi', 'dag')
1462 b = SubElement(a, 'b')
1463 c = SubElement(b, 'c')
1464 a.clear()
1465 self.assertEquals(None, a.text)
1466 self.assertEquals(None, a.tail)
1467 self.assertEquals(None, a.get('hoi'))
1468 self.assertEquals('a', a.tag)
1469 self.assertEquals(0, len(a))
1470 self.assertXML(_bytes('<a></a>'),
1471 a)
1472 self.assertXML(_bytes('<b><c></c></b>'),
1473 b)
1474
1476 ElementTree = self.etree.ElementTree
1477 f = BytesIO('<a><b></b>B2<c></c>C2</a>')
1478 doc = ElementTree(file=f)
1479 a = doc.getroot()
1480 a.clear()
1481 self.assertXML(
1482 _bytes('<a></a>'),
1483 a)
1484
1486 Element = self.etree.Element
1487 SubElement = self.etree.SubElement
1488
1489 a = Element('a')
1490 b = SubElement(a, 'b')
1491 c = SubElement(a, 'c')
1492 d = Element('d')
1493 a.insert(0, d)
1494
1495 self.assertEquals(
1496 d,
1497 a[0])
1498
1499 self.assertXML(
1500 _bytes('<a><d></d><b></b><c></c></a>'),
1501 a)
1502
1503 e = Element('e')
1504 a.insert(2, e)
1505 self.assertEquals(
1506 e,
1507 a[2])
1508 self.assertXML(
1509 _bytes('<a><d></d><b></b><e></e><c></c></a>'),
1510 a)
1511
1513 Element = self.etree.Element
1514 SubElement = self.etree.SubElement
1515
1516 a = Element('a')
1517 b = SubElement(a, 'b')
1518 c = Element('c')
1519
1520 a.insert(2, c)
1521 self.assertEquals(
1522 c,
1523 a[1])
1524 self.assertXML(
1525 _bytes('<a><b></b><c></c></a>'),
1526 a)
1527
1529 Element = self.etree.Element
1530 SubElement = self.etree.SubElement
1531
1532 a = Element('a')
1533 b = SubElement(a, 'b')
1534 c = SubElement(a, 'c')
1535
1536 d = Element('d')
1537 a.insert(-1, d)
1538 self.assertEquals(
1539 d,
1540 a[-2])
1541 self.assertXML(
1542 _bytes('<a><b></b><d></d><c></c></a>'),
1543 a)
1544
1546 Element = self.etree.Element
1547 SubElement = self.etree.SubElement
1548
1549 a = Element('a')
1550 b = SubElement(a, 'b')
1551
1552 c = Element('c')
1553 c.tail = 'C2'
1554
1555 a.insert(0, c)
1556 self.assertXML(
1557 _bytes('<a><c></c>C2<b></b></a>'),
1558 a)
1559
1561 Element = self.etree.Element
1562 SubElement = self.etree.SubElement
1563
1564 a = Element('a')
1565 b = SubElement(a, 'b')
1566 c = SubElement(a, 'c')
1567
1568 a.remove(b)
1569 self.assertEquals(
1570 c,
1571 a[0])
1572 self.assertXML(
1573 _bytes('<a><c></c></a>'),
1574 a)
1575
1577 Element = self.etree.Element
1578 SubElement = self.etree.SubElement
1579
1580 a = Element('{http://test}a')
1581 b = SubElement(a, '{http://test}b')
1582 c = SubElement(a, '{http://test}c')
1583
1584 a.remove(b)
1585 self.assertXML(
1586 _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'),
1587 a)
1588 self.assertXML(
1589 _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'),
1590 b)
1591
1593 Element = self.etree.Element
1594 SubElement = self.etree.SubElement
1595
1596 a = Element('a')
1597 b = SubElement(a, 'b')
1598 c = SubElement(a, 'c')
1599 d = Element('d')
1600 self.assertRaises(
1601 ValueError, a.remove, d)
1602
1604 Element = self.etree.Element
1605 SubElement = self.etree.SubElement
1606
1607 a = Element('a')
1608 b = SubElement(a, 'b')
1609 b.tail = 'b2'
1610 a.remove(b)
1611 self.assertXML(
1612 _bytes('<a></a>'),
1613 a)
1614 self.assertEquals('b2', b.tail)
1615
1617 Element = self.etree.Element
1618 SubElement = self.etree.SubElement
1619
1620 a = Element('a')
1621 b = SubElement(a, 'b')
1622 c = SubElement(a, 'c')
1623 d = SubElement(b, 'd')
1624 e = SubElement(c, 'e')
1625 self.assertXML(
1626 _bytes('<a><b><d></d></b><c><e></e></c></a>'),
1627 a)
1628 self.assertEquals(
1629 [b, c],
1630 a.getchildren())
1631 self.assertEquals(
1632 [d],
1633 b.getchildren())
1634 self.assertEquals(
1635 [],
1636 d.getchildren())
1637
1639 Element = self.etree.Element
1640
1641 a = Element('a')
1642 b = a.makeelement('c', {'hoi':'dag'})
1643 self.assertXML(
1644 _bytes('<c hoi="dag"></c>'),
1645 b)
1646
1648 Element = self.etree.Element
1649 SubElement = self.etree.SubElement
1650
1651 a = Element('a')
1652 b = SubElement(a, 'b')
1653 c = SubElement(a, 'c')
1654 d = SubElement(b, 'd')
1655 e = SubElement(c, 'e')
1656
1657 self.assertEquals(
1658 [a, b, d, c, e],
1659 list(a.iter()))
1660 self.assertEquals(
1661 [d],
1662 list(d.iter()))
1663
1665 Element = self.etree.Element
1666 SubElement = self.etree.SubElement
1667
1668 a = Element('a')
1669 b = SubElement(a, 'b')
1670 c = SubElement(a, 'c')
1671 d = SubElement(b, 'd')
1672 e = SubElement(c, 'e')
1673
1674 self.assertEquals(
1675 [a, b, d, c, e],
1676 list(a.getiterator()))
1677 self.assertEquals(
1678 [d],
1679 list(d.getiterator()))
1680
1682 Element = self.etree.Element
1683 SubElement = self.etree.SubElement
1684
1685 a = Element('a')
1686 b = SubElement(a, 'b')
1687 c = SubElement(a, 'c')
1688 d = SubElement(b, 'd')
1689 e = SubElement(c, 'e')
1690
1691 self.assertEquals(
1692 [],
1693 list(a.getiterator('none')))
1694 self.assertEquals(
1695 [],
1696 list(e.getiterator('none')))
1697 self.assertEquals(
1698 [e],
1699 list(e.getiterator()))
1700
1702 Element = self.etree.Element
1703 SubElement = self.etree.SubElement
1704
1705 a = Element('a')
1706 b = SubElement(a, 'b')
1707 c = SubElement(a, 'c')
1708 d = SubElement(b, 'd')
1709 e = SubElement(c, 'e')
1710
1711 self.assertEquals(
1712 [a],
1713 list(a.getiterator('a')))
1714 a2 = SubElement(e, 'a')
1715 self.assertEquals(
1716 [a, a2],
1717 list(a.getiterator('a')))
1718 self.assertEquals(
1719 [a2],
1720 list(c.getiterator('a')))
1721
1723 Element = self.etree.Element
1724 SubElement = self.etree.SubElement
1725
1726 a = Element('a')
1727 b = SubElement(a, 'b')
1728 c = SubElement(a, 'c')
1729 d = SubElement(b, 'd')
1730 e = SubElement(c, 'e')
1731
1732 self.assertEquals(
1733 [a, b, d, c, e],
1734 list(a.getiterator('*')))
1735
1737 Element = self.etree.Element
1738 Comment = self.etree.Comment
1739 SubElement = self.etree.SubElement
1740
1741 a = Element('a')
1742 b = SubElement(a, 'b')
1743 comment_b = Comment("TEST-b")
1744 b.append(comment_b)
1745
1746 self.assertEquals(
1747 [comment_b],
1748 list(a.getiterator(Comment)))
1749
1750 comment_a = Comment("TEST-a")
1751 a.append(comment_a)
1752
1753 self.assertEquals(
1754 [comment_b, comment_a],
1755 list(a.getiterator(Comment)))
1756
1757 self.assertEquals(
1758 [comment_b],
1759 list(b.getiterator(Comment)))
1760
1762 Element = self.etree.Element
1763 PI = self.etree.ProcessingInstruction
1764 SubElement = self.etree.SubElement
1765
1766 a = Element('a')
1767 b = SubElement(a, 'b')
1768 pi_b = PI("TEST-b")
1769 b.append(pi_b)
1770
1771 self.assertEquals(
1772 [pi_b],
1773 list(a.getiterator(PI)))
1774
1775 pi_a = PI("TEST-a")
1776 a.append(pi_a)
1777
1778 self.assertEquals(
1779 [pi_b, pi_a],
1780 list(a.getiterator(PI)))
1781
1782 self.assertEquals(
1783 [pi_b],
1784 list(b.getiterator(PI)))
1785
1787 Element = self.etree.Element
1788 SubElement = self.etree.SubElement
1789
1790 a = Element('a')
1791 a.text = 'a'
1792 b = SubElement(a, 'b')
1793 b.text = 'b'
1794 b.tail = 'b1'
1795 c = SubElement(a, 'c')
1796 c.text = 'c'
1797 c.tail = 'c1'
1798 d = SubElement(b, 'd')
1799 c.text = 'd'
1800 c.tail = 'd1'
1801 e = SubElement(c, 'e')
1802 e.text = 'e'
1803 e.tail = 'e1'
1804
1805 self.assertEquals(
1806 [a, b, d, c, e],
1807 list(a.getiterator()))
1808 #self.assertEquals(
1809 # [d],
1810 # list(d.getiterator()))
1811
1813 Element = self.etree.Element
1814 SubElement = self.etree.SubElement
1815
1816 a = Element('a')
1817 a.text = 'a'
1818 b = SubElement(a, 'b')
1819 b.text = 'b'
1820 b.tail = 'b1'
1821 c = SubElement(a, 'c')
1822 c.text = 'c'
1823 c.tail = 'c1'
1824 d = SubElement(b, 'd')
1825 c.text = 'd'
1826 c.tail = 'd1'
1827 e = SubElement(c, 'e')
1828 e.text = 'e'
1829 e.tail = 'e1'
1830
1831 self.assertEquals(
1832 [a],
1833 list(a.getiterator('a')))
1834 a2 = SubElement(e, 'a')
1835 self.assertEquals(
1836 [a, a2],
1837 list(a.getiterator('a')))
1838 self.assertEquals(
1839 [a2],
1840 list(e.getiterator('a')))
1841
1843 Element = self.etree.Element
1844
1845 a = Element('a')
1846 a.attrib['foo'] = 'Foo'
1847 a.attrib['bar'] = 'Bar'
1848 self.assertEquals('Foo', a.attrib['foo'])
1849 del a.attrib['foo']
1850 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
1851
1853 Element = self.etree.Element
1854 SubElement = self.etree.SubElement
1855
1856 a = Element('a')
1857 b = SubElement(a, 'b')
1858 c = SubElement(a, 'c')
1859 d = SubElement(a, 'd')
1860
1861 self.assertEquals(
1862 [b, c],
1863 a[0:2])
1864 self.assertEquals(
1865 [b, c, d],
1866 a[:])
1867 self.assertEquals(
1868 [b, c, d],
1869 a[:10])
1870 self.assertEquals(
1871 [b],
1872 a[0:1])
1873 self.assertEquals(
1874 [],
1875 a[10:12])
1876
1878 Element = self.etree.Element
1879 SubElement = self.etree.SubElement
1880
1881 a = Element('a')
1882 b = SubElement(a, 'b')
1883 c = SubElement(a, 'c')
1884 d = SubElement(a, 'd')
1885
1886 self.assertEquals(
1887 [d],
1888 a[-1:])
1889 self.assertEquals(
1890 [c, d],
1891 a[-2:])
1892 self.assertEquals(
1893 [c],
1894 a[-2:-1])
1895 self.assertEquals(
1896 [b, c],
1897 a[-3:-1])
1898 self.assertEquals(
1899 [b, c],
1900 a[-3:2])
1901
1903 Element = self.etree.Element
1904 SubElement = self.etree.SubElement
1905
1906 a = Element('a')
1907 b = SubElement(a, 'b')
1908 c = SubElement(a, 'c')
1909 d = SubElement(a, 'd')
1910 e = SubElement(a, 'e')
1911
1912 self.assertEquals(
1913 [e,d,c,b],
1914 a[::-1])
1915 self.assertEquals(
1916 [b,d],
1917 a[::2])
1918 self.assertEquals(
1919 [e,c],
1920 a[::-2])
1921 self.assertEquals(
1922 [d,c],
1923 a[-2:0:-1])
1924 self.assertEquals(
1925 [e],
1926 a[:1:-2])
1927
1929 ElementTree = self.etree.ElementTree
1930
1931 f = BytesIO('<a><b>B</b>B1<c>C</c>C1</a>')
1932 doc = ElementTree(file=f)
1933 a = doc.getroot()
1934 b = a[0]
1935 c = a[1]
1936 self.assertEquals(
1937 [b, c],
1938 a[:])
1939 self.assertEquals(
1940 [b],
1941 a[0:1])
1942 self.assertEquals(
1943 [c],
1944 a[1:])
1945
1947 Element = self.etree.Element
1948 Comment = self.etree.Comment
1949 SubElement = self.etree.SubElement
1950
1951 a = Element('a')
1952 b = SubElement(a, 'b')
1953 foo = Comment('foo')
1954 a.append(foo)
1955 c = SubElement(a, 'c')
1956 self.assertEquals(
1957 [b, foo, c],
1958 a[:])
1959 self.assertEquals(
1960 foo,
1961 a[1])
1962 a[1] = new = Element('new')
1963 self.assertEquals(
1964 new,
1965 a[1])
1966 self.assertXML(
1967 _bytes('<a><b></b><new></new><c></c></a>'),
1968 a)
1969
1971 Element = self.etree.Element
1972 SubElement = self.etree.SubElement
1973
1974 a = Element('a')
1975 b = SubElement(a, 'b')
1976 c = SubElement(a, 'c')
1977 d = SubElement(a, 'd')
1978 e = SubElement(a, 'e')
1979
1980 del a[1:3]
1981 self.assertEquals(
1982 [b, e],
1983 list(a))
1984
1986 Element = self.etree.Element
1987 SubElement = self.etree.SubElement
1988
1989 a = Element('a')
1990 b = SubElement(a, 'b')
1991 c = SubElement(a, 'c')
1992 d = SubElement(a, 'd')
1993 e = SubElement(a, 'e')
1994
1995 del a[1:-1]
1996 self.assertEquals(
1997 [b, e],
1998 list(a))
1999
2001 Element = self.etree.Element
2002 SubElement = self.etree.SubElement
2003
2004 a = Element('a')
2005 b = SubElement(a, 'b')
2006 c = SubElement(a, 'c')
2007 d = SubElement(a, 'd')
2008 e = SubElement(a, 'e')
2009
2010 del a[-3:-1]
2011 self.assertEquals(
2012 [b, e],
2013 list(a))
2014
2016 Element = self.etree.Element
2017 SubElement = self.etree.SubElement
2018
2019 a = Element('a')
2020 b = SubElement(a, 'b')
2021 c = SubElement(a, 'c')
2022 d = SubElement(a, 'd')
2023 e = SubElement(a, 'e')
2024
2025 del a[1::2]
2026 self.assertEquals(
2027 [b, d],
2028 list(a))
2029
2031 Element = self.etree.Element
2032 SubElement = self.etree.SubElement
2033
2034 a = Element('a')
2035 b = SubElement(a, 'b')
2036 c = SubElement(a, 'c')
2037 d = SubElement(a, 'd')
2038 e = SubElement(a, 'e')
2039
2040 del a[::-1]
2041 self.assertEquals(
2042 [],
2043 list(a))
2044
2046 Element = self.etree.Element
2047 SubElement = self.etree.SubElement
2048
2049 a = Element('a')
2050 b = SubElement(a, 'b')
2051 c = SubElement(a, 'c')
2052 d = SubElement(a, 'd')
2053 e = SubElement(a, 'e')
2054
2055 del a[::-2]
2056 self.assertEquals(
2057 [b, d],
2058 list(a))
2059
2061 ElementTree = self.etree.ElementTree
2062 f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
2063 doc = ElementTree(file=f)
2064 a = doc.getroot()
2065 del a[1:3]
2066 self.assertXML(
2067 _bytes('<a><b></b>B2<e></e>E2</a>'),
2068 a)
2069
2071 XML = self.etree.XML
2072 a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
2073 b, c = a
2074
2075 del a[:]
2076
2077 self.assertEquals("B2", b.tail)
2078 self.assertEquals("C2", c.tail)
2079
2081 # this could trigger a crash
2082 Element = self.etree.Element
2083 SubElement = self.etree.SubElement
2084 a = Element('a')
2085 b = SubElement(a, 'b')
2086 c = SubElement(b, 'c')
2087 del b # no more reference to b
2088 del a[:]
2089 self.assertEquals('c', c.tag)
2090
2092 Element = self.etree.Element
2093 SubElement = self.etree.SubElement
2094
2095 a = Element('a')
2096 b = SubElement(a, 'b')
2097 c = SubElement(a, 'c')
2098 d = SubElement(a, 'd')
2099
2100 e = Element('e')
2101 f = Element('f')
2102 g = Element('g')
2103
2104 s = [e, f, g]
2105 a[1:2] = s
2106 self.assertEquals(
2107 [b, e, f, g, d],
2108 list(a))
2109
2111 Element = self.etree.Element
2112 SubElement = self.etree.SubElement
2113
2114 a = Element('a')
2115 b = SubElement(a, 'b')
2116 c = SubElement(a, 'c')
2117
2118 e = Element('e')
2119 f = Element('f')
2120 g = Element('g')
2121
2122 s = [e, f, g]
2123 a[:] = s
2124 self.assertEquals(
2125 [e, f, g],
2126 list(a))
2127
2129 Element = self.etree.Element
2130 SubElement = self.etree.SubElement
2131
2132 a = Element('a')
2133
2134 e = Element('e')
2135 f = Element('f')
2136 g = Element('g')
2137
2138 s = [e, f, g]
2139 a[:] = s
2140 self.assertEquals(
2141 [e, f, g],
2142 list(a))
2143
2145 Element = self.etree.Element
2146 SubElement = self.etree.SubElement
2147
2148 a = Element('a')
2149 b = SubElement(a, 'b')
2150 c = SubElement(a, 'c')
2151 d = SubElement(a, 'd')
2152
2153 s = [b, c, d]
2154 a[:] = s
2155 self.assertEquals(
2156 [b, c, d],
2157 list(a))
2158
2160 Element = self.etree.Element
2161 SubElement = self.etree.SubElement
2162
2163 a = Element('a')
2164 b = SubElement(a, 'b')
2165 c = SubElement(a, 'c')
2166 d = SubElement(a, 'd')
2167
2168 s = [d, c, b]
2169 a[:] = s
2170 self.assertEquals(
2171 [d, c, b],
2172 list(a))
2173
2175 Element = self.etree.Element
2176 SubElement = self.etree.SubElement
2177
2178 a = Element('{ns}a')
2179 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
2180 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
2181 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
2182
2183 s = [d, c, b]
2184 a[:] = s
2185 self.assertEquals(
2186 [d, c, b],
2187 list(a))
2188 self.assertEquals(
2189 ['{ns}d', '{ns}c', '{ns}b'],
2190 [ child.tag for child in a ])
2191
2192 self.assertEquals(
2193 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
2194 [ child.attrib.keys() for child in a ])
2195
2197 Element = self.etree.Element
2198 SubElement = self.etree.SubElement
2199
2200 a = Element('{ns}a')
2201 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
2202 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
2203 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
2204
2205 s = [d, c, b]
2206 a[:] = s
2207 self.assertEquals(
2208 [d, c, b],
2209 list(a))
2210 self.assertEquals(
2211 ['{ns3}d', '{ns2}c', '{ns1}b'],
2212 [ child.tag for child in a ])
2213
2214 self.assertEquals(
2215 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
2216 [ child.attrib.keys() for child in a ])
2217
2219 Element = self.etree.Element
2220 SubElement = self.etree.SubElement
2221
2222 a = Element('a')
2223 b = SubElement(a, 'b')
2224 c = SubElement(a, 'c')
2225
2226 e = Element('e')
2227 f = Element('f')
2228 g = Element('g')
2229 h = Element('h')
2230
2231 s = [e, f]
2232 a[99:] = s
2233 self.assertEquals(
2234 [a, b, e, f],
2235 list(a))
2236
2237 s = [g, h]
2238 a[:0] = s
2239 self.assertEquals(
2240 [g, h, a, b, e, f],
2241 list(a))
2242
2244 Element = self.etree.Element
2245 SubElement = self.etree.SubElement
2246
2247 a = Element('a')
2248 b = SubElement(a, 'b')
2249 c = SubElement(a, 'c')
2250
2251 e = Element('e')
2252 f = Element('f')
2253
2254 s = [e]
2255 a[0:1] = s
2256 self.assertEquals(
2257 [e, c],
2258 list(a))
2259
2260 s = [f]
2261 a[1:2] = s
2262 self.assertEquals(
2263 [e, f],
2264 list(a))
2265
2267 ElementTree = self.etree.ElementTree
2268 Element = self.etree.Element
2269 f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
2270 doc = ElementTree(file=f)
2271 a = doc.getroot()
2272 x = Element('x')
2273 y = Element('y')
2274 z = Element('z')
2275 x.tail = 'X2'
2276 y.tail = 'Y2'
2277 z.tail = 'Z2'
2278 a[1:3] = [x, y, z]
2279 self.assertXML(
2280 _bytes('<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'),
2281 a)
2282
2284 Element = self.etree.Element
2285 SubElement = self.etree.SubElement
2286
2287 a = Element('a')
2288 b = SubElement(a, 'b')
2289 c = SubElement(a, 'c')
2290 d = SubElement(a, 'd')
2291
2292 x = Element('x')
2293 y = Element('y')
2294
2295 a[1:-1] = [x, y]
2296 self.assertEquals(
2297 [b, x, y, d],
2298 list(a))
2299
2301 Element = self.etree.Element
2302 SubElement = self.etree.SubElement
2303
2304 a = Element('a')
2305 b = SubElement(a, 'b')
2306 c = SubElement(a, 'c')
2307 d = SubElement(a, 'd')
2308
2309 x = Element('x')
2310 y = Element('y')
2311
2312 a[1:-2] = [x, y]
2313 self.assertEquals(
2314 [b, x, y, c, d],
2315 list(a))
2316
2318 Element = self.etree.Element
2319 SubElement = self.etree.SubElement
2320
2321 a = Element('a')
2322 b = SubElement(a, 'b')
2323 c = SubElement(a, 'c')
2324 d = SubElement(a, 'd')
2325
2326 e = Element('e')
2327 f = Element('f')
2328 g = Element('g')
2329
2330 s = [e, f, g]
2331 a[3:] = s
2332 self.assertEquals(
2333 [b, c, d, e, f, g],
2334 list(a))
2335
2337 Element = self.etree.Element
2338
2339 a = Element('a')
2340
2341 b = Element('b')
2342 c = Element('c')
2343
2344 a[:] = [b, c]
2345 self.assertEquals(
2346 [b, c],
2347 list(a))
2348
2350 Element = self.etree.Element
2351 ElementTree = self.etree.ElementTree
2352
2353 a = Element('a')
2354 a.tail = 'A2'
2355 t = ElementTree(element=a)
2356 self.assertEquals('A2',
2357 a.tail)
2358
2360 Element = self.etree.Element
2361 SubElement = self.etree.SubElement
2362 ElementTree = self.etree.ElementTree
2363
2364 a = Element('a')
2365 b = SubElement(a, 'b')
2366 c = SubElement(a, 'c')
2367 d = SubElement(b, 'd')
2368 e = SubElement(c, 'e')
2369 t = ElementTree(element=a)
2370
2371 self.assertEquals(
2372 [a, b, d, c, e],
2373 list(t.getiterator()))
2374
2376 Element = self.etree.Element
2377 SubElement = self.etree.SubElement
2378 ElementTree = self.etree.ElementTree
2379 a = Element('a')
2380 b = SubElement(a, 'b')
2381 c = SubElement(a, 'c')
2382 d = SubElement(b, 'd')
2383 e = SubElement(c, 'e')
2384 t = ElementTree(element=a)
2385
2386 self.assertEquals(
2387 [a],
2388 list(t.getiterator('a')))
2389 a2 = SubElement(e, 'a')
2390 self.assertEquals(
2391 [a, a2],
2392 list(t.getiterator('a')))
2393
2395 ElementTree = self.etree.ElementTree
2396 ns = 'http://xml.infrae.com/1'
2397 f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
2398 t = ElementTree(file=f)
2399 a = t.getroot()
2400 self.assertEquals('{%s}a' % ns,
2401 a.tag)
2402 self.assertEquals('{%s}b' % ns,
2403 a[0].tag)
2404
2406 ElementTree = self.etree.ElementTree
2407 ns = 'http://xml.infrae.com/1'
2408 ns2 = 'http://xml.infrae.com/2'
2409 f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2410 t = ElementTree(file=f)
2411 a = t.getroot()
2412 self.assertEquals('{%s}a' % ns,
2413 a.tag)
2414 self.assertEquals('{%s}b' % ns,
2415 a[0].tag)
2416 self.assertEquals('{%s}b' % ns2,
2417 a[1].tag)
2418
2420 Element = self.etree.Element
2421 SubElement = self.etree.SubElement
2422 ns = 'http://xml.infrae.com/1'
2423 ns2 = 'http://xml.infrae.com/2'
2424 a = Element('{%s}a' % ns)
2425 b = SubElement(a, '{%s}b' % ns2)
2426 c = SubElement(a, '{%s}c' % ns)
2427 self.assertEquals('{%s}a' % ns,
2428 a.tag)
2429 self.assertEquals('{%s}b' % ns2,
2430 b.tag)
2431 self.assertEquals('{%s}c' % ns,
2432 c.tag)
2433 self.assertEquals('{%s}a' % ns,
2434 a.tag)
2435 self.assertEquals('{%s}b' % ns2,
2436 b.tag)
2437 self.assertEquals('{%s}c' % ns,
2438 c.tag)
2439
2441 Element = self.etree.Element
2442 SubElement = self.etree.SubElement
2443 ElementTree = self.etree.ElementTree
2444
2445 ns = 'http://xml.infrae.com/1'
2446 ns2 = 'http://xml.infrae.com/2'
2447 f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2))
2448 t = ElementTree(file=f)
2449
2450 a = t.getroot()
2451 self.assertEquals('{%s}a' % ns,
2452 a.tag)
2453 self.assertEquals('{%s}b' % ns2,
2454 a[0].tag)
2455 self.assertEquals('{%s}b' % ns,
2456 a[1].tag)
2457
2459 Element = self.etree.Element
2460 ns = 'http://xml.infrae.com/1'
2461 ns2 = 'http://xml.infrae.com/2'
2462 a = Element('a')
2463 a.set('{%s}foo' % ns, 'Foo')
2464 a.set('{%s}bar' % ns2, 'Bar')
2465 self.assertEquals(
2466 'Foo',
2467 a.get('{%s}foo' % ns))
2468 self.assertEquals(
2469 'Bar',
2470 a.get('{%s}bar' % ns2))
2471 try:
2472 self.assertXML(
2473 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)),
2474 a)
2475 except AssertionError:
2476 self.assertXML(
2477 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)),
2478 a)
2479
2481 Element = self.etree.Element
2482 one = self.etree.fromstring(
2483 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
2484 baz = one[0][0]
2485
2486 two = Element('root')
2487 two.append(baz)
2488 # removing the originating document could cause a crash/error before
2489 # as namespace is not moved along with it
2490 del one, baz
2491 self.assertEquals('{http://a.b.c}baz', two[0].tag)
2492
2494 tostring = self.etree.tostring
2495 root = self.etree.XML(
2496 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
2497 baz = root[0][0]
2498
2499 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
2500 tostring(baz))
2501 self.assertEquals([_bytes("http://a.b.c")], nsdecl)
2502
2504 tostring = self.etree.tostring
2505 root = self.etree.XML(
2506 _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>'))
2507 baz = root[0][0]
2508
2509 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
2510 tostring(baz))
2511 self.assertEquals([_bytes("http://a.b.c")], nsdecl)
2512
2514 tostring = self.etree.tostring
2515 root = self.etree.XML(
2516 _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>'))
2517 baz = root[0][0]
2518
2519 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
2520 tostring(baz))
2521
2522 self.assertEquals([_bytes("http://a.b.c")], nsdecl)
2523
2525 Element = self.etree.Element
2526 SubElement = self.etree.SubElement
2527
2528 root = Element("foo")
2529 bar = SubElement(root, "{http://a.b.c}bar")
2530 baz = SubElement(bar, "{http://a.b.c}baz")
2531
2532 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
2533 self.etree.tostring(baz))
2534
2535 self.assertEquals([_bytes("http://a.b.c")], nsdecl)
2536
2538 Element = self.etree.Element
2539
2540 root = Element('element')
2541
2542 subelement = Element('subelement',
2543 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2544 self.assertEquals(1, len(subelement.attrib))
2545 self.assertEquals(
2546 "foo",
2547 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2548
2549 root.append(subelement)
2550 self.assertEquals(1, len(subelement.attrib))
2551 self.assertEquals(
2552 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()),
2553 list(subelement.attrib.items()))
2554 self.assertEquals(
2555 "foo",
2556 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2557
2559 parse = self.etree.parse
2560 tostring = self.etree.tostring
2561
2562 ns_href = "http://a.b.c"
2563 one = parse(
2564 BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
2565 baz = one.getroot()[0][0]
2566
2567 parsed = parse(BytesIO( tostring(baz) )).getroot()
2568 self.assertEquals('{%s}baz' % ns_href, parsed.tag)
2569
2571 tostring = self.etree.tostring
2572 Element = self.etree.Element
2573 SubElement = self.etree.SubElement
2574
2575 a = Element('a')
2576 b = SubElement(a, 'b')
2577 c = SubElement(a, 'c')
2578
2579 self.assertEquals(_bytes('<a><b></b><c></c></a>'),
2580 canonicalize(tostring(a)))
2581
2583 tostring = self.etree.tostring
2584 Element = self.etree.Element
2585 SubElement = self.etree.SubElement
2586
2587 a = Element('a')
2588 b = SubElement(a, 'b')
2589 c = SubElement(a, 'c')
2590 d = SubElement(c, 'd')
2591 self.assertEquals(_bytes('<b></b>'),
2592 canonicalize(tostring(b)))
2593 self.assertEquals(_bytes('<c><d></d></c>'),
2594 canonicalize(tostring(c)))
2595
2597 tostring = self.etree.tostring
2598 Element = self.etree.Element
2599 SubElement = self.etree.SubElement
2600
2601 a = Element('a')
2602 b = SubElement(a, 'b')
2603 c = SubElement(a, 'c')
2604 d = SubElement(c, 'd')
2605 b.tail = 'Foo'
2606
2607 self.assert_(tostring(b) == _bytes('<b/>Foo') or
2608 tostring(b) == _bytes('<b />Foo'))
2609
2611 tostring = self.etree.tostring
2612 Element = self.etree.Element
2613 SubElement = self.etree.SubElement
2614
2615 html = Element('html')
2616 body = SubElement(html, 'body')
2617 p = SubElement(body, 'p')
2618 p.text = "html"
2619 SubElement(p, 'br').tail = "test"
2620
2621 self.assertEquals(_bytes('<html><body><p>html<br>test</p></body></html>'),
2622 tostring(html, method="html"))
2623
2625 tostring = self.etree.tostring
2626 Element = self.etree.Element
2627 SubElement = self.etree.SubElement
2628
2629 a = Element('a')
2630 a.text = "A"
2631 a.tail = "tail"
2632 b = SubElement(a, 'b')
2633 b.text = "B"
2634 b.tail = "TAIL"
2635 c = SubElement(a, 'c')
2636 c.text = "C"
2637
2638 self.assertEquals(_bytes('ABTAILCtail'),
2639 tostring(a, method="text"))
2640
2642 iterparse = self.etree.iterparse
2643 f = BytesIO('<a><b></b><c/></a>')
2644
2645 iterator = iterparse(f)
2646 self.assertEquals(None,
2647 iterator.root)
2648 events = list(iterator)
2649 root = iterator.root
2650 self.assertEquals(
2651 [('end', root[0]), ('end', root[1]), ('end', root)],
2652 events)
2653
2655 iterparse = self.etree.iterparse
2656 iterator = iterparse(fileInTestDir("test.xml"))
2657 self.assertEquals(None,
2658 iterator.root)
2659 events = list(iterator)
2660 root = iterator.root
2661 self.assertEquals(
2662 [('end', root[0]), ('end', root)],
2663 events)
2664
2666 iterparse = self.etree.iterparse
2667 f = BytesIO('<a><b></b><c/></a>')
2668
2669 iterator = iterparse(f, events=('start',))
2670 events = list(iterator)
2671 root = iterator.root
2672 self.assertEquals(
2673 [('start', root), ('start', root[0]), ('start', root[1])],
2674 events)
2675
2677 iterparse = self.etree.iterparse
2678 f = BytesIO('<a><b></b><c/></a>')
2679
2680 iterator = iterparse(f, events=('start','end'))
2681 events = list(iterator)
2682 root = iterator.root
2683 self.assertEquals(
2684 [('start', root), ('start', root[0]), ('end', root[0]),
2685 ('start', root[1]), ('end', root[1]), ('end', root)],
2686 events)
2687
2689 iterparse = self.etree.iterparse
2690 f = BytesIO('<a><b></b><c/></a>')
2691
2692 iterator = iterparse(f)
2693 for event, elem in iterator:
2694 elem.clear()
2695
2696 root = iterator.root
2697 self.assertEquals(0,
2698 len(root))
2699
2701 iterparse = self.etree.iterparse
2702 CHILD_COUNT = 12345
2703 f = BytesIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
2704
2705 i = 0
2706 for key in iterparse(f):
2707 event, element = key
2708 i += 1
2709 self.assertEquals(i, CHILD_COUNT + 1)
2710
2712 iterparse = self.etree.iterparse
2713 f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>')
2714
2715 attr_name = '{http://testns/}bla'
2716 events = []
2717 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2718 for event, elem in iterator:
2719 events.append(event)
2720 if event == 'start':
2721 if elem.tag != '{http://ns1/}a':
2722 elem.set(attr_name, 'value')
2723
2724 self.assertEquals(
2725 ['start-ns', 'start', 'start', 'start-ns', 'start',
2726 'end', 'end-ns', 'end', 'end', 'end-ns'],
2727 events)
2728
2729 root = iterator.root
2730 self.assertEquals(
2731 None,
2732 root.get(attr_name))
2733 self.assertEquals(
2734 'value',
2735 root[0].get(attr_name))
2736
2738 iterparse = self.etree.iterparse
2739 f = BytesIO('<a><b><d/></b><c/></a>')
2740
2741 counts = []
2742 for event, elem in iterparse(f):
2743 counts.append(len(list(elem.getiterator())))
2744 self.assertEquals(
2745 [1,2,1,4],
2746 counts)
2747
2749 iterparse = self.etree.iterparse
2750 f = BytesIO('<a><b><d/></b><c/></a>')
2751
2752 for event, node in etree.iterparse(f): pass
2753
2754 root = etree.Element('new_root', {})
2755 root[:] = node[:]
2756
2757 self.assertEquals(
2758 ['b', 'c'],
2759 [ el.tag for el in root ])
2760
2762 tostring = self.etree.tostring
2763 f = BytesIO('<root><![CDATA[test]]></root>')
2764 context = self.etree.iterparse(f)
2765 content = [ el.text for event,el in context ]
2766
2767 self.assertEquals(['test'], content)
2768 self.assertEquals(_bytes('<root>test</root>'),
2769 tostring(context.root))
2770
2772 parse = self.etree.parse
2773 # from file
2774 tree = parse(fileInTestDir('test.xml'))
2775 self.assertXML(
2776 _bytes('<a><b></b></a>'),
2777 tree.getroot())
2778
2782
2786
2788 # ET < 1.3 raises ExpatError
2789 parse = self.etree.parse
2790 f = BytesIO('<a><b></c></b></a>')
2791 self.assertRaises(SyntaxError, parse, f)
2792 f.close()
2793
2795 parse = self.etree.parse
2796 # from file
2797 f = open(fileInTestDir('test_broken.xml'), 'rb')
2798 self.assertRaises(SyntaxError, parse, f)
2799 f.close()
2800
2802 parse = self.etree.parse
2803 # from file object
2804 f = open(fileInTestDir('test.xml'), 'rb')
2805 tree = parse(f)
2806 f.close()
2807 self.assertXML(
2808 _bytes('<a><b></b></a>'),
2809 tree.getroot())
2810
2812 parse = self.etree.parse
2813 f = BytesIO('<a><b></b></a>')
2814 tree = parse(f)
2815 f.close()
2816 self.assertXML(
2817 _bytes('<a><b></b></a>'),
2818 tree.getroot()
2819 )
2820
2822 tostring = self.etree.tostring
2823 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'))
2824
2825 self.assertEquals('test', root.text)
2826 self.assertEquals(_bytes('<root>test</root>'),
2827 tostring(root))
2828
2830 # this can fail in libxml2 <= 2.6.22
2831 parse = self.etree.parse
2832 tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2833 self.assertXML(_bytes('<html></html>'),
2834 tree.getroot())
2835
2837 Element = self.etree.Element
2838
2839 a = Element('a')
2840 a.text = _str('Søk på nettet')
2841 self.assertXML(
2842 _str('<a>Søk på nettet</a>').encode('UTF-8'),
2843 a, 'utf-8')
2844
2846 ElementTree = self.etree.ElementTree
2847 Element = self.etree.Element
2848
2849 a = Element('a')
2850 a.text = _str('Søk på nettet')
2851
2852 f = BytesIO()
2853 tree = ElementTree(element=a)
2854 tree.write(f, encoding='utf-8')
2855 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'),
2856 f.getvalue().replace(_bytes('\n'),_bytes('')))
2857
2859 parse = self.etree.parse
2860 # from file
2861 tree = parse(fileInTestDir('test-string.xml'))
2862 self.assertXML(
2863 _str('<a>Søk på nettet</a>').encode('UTF-8'),
2864 tree.getroot(), 'UTF-8')
2865
2867 parse = self.etree.parse
2868 # from file object
2869 f = open(fileInTestDir('test-string.xml'), 'rb')
2870 tree = parse(f)
2871 f.close()
2872 self.assertXML(
2873 _str('<a>Søk på nettet</a>').encode('UTF-8'),
2874 tree.getroot(), 'UTF-8')
2875
2877 ElementTree = self.etree.ElementTree
2878 Element = self.etree.Element
2879
2880 a = Element('a')
2881 a.text = _str('Søk på nettet')
2882
2883 f = BytesIO()
2884 tree = ElementTree(element=a)
2885 tree.write(f, encoding='iso-8859-1')
2886 result = f.getvalue()
2887 declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>")
2888 self.assertEncodingDeclaration(result, _bytes('iso-8859-1'))
2889 result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes(''))
2890 self.assertEquals(_str('<a>Søk på nettet</a>').encode('iso-8859-1'),
2891 result)
2892
2894 XMLParser = self.etree.XMLParser
2895
2896 text = _str('Søk på nettet')
2897 xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1')
2898
2899 self.assertRaises(self.etree.ParseError,
2900 self.etree.parse,
2901 BytesIO(xml_latin1))
2902
2903 tree = self.etree.parse(BytesIO(xml_latin1),
2904 XMLParser(encoding="iso-8859-1"))
2905 a = tree.getroot()
2906 self.assertEquals(a.text, text)
2907
2909 XMLParser = self.etree.XMLParser
2910
2911 text = _str('Søk på nettet')
2912 wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>")
2913 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
2914 ).encode('iso-8859-1')
2915
2916 self.assertRaises(self.etree.ParseError,
2917 self.etree.parse,
2918 BytesIO(xml_latin1))
2919
2920 tree = self.etree.parse(BytesIO(xml_latin1),
2921 XMLParser(encoding="iso-8859-1"))
2922 a = tree.getroot()
2923 self.assertEquals(a.text, text)
2924
2926 # raise error on wrong encoding declaration in unicode strings
2927 XML = self.etree.XML
2928 test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') +
2929 _str('<a>Søk på nettet</a>'))
2930 self.assertRaises(SyntaxError, XML, test_utf)
2931
2933 ElementTree = self.etree.ElementTree
2934 Element = self.etree.Element
2935
2936 a = Element('a')
2937 a.text = _str('Søk på nettet')
2938
2939 f = BytesIO()
2940 tree = ElementTree(element=a)
2941 tree.write(f)
2942 data = f.getvalue().replace(_bytes('\n'),_bytes(''))
2943 self.assertEquals(
2944 _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'),
2945 data)
2946
2948 Element = self.etree.Element
2949 tostring = self.etree.tostring
2950
2951 a = Element('a')
2952 a.text = _str('Søk på nettet')
2953 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'),
2954 tostring(a, encoding='utf-8'))
2955
2957 Element = self.etree.Element
2958 tostring = self.etree.tostring
2959
2960 a = Element('a')
2961 a.text = _str('Søk på nettet')
2962 self.assertRaises(LookupError, tostring, a,
2963 encoding='Invalid Encoding')
2964
2966 Element = self.etree.Element
2967 SubElement = self.etree.SubElement
2968 tostring = self.etree.tostring
2969
2970 a = Element('a')
2971 b = SubElement(a, 'b')
2972 b.text = _str('Søk på nettet')
2973 self.assertEquals(_str('<b>Søk på nettet</b>').encode('UTF-8'),
2974 tostring(b, encoding='utf-8'))
2975
2977 Element = self.etree.Element
2978 SubElement = self.etree.SubElement
2979 tostring = self.etree.tostring
2980
2981 a = Element('a')
2982 b = SubElement(a, 'b')
2983 b.text = _str('Søk på nettet')
2984 b.tail = _str('Søk')
2985 self.assertEquals(_str('<b>Søk på nettet</b>Søk').encode('UTF-8'),
2986 tostring(b, encoding='utf-8'))
2987
2989 Element = self.etree.Element
2990 SubElement = self.etree.SubElement
2991 tostring = self.etree.tostring
2992
2993 a = Element('a')
2994 a.text = _str('Søk på nettet')
2995
2996 expected = _bytes('<a>Søk på nettet</a>')
2997 self.assertEquals(
2998 expected,
2999 tostring(a))
3000
3002 Element = self.etree.Element
3003 SubElement = self.etree.SubElement
3004 tostring = self.etree.tostring
3005
3006 a = Element('a')
3007 b = SubElement(a, 'b')
3008 b.text = _str('Søk på nettet')
3009
3010 expected = _bytes('<b>Søk på nettet</b>')
3011 self.assertEquals(
3012 expected,
3013 tostring(b))
3014
3016 utext = _str('Søk på nettet')
3017 uxml = _str('<p>%s</p>') % utext
3018 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
3019 isoxml = prologue + uxml.encode('iso-8859-1')
3020 tree = self.etree.XML(isoxml)
3021 self.assertEquals(utext, tree.text)
3022
3024 utext = _str('Søk på nettet')
3025 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') +
3026 _str('<p>%s</p>') % utext)
3027 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1")
3028 xml = bom + uxml.encode("utf-8")
3029 tree = etree.XML(xml)
3030 self.assertEquals(utext, tree.text)
3031
3033 utext = _str('Søk på nettet')
3034 uxml = _str('<p>%s</p>') % utext
3035 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
3036 isoxml = prologue + uxml.encode('iso-8859-1')
3037 el = self.etree.parse(BytesIO(isoxml)).getroot()
3038 self.assertEquals(utext, el.text)
3039
3041 Element = self.etree.Element
3042 ElementTree = self.etree.ElementTree
3043
3044 a = Element('a')
3045 a.text = "Foo"
3046 atree = ElementTree(a)
3047
3048 btree = copy.deepcopy(atree)
3049 self.assertEqual("Foo", atree.getroot().text)
3050 self.assertEqual("Foo", btree.getroot().text)
3051 self.assertFalse(btree is atree)
3052 self.assertFalse(btree.getroot() is atree.getroot())
3053
3055 Element = self.etree.Element
3056
3057 a = Element('a')
3058 a.text = 'Foo'
3059
3060 b = copy.deepcopy(a)
3061 self.assertEquals('Foo', b.text)
3062
3063 b.text = 'Bar'
3064 self.assertEquals('Bar', b.text)
3065 self.assertEquals('Foo', a.text)
3066
3067 del a
3068 self.assertEquals('Bar', b.text)
3069
3071 Element = self.etree.Element
3072
3073 a = Element('a')
3074 a.tail = 'Foo'
3075
3076 b = copy.deepcopy(a)
3077 self.assertEquals('Foo', b.tail)
3078
3079 b.tail = 'Bar'
3080 self.assertEquals('Bar', b.tail)
3081 self.assertEquals('Foo', a.tail)
3082
3083 del a
3084 self.assertEquals('Bar', b.tail)
3085
3087 Element = self.etree.Element
3088 SubElement = self.etree.SubElement
3089
3090 root = Element('root')
3091 a = SubElement(root, 'a')
3092 a.text = 'FooText'
3093 a.tail = 'FooTail'
3094
3095 b = copy.deepcopy(a)
3096 self.assertEquals('FooText', b.text)
3097 self.assertEquals('FooTail', b.tail)
3098
3099 b.text = 'BarText'
3100 b.tail = 'BarTail'
3101 self.assertEquals('BarTail', b.tail)
3102 self.assertEquals('FooTail', a.tail)
3103 self.assertEquals('BarText', b.text)
3104 self.assertEquals('FooText', a.text)
3105
3106 del a
3107 self.assertEquals('BarTail', b.tail)
3108 self.assertEquals('BarText', b.text)
3109
3111 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns">
3112 <parent><node t:foo="bar" /></parent>
3113 </doc>'''))
3114 self.assertEquals(
3115 root[0][0].get('{tns}foo'),
3116 copy.deepcopy(root[0])[0].get('{tns}foo') )
3117 self.assertEquals(
3118 root[0][0].get('{tns}foo'),
3119 copy.deepcopy(root[0][0]).get('{tns}foo') )
3120
3122 # previously caused a crash
3123 Element = self.etree.Element
3124 tostring = self.etree.tostring
3125
3126 a = Element('a')
3127 b = copy.deepcopy(a)
3128 a.append( Element('C') )
3129 b.append( Element('X') )
3130
3131 self.assertEquals(_bytes('<a><C/></a>'),
3132 tostring(a).replace(_bytes(' '), _bytes('')))
3133 self.assertEquals(_bytes('<a><X/></a>'),
3134 tostring(b).replace(_bytes(' '), _bytes('')))
3135
3137 # previously caused a crash
3138 # not supported by ET < 1.3!
3139 Comment = self.etree.Comment
3140
3141 a = Comment("ONE")
3142 b = copy.deepcopy(a)
3143 b.text = "ANOTHER"
3144
3145 self.assertEquals('ONE', a.text)
3146 self.assertEquals('ANOTHER', b.text)
3147
3149 Element = self.etree.Element
3150
3151 a = Element('a')
3152 a.text = 'Foo'
3153
3154 b = copy.copy(a)
3155 self.assertEquals('Foo', b.text)
3156
3157 b.text = 'Bar'
3158 self.assertEquals('Bar', b.text)
3159 self.assertEquals('Foo', a.text)
3160 # XXX ElementTree will share nodes, but lxml.etree won't..
3161
3163 Element = self.etree.Element
3164 ElementTree = self.etree.ElementTree
3165
3166 a = Element('a')
3167 a.text = 'Foo'
3168 atree = ElementTree(a)
3169
3170 btree = copy.copy(atree)
3171 self.assertFalse(btree is atree)
3172 self.assert_(btree.getroot() is atree.getroot())
3173 self.assertEquals('Foo', atree.getroot().text)
3174
3176 # deprecated as of ET 1.3/lxml 2.0
3177 etree = self.etree
3178 e = etree.Element('foo')
3179 self.assertEquals(False, bool(e))
3180 etree.SubElement(e, 'bar')
3181 self.assertEquals(True, bool(e))
3182 e = etree.Element('foo')
3183 e.text = 'hey'
3184 self.assertEquals(False, bool(e))
3185 e = etree.Element('foo')
3186 e.tail = 'bar'
3187 self.assertEquals(False, bool(e))
3188 e = etree.Element('foo')
3189 e.set('bar', 'Bar')
3190 self.assertEquals(False, bool(e))
3191
3193 etree = self.etree
3194
3195 a = etree.Element('a')
3196 b = etree.SubElement(a, 'b')
3197
3198 t = etree.ElementTree(a)
3199 self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3200
3201 t1 = etree.ElementTree(a)
3202 self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
3203 self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3204
3205 t2 = etree.ElementTree(b)
3206 self.assertEquals(self._rootstring(t2), _bytes('<b/>'))
3207 self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
3208 self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3209
3211 etree = self.etree
3212 qname = etree.QName('myns', 'a')
3213 a1 = etree.Element(qname)
3214 a2 = etree.SubElement(a1, qname)
3215 self.assertEquals(a1.tag, "{myns}a")
3216 self.assertEquals(a2.tag, "{myns}a")
3217
3219 etree = self.etree
3220 qname1 = etree.QName('myns', 'a')
3221 qname2 = etree.QName('myns', 'a')
3222 self.assertEquals(qname1, "{myns}a")
3223 self.assertEquals("{myns}a", qname2)
3224 self.assertEquals(qname1, qname1)
3225 self.assertEquals(qname1, qname2)
3226
3228 etree = self.etree
3229 qname = etree.QName('myns', 'a')
3230
3231 a = etree.Element(qname)
3232 a.set(qname, "value")
3233
3234 self.assertEquals(a.get(qname), "value")
3235 self.assertEquals(a.get("{myns}a"), "value")
3236
3238 etree = self.etree
3239 qname = etree.QName('myns', 'a')
3240
3241 a = etree.Element(qname)
3242 a.attrib[qname] = "value"
3243
3244 self.assertEquals(a.attrib[qname], "value")
3245 self.assertEquals(a.attrib.get(qname), "value")
3246
3247 self.assertEquals(a.attrib["{myns}a"], "value")
3248 self.assertEquals(a.attrib.get("{myns}a"), "value")
3249
3251 etree = self.etree
3252 qname = etree.QName('http://myns', 'a')
3253 a = etree.Element(qname)
3254 a.set(qname, qname)
3255
3256 self.assertXML(
3257 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'),
3258 a)
3259
3261 etree = self.etree
3262 qname = etree.QName('http://myns', 'a')
3263 a = etree.Element('a')
3264 a.set('a', qname)
3265
3266 self.assertXML(
3267 _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'),
3268 a)
3269
3271 etree = self.etree
3272 qname = etree.QName('http://myns', 'a')
3273 a = etree.Element(qname)
3274 a.attrib[qname] = qname
3275
3276 self.assertXML(
3277 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'),
3278 a)
3279
3281 etree = self.etree
3282 parser = etree.XMLParser()
3283 if hasattr(parser, "version"):
3284 # ElementTree 1.3+, cET
3285 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))
3286
3287 # feed parser interface
3288
3290 parser = self.etree.XMLParser()
3291
3292 parser.feed('<?xml version=')
3293 parser.feed('"1.0"?><ro')
3294 parser.feed('ot><')
3295 parser.feed('a test="works"/')
3296 parser.feed('></root')
3297 parser.feed('>')
3298
3299 root = parser.close()
3300
3301 self.assertEquals(root.tag, "root")
3302 self.assertEquals(root[0].tag, "a")
3303 self.assertEquals(root[0].get("test"), "works")
3304
3306 ParseError = self.etree.ParseError
3307 parser = self.etree.XMLParser()
3308 self.assertRaises(ParseError, parser.close)
3309
3311 ParseError = self.etree.ParseError
3312 parser = self.etree.XMLParser()
3313
3314 parser.feed('<?xml version=')
3315 parser.feed('"1.0"?><ro')
3316
3317 self.assertRaises(ParseError, parser.close)
3318
3320 ParseError = self.etree.ParseError
3321 parser = self.etree.XMLParser()
3322
3323 parser.feed('<?xml version=')
3324 parser.feed('"1.0"?><ro')
3325 try:
3326 parser.feed('<><><><><><><')
3327 except ParseError:
3328 # can raise, but not required before close()
3329 pass
3330
3331 self.assertRaises(ParseError, parser.close)
3332
3334 ParseError = self.etree.ParseError
3335 parser = self.etree.XMLParser()
3336 try:
3337 parser.close()
3338 except ParseError:
3339 e = sys.exc_info()[1]
3340 self.assertNotEquals(None, e.code)
3341 self.assertNotEquals(0, e.code)
3342 self.assert_(isinstance(e.position, tuple))
3343 self.assert_(e.position >= (0, 0))
3344
3345 # parser target interface
3346
3348 assertEquals = self.assertEquals
3349 assertFalse = self.assertFalse
3350
3351 events = []
3352 class Target(object):
3353 def start(self, tag, attrib):
3354 events.append("start")
3355 assertFalse(attrib)
3356 assertEquals("TAG", tag)
3357 def end(self, tag):
3358 events.append("end")
3359 assertEquals("TAG", tag)
3360 def close(self):
3361 return "DONE"
3362
3363 parser = self.etree.XMLParser(target=Target())
3364
3365 parser.feed("<TAG/>")
3366 done = parser.close()
3367
3368 self.assertEquals("DONE", done)
3369 self.assertEquals(["start", "end"], events)
3370
3372 assertEquals = self.assertEquals
3373 assertFalse = self.assertFalse
3374 Element = self.etree.Element
3375
3376 events = []
3377 class Target(object):
3378 def start(self, tag, attrib):
3379 events.append("start")
3380 assertFalse(attrib)
3381 assertEquals("TAG", tag)
3382 def end(self, tag):
3383 events.append("end")
3384 assertEquals("TAG", tag)
3385 def close(self):
3386 return Element("DONE")
3387
3388 parser = self.etree.XMLParser(target=Target())
3389 tree = self.etree.ElementTree()
3390 tree.parse(BytesIO("<TAG/>"), parser=parser)
3391
3392 self.assertEquals("DONE", tree.getroot().tag)
3393 self.assertEquals(["start", "end"], events)
3394
3396 assertEquals = self.assertEquals
3397
3398 events = []
3399 class Target(object):
3400 def start(self, tag, attrib):
3401 events.append("start-" + tag)
3402 for name, value in attrib.items():
3403 assertEquals(tag + name, value)
3404 def end(self, tag):
3405 events.append("end-" + tag)
3406 def close(self):
3407 return "DONE"
3408
3409 parser = self.etree.XMLParser(target=Target())
3410
3411 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3412 done = parser.close()
3413
3414 self.assertEquals("DONE", done)
3415 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3416 events)
3417
3419 events = []
3420 class Target(object):
3421 def start(self, tag, attrib):
3422 events.append("start-" + tag)
3423 def end(self, tag):
3424 events.append("end-" + tag)
3425 def data(self, data):
3426 events.append("data-" + data)
3427 def close(self):
3428 return "DONE"
3429
3430 parser = self.etree.XMLParser(target=Target())
3431
3432 parser.feed('<root>A<sub/>B</root>')
3433 done = parser.close()
3434
3435 self.assertEquals("DONE", done)
3436 self.assertEquals(["start-root", "data-A", "start-sub",
3437 "end-sub", "data-B", "end-root"],
3438 events)
3439
3445 def _flush_data(self):
3446 if self._data:
3447 events.append("data-" + ''.join(self._data))
3448 del self._data[:]
3449 def start(self, tag, attrib):
3450 self._flush_data()
3451 events.append("start-" + tag)
3452 def end(self, tag):
3453 self._flush_data()
3454 events.append("end-" + tag)
3455 def data(self, data):
3456 self._data.append(data)
3457 def close(self):
3458 self._flush_data()
3459 return "DONE"
3460
3461 parser = self.etree.XMLParser(target=Target())
3462
3463 dtd = '''
3464 <!DOCTYPE root [
3465 <!ELEMENT root (sub*)>
3466 <!ELEMENT sub (#PCDATA)>
3467 <!ENTITY ent "an entity">
3468 ]>
3469 '''
3470 parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
3471 done = parser.close()
3472
3473 self.assertEquals("DONE", done)
3474 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
3475 "data-this is an entity",
3476 "end-sub", "start-sub", "end-sub", "end-root"],
3477 events)
3478
3484 def _flush_data(self):
3485 if self._data:
3486 events.append("data-" + ''.join(self._data))
3487 del self._data[:]
3488 def start(self, tag, attrib):
3489 self._flush_data()
3490 events.append("start-" + tag)
3491 def end(self, tag):
3492 self._flush_data()
3493 events.append("end-" + tag)
3494 def data(self, data):
3495 self._data.append(data)
3496 def close(self):
3497 self._flush_data()
3498 return "DONE"
3499
3500 parser = self.etree.XMLParser(target=Target())
3501
3502 def feed():
3503 parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
3504 parser.close()
3505
3506 self.assertRaises(self.etree.ParseError, feed)
3507
3509 events = []
3510 class Target(object):
3511 def start(self, tag, attrib):
3512 events.append("start-" + tag)
3513 def end(self, tag):
3514 events.append("end-" + tag)
3515 if tag == 'a':
3516 raise ValueError("dead and gone")
3517 def data(self, data):
3518 events.append("data-" + data)
3519 def close(self):
3520 events.append("close")
3521 return "DONE"
3522
3523 parser = self.etree.XMLParser(target=Target())
3524
3525 try:
3526 parser.feed(_bytes('<root>A<a>ca</a>B</root>'))
3527 done = parser.close()
3528 self.fail("error expected, but parsing succeeded")
3529 except ValueError:
3530 done = 'value error received as expected'
3531
3532 self.assertEquals(["start-root", "data-A", "start-a",
3533 "data-ca", "end-a"],
3534 events)
3535
3537 events = []
3538 class Target(object):
3539 def start(self, tag, attrib):
3540 events.append("start-" + tag)
3541 def end(self, tag):
3542 events.append("end-" + tag)
3543 if tag == 'a':
3544 raise ValueError("dead and gone")
3545 def data(self, data):
3546 events.append("data-" + data)
3547 def close(self):
3548 events.append("close")
3549 return "DONE"
3550
3551 parser = self.etree.XMLParser(target=Target())
3552
3553 try:
3554 done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'),
3555 parser=parser)
3556 self.fail("error expected, but parsing succeeded")
3557 except ValueError:
3558 done = 'value error received as expected'
3559
3560 self.assertEquals(["start-root", "data-A", "start-a",
3561 "data-ca", "end-a"],
3562 events)
3563
3565 builder = self.etree.TreeBuilder()
3566 el = builder.start("root", {'a':'A', 'b':'B'})
3567 self.assertEquals("root", el.tag)
3568 self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3569 builder.data("ROOTTEXT")
3570 el = builder.start("child", {'x':'X', 'y':'Y'})
3571 self.assertEquals("child", el.tag)
3572 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3573 builder.data("CHILDTEXT")
3574 el = builder.end("child")
3575 self.assertEquals("child", el.tag)
3576 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3577 self.assertEquals("CHILDTEXT", el.text)
3578 self.assertEquals(None, el.tail)
3579 builder.data("CHILDTAIL")
3580 root = builder.end("root")
3581
3582 self.assertEquals("root", root.tag)
3583 self.assertEquals("ROOTTEXT", root.text)
3584 self.assertEquals("CHILDTEXT", root[0].text)
3585 self.assertEquals("CHILDTAIL", root[0].tail)
3586
3588 parser = self.etree.XMLParser(target=self.etree.TreeBuilder())
3589 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>')
3590 root = parser.close()
3591
3592 self.assertEquals("root", root.tag)
3593 self.assertEquals("ROOTTEXT", root.text)
3594 self.assertEquals("CHILDTEXT", root[0].text)
3595 self.assertEquals("CHILDTAIL", root[0].tail)
3596
3597 # helper methods
3598
3600 """Write out element for comparison.
3601 """
3602 data = self.etree.tostring(element, encoding=encoding)
3603 if encoding != 'us-ascii':
3604 data = data.decode(encoding)
3605 return canonicalize(data)
3606
3608 """Write out element for comparison, using real file.
3609 """
3610 ElementTree = self.etree.ElementTree
3611 handle, filename = tempfile.mkstemp()
3612 try:
3613 f = open(filename, 'wb')
3614 tree = ElementTree(element=element)
3615 tree.write(f, encoding=encoding)
3616 f.close()
3617 f = open(filename, 'rb')
3618 data = f.read()
3619 f.close()
3620 finally:
3621 os.close(handle)
3622 os.remove(filename)
3623 if encoding != 'us-ascii':
3624 data = data.decode(encoding)
3625 return canonicalize(data)
3626
3628 """Writes element out and checks whether it is expected.
3629
3630 Does this two ways; once using BytesIO, once using a real file.
3631 """
3632 self.assertEquals(expected, self._writeElement(element, encoding))
3633 self.assertEquals(expected, self._writeElementFile(element, encoding))
3634
3636 "Checks if the result XML byte string specifies the encoding."
3637 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']"
3638 if isinstance(result, str):
3639 has_encoding = re.compile(enc_re).match
3640 else:
3641 has_encoding = re.compile(_bytes(enc_re)).match
3642 self.assert_(has_encoding(result))
3643 result_encoding = has_encoding(result).group(1)
3644 self.assertEquals(result_encoding.upper(), encoding.upper())
3645
3647 return self.etree.tostring(tree.getroot()).replace(
3648 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))
3649
3652
3654 self.assert_(hasattr(element, 'tag'))
3655 self.assert_(hasattr(element, 'attrib'))
3656 self.assert_(hasattr(element, 'text'))
3657 self.assert_(hasattr(element, 'tail'))
3658 self._check_string(element.tag)
3659 self._check_mapping(element.attrib)
3660 if element.text != None:
3661 self._check_string(element.text)
3662 if element.tail != None:
3663 self._check_string(element.tail)
3664
3666 len(string)
3667 for char in string:
3668 self.assertEquals(1, len(char))
3669 new_string = string + ""
3670 new_string = string + " "
3671 string[:0]
3672
3674 len(mapping)
3675 keys = mapping.keys()
3676 values = mapping.values()
3677 items = mapping.items()
3678 for key in keys:
3679 item = mapping[key]
3680 mapping["key"] = "value"
3681 self.assertEquals("value", mapping["key"])
3682
3683
3684 if etree:
3687
3688 if ElementTree:
3691
3692 if cElementTree:
3695
3697 suite = unittest.TestSuite()
3698 if etree:
3699 suite.addTests([unittest.makeSuite(ETreeTestCase)])
3700 if ElementTree:
3701 suite.addTests([unittest.makeSuite(ElementTreeTestCase)])
3702 if cElementTree:
3703 suite.addTests([unittest.makeSuite(CElementTreeTestCase)])
3704 return suite
3705
3706 if __name__ == '__main__':
3707 print('to test use test.py %s' % __file__)
3708
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Tue Mar 2 17:15:39 2010 | http://epydoc.sourceforge.net |