1
2
3 """
4 Tests for the ElementTree API
5
6 Only test cases that apply equally well to etree and ElementTree
7 belong here. Note that there is a second test module called test_io.py
8 for IO related test cases.
9 """
10
11 import unittest, doctest
12 import os, re, tempfile, copy, operator, gc
13
14 from common_imports import StringIO, etree, ElementTree, cElementTree
15 from common_imports import fileInTestDir, canonicalize, HelperTestCase
16
17 if cElementTree is not None:
18 if tuple([int(n) for n in
19 getattr(cElementTree, "VERSION", "0.0").split(".")]) <= (1,0,7):
20 cElementTree = None
21
22 try:
23 reversed
24 except NameError:
25
27 seq = list(seq)[::-1]
28 return seq
29
31 etree = None
32
34 for i in range(10):
35 e = self.etree.Element('foo')
36 self.assertEquals(e.tag, 'foo')
37 self.assertEquals(e.text, None)
38 self.assertEquals(e.tail, None)
39
52
53
63
76
94
96 ElementTree = self.etree.ElementTree
97
98 f = StringIO('<doc>Test<one>One</one></doc>')
99 doc = ElementTree(file=f)
100 root = doc.getroot()
101 self.assertEquals(1, len(root))
102 self.assertEquals('one', root[0].tag)
103 self.assertRaises(IndexError, operator.getitem, root, 1)
104
106 ElementTree = self.etree.ElementTree
107
108 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
109 doc = ElementTree(file=f)
110 root = doc.getroot()
111 self.assertEquals(3, len(root))
112 self.assertEquals('one', root[0].tag)
113 self.assertEquals('two', root[1].tag)
114 self.assertEquals('three', root[2].tag)
115
117 ElementTree = self.etree.ElementTree
118
119 f = StringIO('<doc>Test</doc>')
120 doc = ElementTree(file=f)
121 root = doc.getroot()
122 self.assertEquals(0, len(root))
123
125 Element = self.etree.Element
126 SubElement = self.etree.SubElement
127 a = Element('a')
128 b = SubElement(a, 'b')
129 c = SubElement(a, 'c')
130 d = SubElement(a, 'd')
131 self.assertEquals(d, a[-1])
132 self.assertEquals(c, a[-2])
133 self.assertEquals(b, a[-3])
134 self.assertRaises(IndexError, operator.getitem, a, -4)
135 a[-1] = e = Element('e')
136 self.assertEquals(e, a[-1])
137 del a[-1]
138 self.assertEquals(2, len(a))
139
149
150 - def test_text(self):
151 ElementTree = self.etree.ElementTree
152
153 f = StringIO('<doc>This is a text</doc>')
154 doc = ElementTree(file=f)
155 root = doc.getroot()
156 self.assertEquals('This is a text', root.text)
157
158 - def test_text_empty(self):
159 ElementTree = self.etree.ElementTree
160
161 f = StringIO('<doc></doc>')
162 doc = ElementTree(file=f)
163 root = doc.getroot()
164 self.assertEquals(None, root.text)
165
166 - def test_text_other(self):
167 ElementTree = self.etree.ElementTree
168
169 f = StringIO('<doc><one>One</one></doc>')
170 doc = ElementTree(file=f)
171 root = doc.getroot()
172 self.assertEquals(None, root.text)
173 self.assertEquals('One', root[0].text)
174
176 ElementTree = self.etree.ElementTree
177
178 f = StringIO('<doc>This is > than a text</doc>')
179 doc = ElementTree(file=f)
180 root = doc.getroot()
181 self.assertEquals('This is > than a text', root.text)
182
184 Element = self.etree.Element
185
186 a = Element("a")
187 a.text = "<>&"
188 self.assertXML('<a><>&</a>',
189 a)
190
192 tostring = self.etree.tostring
193 Element = self.etree.Element
194
195 a = Element("a")
196 a.text = "<>&"
197 self.assertEquals('<a><>&</a>',
198 tostring(a))
199
201 Element = self.etree.Element
202
203 class strTest(str):
204 pass
205
206 a = Element("a")
207 a.text = strTest("text")
208 self.assertXML('<a>text</a>',
209 a)
210
222
229
230 a = Element("a")
231 SubElement(a, "t").tail = strTest("tail")
232 self.assertXML('<a><t></t>tail</a>',
233 a)
234
236
237 XML = self.etree.XML
238
239 root = XML('<doc>This is <i>mixed</i> content.</doc>')
240 self.assertEquals(1, len(root))
241 self.assertEquals('This is ', root.text)
242 self.assertEquals(None, root.tail)
243 self.assertEquals('mixed', root[0].text)
244 self.assertEquals(' content.', root[0].tail)
245
246 del root[0].tail
247
248 self.assertEquals(1, len(root))
249 self.assertEquals('This is ', root.text)
250 self.assertEquals(None, root.tail)
251 self.assertEquals('mixed', root[0].text)
252 self.assertEquals(None, root[0].tail)
253
254 root[0].tail = "TAIL"
255
256 self.assertEquals(1, len(root))
257 self.assertEquals('This is ', root.text)
258 self.assertEquals(None, root.tail)
259 self.assertEquals('mixed', root[0].text)
260 self.assertEquals('TAIL', root[0].tail)
261
271
281
292
294 ElementTree = self.etree.ElementTree
295
296 f = StringIO('<doc one="One" two="Two"/>')
297 doc = ElementTree(file=f)
298 root = doc.getroot()
299 self.assertEquals('One', root.get('one'))
300 self.assertEquals('Two', root.get('two'))
301 self.assertEquals(None, root.get('three'))
302 self.assertEquals('foo', root.get('three', 'foo'))
303
305 XML = self.etree.XML
306
307 root = XML('<doc one="One" two="Two"/>')
308 self.assertEquals('One', root.get('one'))
309 self.assertEquals('Two', root.get('two'))
310 root.attrib.clear()
311 self.assertEquals(None, root.get('one'))
312 self.assertEquals(None, root.get('two'))
313
315 Element = self.etree.Element
316
317 root = Element("root", one="One")
318 root.set("two", "Two")
319 self.assertEquals('One', root.get('one'))
320 self.assertEquals('Two', root.get('two'))
321 root.attrib.clear()
322 self.assertEquals(None, root.get('one'))
323 self.assertEquals(None, root.get('two'))
324
326 Element = self.etree.Element
327 SubElement = self.etree.SubElement
328
329 attribNS = '{http://foo/bar}x'
330
331 parent = Element('parent')
332 parent.set(attribNS, 'a')
333 child = SubElement(parent, 'child')
334 child.set(attribNS, 'b')
335
336 self.assertEquals('a', parent.get(attribNS))
337 self.assertEquals('b', child.get(attribNS))
338
339 parent.clear()
340 self.assertEquals(None, parent.get(attribNS))
341 self.assertEquals('b', child.get(attribNS))
342
356
358 root = self.etree.XML('<doc one="One" two="Two"/>')
359 self.assertRaises(KeyError, root.attrib.pop, 'NONE')
360
361 self.assertEquals('One', root.attrib['one'])
362 self.assertEquals('Two', root.attrib['two'])
363
365 root = self.etree.XML('<doc one="One" two="Two"/>')
366 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
367
371
373 root = self.etree.XML('<doc one="One" two="Two"/>')
374 self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)
375
377 XML = self.etree.XML
378
379 root = XML('<doc alpha="Alpha" beta="Beta"/>')
380 items = root.attrib.items()
381 items.sort()
382 self.assertEquals(
383 [('alpha', 'Alpha'), ('beta', 'Beta')],
384 items)
385
386 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
387
388 items = root.attrib.items()
389 items.sort()
390 self.assertEquals(
391 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
392 items)
393
395 XML = self.etree.XML
396
397 root = XML('<doc alpha="Alpha" beta="Beta"/>')
398 items = root.attrib.items()
399 items.sort()
400 self.assertEquals(
401 [('alpha', 'Alpha'), ('beta', 'Beta')],
402 items)
403
404 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
405
406 items = root.attrib.items()
407 items.sort()
408 self.assertEquals(
409 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
410 items)
411
413 XML = self.etree.XML
414
415 root = XML('<doc alpha="Alpha" beta="Beta"/>')
416 items = root.attrib.items()
417 items.sort()
418 self.assertEquals(
419 [('alpha', 'Alpha'), ('beta', 'Beta')],
420 items)
421
422 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems())
423
424 items = root.attrib.items()
425 items.sort()
426 self.assertEquals(
427 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
428 items)
429
431 XML = self.etree.XML
432
433 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
434 keys = root.attrib.keys()
435 keys.sort()
436 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
437
439 XML = self.etree.XML
440
441 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
442 keys = root.keys()
443 keys.sort()
444 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
445
447 XML = self.etree.XML
448
449 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
450 items = root.items()
451 items.sort()
452 self.assertEquals(
453 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
454 items)
455
457 XML = self.etree.XML
458
459 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
460 keys = root.keys()
461 keys.sort()
462 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
463 keys)
464
466 XML = self.etree.XML
467
468 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
469 values = root.attrib.values()
470 values.sort()
471 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
472
474 XML = self.etree.XML
475
476 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
477 values = root.attrib.values()
478 values.sort()
479 self.assertEquals(
480 ['Bar', 'Baz'], values)
481
483 XML = self.etree.XML
484
485 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
486 items = root.attrib.items()
487 items.sort()
488 self.assertEquals([
489 ('alpha', 'Alpha'),
490 ('beta', 'Beta'),
491 ('gamma', 'Gamma'),
492 ],
493 items)
494
496 XML = self.etree.XML
497
498 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
499 items = root.attrib.items()
500 items.sort()
501 self.assertEquals(
502 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
503 items)
504
506 XML = self.etree.XML
507
508 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
509 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
510
511 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
512 try:
513 self.assertEquals(expected, str(root.attrib))
514 except AssertionError:
515 self.assertEquals(alternative, str(root.attrib))
516
518 XML = self.etree.XML
519
520 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
521 self.assertEquals(
522 True, root.attrib.has_key('bar'))
523 self.assertEquals(
524 False, root.attrib.has_key('baz'))
525 self.assertEquals(
526 False, root.attrib.has_key('hah'))
527 self.assertEquals(
528 True,
529 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
530
532 XML = self.etree.XML
533
534 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
535 self.assertEquals(
536 True, 'bar' in root.attrib)
537 self.assertEquals(
538 False, 'baz' in root.attrib)
539 self.assertEquals(
540 False, 'hah' in root.attrib)
541 self.assertEquals(
542 True,
543 '{http://ns.codespeak.net/test}baz' in root.attrib)
544
551
553 XML = self.etree.XML
554
555 root = XML('<doc>This is a text.</doc>')
556 self.assertEquals(0, len(root))
557 self.assertEquals('This is a text.', root.text)
558
560 XMLID = self.etree.XMLID
561 XML = self.etree.XML
562 xml_text = '''
563 <document>
564 <h1 id="chapter1">...</h1>
565 <p id="note1" class="note">...</p>
566 <p>Regular paragraph.</p>
567 <p xml:id="xmlid">XML:ID paragraph.</p>
568 <p id="warn1" class="warning">...</p>
569 </document>
570 '''
571
572 root, dic = XMLID(xml_text)
573 root2 = XML(xml_text)
574 self.assertEquals(self._writeElement(root),
575 self._writeElement(root2))
576 expected = {
577 "chapter1" : root[0],
578 "note1" : root[1],
579 "warn1" : root[4]
580 }
581 self.assertEquals(dic, expected)
582
589
597
604
611
635
637 XML = self.etree.XML
638
639 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
640 result = []
641 for el in root:
642 result.append(el.tag)
643 self.assertEquals(['one', 'two', 'three'], result)
644
646 XML = self.etree.XML
647
648 root = XML('<doc></doc>')
649 result = []
650 for el in root:
651 result.append(el.tag)
652 self.assertEquals([], result)
653
655 XML = self.etree.XML
656
657 root = XML('<doc>Text</doc>')
658 result = []
659 for el in root:
660 result.append(el.tag)
661 self.assertEquals([], result)
662
669
671 XML = self.etree.XML
672 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
673 result = []
674 for el in reversed(root):
675 result.append(el.tag)
676 self.assertEquals(['three', 'two', 'one'], result)
677
679 XML = self.etree.XML
680
681 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
682 result = []
683 add = True
684 for el in root:
685 result.append(el.tag)
686 if add:
687 self.etree.SubElement(root, 'four')
688 add = False
689 self.assertEquals(['one', 'two', 'three', 'four'], result)
690
692 XML = self.etree.XML
693
694 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
695 result = []
696 for el in root:
697 result.append(el.tag)
698 del root[-1]
699 self.assertEquals(['one', 'two'], result)
700
702 XML = self.etree.XML
703
704 root = XML('<doc><one/><two/></doc>')
705 result = []
706 for el0 in root:
707 result.append(el0.tag)
708 for el1 in root:
709 result.append(el1.tag)
710 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
711
713 XML = self.etree.XML
714
715 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')
716 result = []
717 for key in root.attrib:
718 result.append(key)
719 result.sort()
720 self.assertEquals(['alpha', 'beta', 'gamma'], result)
721
722 - def test_itertext(self):
723
724 XML = self.etree.XML
725 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")
726
727 text = list(root.itertext())
728 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"],
729 text)
730
732
733 XML = self.etree.XML
734 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")
735
736 text = list(root[2].itertext())
737 self.assertEquals(["CTEXT"],
738 text)
739
741 XML = self.etree.XML
742 root = XML('<a><b><c/></b><b/><c><b/></c></a>')
743 self.assertEquals(len(list(root.findall("c"))), 1)
744 self.assertEquals(len(list(root.findall(".//c"))), 2)
745 self.assertEquals(len(list(root.findall(".//b"))), 3)
746 self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
747 self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
748 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
749
751 XML = self.etree.XML
752 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
753 self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
754 self.assertEquals(len(list(root.findall(".//b"))), 3)
755 self.assertEquals(len(list(root.findall("b"))), 2)
756
763
770
772 Element = self.etree.Element
773
774 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
775 self.assertEquals('Foo', el.attrib['{ns1}foo'])
776 self.assertEquals('Bar', el.attrib['{ns2}bar'])
777
786
795
809
828
830 ElementTree = self.etree.ElementTree
831 Element = self.etree.Element
832 SubElement = self.etree.SubElement
833
834 a = Element('a')
835 a.text = "A"
836 a.tail = "tail"
837 b = SubElement(a, 'b')
838 b.text = "B"
839 b.tail = "TAIL"
840 c = SubElement(a, 'c')
841 c.text = "C"
842
843 tree = ElementTree(element=a)
844 f = StringIO()
845 tree.write(f, method="text")
846 data = f.getvalue()
847
848 self.assertEquals('ABTAILCtail',
849 data)
850
858
859
860
862 Element = self.etree.Element
863
864 element = Element('tag')
865 for i in range(10):
866 element.attrib['key'] = 'value'
867 value = element.attrib['key']
868 self.assertEquals(value, 'value')
869
870
882
905
906 - def test_set_text(self):
907 Element = self.etree.Element
908 SubElement = self.etree.SubElement
909
910 a = Element('a')
911 b = SubElement(a, 'b')
912 a.text = 'hoi'
913 self.assertEquals(
914 'hoi',
915 a.text)
916 self.assertEquals(
917 'b',
918 a[0].tag)
919
920 - def test_set_text2(self):
921 Element = self.etree.Element
922 SubElement = self.etree.SubElement
923
924 a = Element('a')
925 a.text = 'hoi'
926 b = SubElement(a ,'b')
927 self.assertEquals(
928 'hoi',
929 a.text)
930 self.assertEquals(
931 'b',
932 a[0].tag)
933
935 Element = self.etree.Element
936
937 a = Element('a')
938
939 a.text = 'foo'
940 a.text = None
941
942 self.assertEquals(
943 None,
944 a.text)
945 self.assertXML('<a></a>', a)
946
948 Element = self.etree.Element
949
950 a = Element('a')
951 self.assertEquals(None, a.text)
952
953 a.text = ''
954 self.assertEquals('', a.text)
955 self.assertXML('<a></a>', a)
956
971
981
993
1003
1005 root = self.etree.Element('foo')
1006 for i in range(3):
1007 element = self.etree.SubElement(root, 'a%s' % i)
1008 element.text = "text%d" % i
1009 element.tail = "tail%d" % i
1010
1011 elements = []
1012 for i in range(3):
1013 new_element = self.etree.Element("test%s" % i)
1014 new_element.text = "TEXT%s" % i
1015 new_element.tail = "TAIL%s" % i
1016 elements.append(new_element)
1017
1018 root.extend(elements)
1019
1020 self.assertEquals(
1021 ["a0", "a1", "a2", "test0", "test1", "test2"],
1022 [ el.tag for el in root ])
1023 self.assertEquals(
1024 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
1025 [ el.text for el in root ])
1026 self.assertEquals(
1027 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
1028 [ el.tail for el in root ])
1029
1039
1051
1060
1072
1073
1089
1090
1101
1103
1104 Element = self.etree.Element
1105 SubElement = self.etree.SubElement
1106 ProcessingInstruction = self.etree.ProcessingInstruction
1107
1108 a = Element('a')
1109 a.append(ProcessingInstruction('foo', 'some more text'))
1110 self.assertEquals(a[0].tag, ProcessingInstruction)
1111 self.assertXML("<a><?foo some more text?></a>",
1112 a)
1113
1125
1127 ProcessingInstruction = self.etree.ProcessingInstruction
1128 pi = ProcessingInstruction('foo')
1129 self.assertEquals({}, pi.attrib)
1130 self.assertEquals([], pi.keys())
1131 self.assertEquals([], pi.items())
1132 self.assertEquals(None, pi.get('hoi'))
1133 self.assertEquals(0, len(pi))
1134
1135 for i in pi:
1136 pass
1137
1153
1171
1181
1190
1205
1222
1240
1259
1265
1266 a = Element("a")
1267 a.tag = strTest("TAG")
1268 self.assertXML('<TAG></TAG>',
1269 a)
1270
1300
1302 Element = self.etree.Element
1303 SubElement = self.etree.SubElement
1304
1305 a = Element('a')
1306 b = SubElement(a, 'b')
1307 bs = SubElement(b, 'bs')
1308 c = SubElement(a, 'c')
1309 cs = SubElement(c, 'cs')
1310
1311 el = a[0]
1312 self.assertXML(
1313 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1314 a)
1315 self.assertXML('<b><bs></bs></b>', b)
1316 self.assertXML('<c><cs></cs></c>', c)
1317
1318 del a[0]
1319 self.assertXML(
1320 '<a><c><cs></cs></c></a>',
1321 a)
1322 self.assertXML('<b><bs></bs></b>', b)
1323 self.assertXML('<c><cs></cs></c>', c)
1324
1325 a.insert(0, el)
1326 self.assertXML(
1327 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1328 a)
1329 self.assertXML('<b><bs></bs></b>', b)
1330 self.assertXML('<c><cs></cs></c>', c)
1331
1350
1369
1371 XML = self.etree.XML
1372 a = XML('<a><b></b>B2<c></c>C2</a>')
1373 b, c = a
1374
1375 a[:] = []
1376
1377 self.assertEquals("B2", b.tail)
1378 self.assertEquals("C2", c.tail)
1379
1389
1391 Element = self.etree.Element
1392
1393 a = Element('a')
1394 a.text = 'foo'
1395 a.tail = 'bar'
1396 a.set('hoi', 'dag')
1397 a.clear()
1398 self.assertEquals(None, a.text)
1399 self.assertEquals(None, a.tail)
1400 self.assertEquals(None, a.get('hoi'))
1401 self.assertEquals('a', a.tag)
1402
1404 Element = self.etree.Element
1405 SubElement = self.etree.SubElement
1406
1407 a = Element('a')
1408 a.text = 'foo'
1409 a.tail = 'bar'
1410 a.set('hoi', 'dag')
1411 b = SubElement(a, 'b')
1412 c = SubElement(b, 'c')
1413 a.clear()
1414 self.assertEquals(None, a.text)
1415 self.assertEquals(None, a.tail)
1416 self.assertEquals(None, a.get('hoi'))
1417 self.assertEquals('a', a.tag)
1418 self.assertEquals(0, len(a))
1419 self.assertXML('<a></a>',
1420 a)
1421 self.assertXML('<b><c></c></b>',
1422 b)
1423
1433
1460
1476
1493
1508
1524
1540
1551
1564
1586
1595
1597 Element = self.etree.Element
1598 SubElement = self.etree.SubElement
1599
1600 a = Element('a')
1601 b = SubElement(a, 'b')
1602 c = SubElement(a, 'c')
1603 d = SubElement(b, 'd')
1604 e = SubElement(c, 'e')
1605
1606 self.assertEquals(
1607 [a, b, d, c, e],
1608 list(a.iter()))
1609 self.assertEquals(
1610 [d],
1611 list(d.iter()))
1612
1614 Element = self.etree.Element
1615 SubElement = self.etree.SubElement
1616
1617 a = Element('a')
1618 b = SubElement(a, 'b')
1619 c = SubElement(a, 'c')
1620 d = SubElement(b, 'd')
1621 e = SubElement(c, 'e')
1622
1623 self.assertEquals(
1624 [a, b, d, c, e],
1625 list(a.getiterator()))
1626 self.assertEquals(
1627 [d],
1628 list(d.getiterator()))
1629
1649
1670
1684
1709
1711 Element = self.etree.Element
1712 PI = self.etree.ProcessingInstruction
1713 SubElement = self.etree.SubElement
1714
1715 a = Element('a')
1716 b = SubElement(a, 'b')
1717 pi_b = PI("TEST-b")
1718 b.append(pi_b)
1719
1720 self.assertEquals(
1721 [pi_b],
1722 list(a.getiterator(PI)))
1723
1724 pi_a = PI("TEST-a")
1725 a.append(pi_a)
1726
1727 self.assertEquals(
1728 [pi_b, pi_a],
1729 list(a.getiterator(PI)))
1730
1731 self.assertEquals(
1732 [pi_b],
1733 list(b.getiterator(PI)))
1734
1736 Element = self.etree.Element
1737 SubElement = self.etree.SubElement
1738
1739 a = Element('a')
1740 a.text = 'a'
1741 b = SubElement(a, 'b')
1742 b.text = 'b'
1743 b.tail = 'b1'
1744 c = SubElement(a, 'c')
1745 c.text = 'c'
1746 c.tail = 'c1'
1747 d = SubElement(b, 'd')
1748 c.text = 'd'
1749 c.tail = 'd1'
1750 e = SubElement(c, 'e')
1751 e.text = 'e'
1752 e.tail = 'e1'
1753
1754 self.assertEquals(
1755 [a, b, d, c, e],
1756 list(a.getiterator()))
1757
1758
1759
1760
1762 Element = self.etree.Element
1763 SubElement = self.etree.SubElement
1764
1765 a = Element('a')
1766 a.text = 'a'
1767 b = SubElement(a, 'b')
1768 b.text = 'b'
1769 b.tail = 'b1'
1770 c = SubElement(a, 'c')
1771 c.text = 'c'
1772 c.tail = 'c1'
1773 d = SubElement(b, 'd')
1774 c.text = 'd'
1775 c.tail = 'd1'
1776 e = SubElement(c, 'e')
1777 e.text = 'e'
1778 e.tail = 'e1'
1779
1780 self.assertEquals(
1781 [a],
1782 list(a.getiterator('a')))
1783 a2 = SubElement(e, 'a')
1784 self.assertEquals(
1785 [a, a2],
1786 list(a.getiterator('a')))
1787 self.assertEquals(
1788 [a2],
1789 list(e.getiterator('a')))
1790
1800
1802 Element = self.etree.Element
1803 SubElement = self.etree.SubElement
1804
1805 a = Element('a')
1806 b = SubElement(a, 'b')
1807 c = SubElement(a, 'c')
1808 d = SubElement(a, 'd')
1809
1810 self.assertEquals(
1811 [b, c],
1812 a[0:2])
1813 self.assertEquals(
1814 [b, c, d],
1815 a[:])
1816 self.assertEquals(
1817 [b, c, d],
1818 a[:10])
1819 self.assertEquals(
1820 [b],
1821 a[0:1])
1822 self.assertEquals(
1823 [],
1824 a[10:12])
1825
1827 Element = self.etree.Element
1828 SubElement = self.etree.SubElement
1829
1830 a = Element('a')
1831 b = SubElement(a, 'b')
1832 c = SubElement(a, 'c')
1833 d = SubElement(a, 'd')
1834
1835 self.assertEquals(
1836 [d],
1837 a[-1:])
1838 self.assertEquals(
1839 [c, d],
1840 a[-2:])
1841 self.assertEquals(
1842 [c],
1843 a[-2:-1])
1844 self.assertEquals(
1845 [b, c],
1846 a[-3:-1])
1847 self.assertEquals(
1848 [b, c],
1849 a[-3:2])
1850
1852 Element = self.etree.Element
1853 SubElement = self.etree.SubElement
1854
1855 a = Element('a')
1856 b = SubElement(a, 'b')
1857 c = SubElement(a, 'c')
1858 d = SubElement(a, 'd')
1859 e = SubElement(a, 'e')
1860
1861 self.assertEquals(
1862 [e,d,c,b],
1863 a[::-1])
1864 self.assertEquals(
1865 [b,d],
1866 a[::2])
1867 self.assertEquals(
1868 [e,c],
1869 a[::-2])
1870 self.assertEquals(
1871 [d,c],
1872 a[-2:0:-1])
1873 self.assertEquals(
1874 [e],
1875 a[:1:-2])
1876
1878 ElementTree = self.etree.ElementTree
1879
1880 f = StringIO('<a><b>B</b>B1<c>C</c>C1</a>')
1881 doc = ElementTree(file=f)
1882 a = doc.getroot()
1883 b = a[0]
1884 c = a[1]
1885 self.assertEquals(
1886 [b, c],
1887 a[:])
1888 self.assertEquals(
1889 [b],
1890 a[0:1])
1891 self.assertEquals(
1892 [c],
1893 a[1:])
1894
1918
1933
1948
1963
1978
1993
2008
2010 ElementTree = self.etree.ElementTree
2011 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
2012 doc = ElementTree(file=f)
2013 a = doc.getroot()
2014 del a[1:3]
2015 self.assertXML(
2016 '<a><b></b>B2<e></e>E2</a>',
2017 a)
2018
2020 XML = self.etree.XML
2021 a = XML('<a><b></b>B2<c></c>C2</a>')
2022 b, c = a
2023
2024 del a[:]
2025
2026 self.assertEquals("B2", b.tail)
2027 self.assertEquals("C2", c.tail)
2028
2039
2041 Element = self.etree.Element
2042 SubElement = self.etree.SubElement
2043
2044 a = Element('a')
2045 b = SubElement(a, 'b')
2046 c = SubElement(a, 'c')
2047 d = SubElement(a, 'd')
2048
2049 e = Element('e')
2050 f = Element('f')
2051 g = Element('g')
2052
2053 s = [e, f, g]
2054 a[1:2] = s
2055 self.assertEquals(
2056 [b, e, f, g, d],
2057 list(a))
2058
2076
2092
2107
2122
2124 Element = self.etree.Element
2125 SubElement = self.etree.SubElement
2126
2127 a = Element('{ns}a')
2128 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
2129 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
2130 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
2131
2132 s = [d, c, b]
2133 a[:] = s
2134 self.assertEquals(
2135 [d, c, b],
2136 list(a))
2137 self.assertEquals(
2138 ['{ns}d', '{ns}c', '{ns}b'],
2139 [ child.tag for child in a ])
2140
2141 self.assertEquals(
2142 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
2143 [ child.attrib.keys() for child in a ])
2144
2146 Element = self.etree.Element
2147 SubElement = self.etree.SubElement
2148
2149 a = Element('{ns}a')
2150 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
2151 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
2152 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
2153
2154 s = [d, c, b]
2155 a[:] = s
2156 self.assertEquals(
2157 [d, c, b],
2158 list(a))
2159 self.assertEquals(
2160 ['{ns3}d', '{ns2}c', '{ns1}b'],
2161 [ child.tag for child in a ])
2162
2163 self.assertEquals(
2164 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
2165 [ child.attrib.keys() for child in a ])
2166
2168 Element = self.etree.Element
2169 SubElement = self.etree.SubElement
2170
2171 a = Element('a')
2172 b = SubElement(a, 'b')
2173 c = SubElement(a, 'c')
2174
2175 e = Element('e')
2176 f = Element('f')
2177 g = Element('g')
2178 h = Element('h')
2179
2180 s = [e, f]
2181 a[99:] = s
2182 self.assertEquals(
2183 [a, b, e, f],
2184 list(a))
2185
2186 s = [g, h]
2187 a[:0] = s
2188 self.assertEquals(
2189 [g, h, a, b, e, f],
2190 list(a))
2191
2214
2231
2248
2265
2267 Element = self.etree.Element
2268 SubElement = self.etree.SubElement
2269
2270 a = Element('a')
2271 b = SubElement(a, 'b')
2272 c = SubElement(a, 'c')
2273 d = SubElement(a, 'd')
2274
2275 e = Element('e')
2276 f = Element('f')
2277 g = Element('g')
2278
2279 s = [e, f, g]
2280 a[3:] = s
2281 self.assertEquals(
2282 [b, c, d, e, f, g],
2283 list(a))
2284
2297
2307
2323
2342
2344 ElementTree = self.etree.ElementTree
2345 ns = 'http://xml.infrae.com/1'
2346 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
2347 t = ElementTree(file=f)
2348 a = t.getroot()
2349 self.assertEquals('{%s}a' % ns,
2350 a.tag)
2351 self.assertEquals('{%s}b' % ns,
2352 a[0].tag)
2353
2355 ElementTree = self.etree.ElementTree
2356 ns = 'http://xml.infrae.com/1'
2357 ns2 = 'http://xml.infrae.com/2'
2358 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2359 t = ElementTree(file=f)
2360 a = t.getroot()
2361 self.assertEquals('{%s}a' % ns,
2362 a.tag)
2363 self.assertEquals('{%s}b' % ns,
2364 a[0].tag)
2365 self.assertEquals('{%s}b' % ns2,
2366 a[1].tag)
2367
2369 Element = self.etree.Element
2370 SubElement = self.etree.SubElement
2371 ns = 'http://xml.infrae.com/1'
2372 ns2 = 'http://xml.infrae.com/2'
2373 a = Element('{%s}a' % ns)
2374 b = SubElement(a, '{%s}b' % ns2)
2375 c = SubElement(a, '{%s}c' % ns)
2376 self.assertEquals('{%s}a' % ns,
2377 a.tag)
2378 self.assertEquals('{%s}b' % ns2,
2379 b.tag)
2380 self.assertEquals('{%s}c' % ns,
2381 c.tag)
2382 self.assertEquals('{%s}a' % ns,
2383 a.tag)
2384 self.assertEquals('{%s}b' % ns2,
2385 b.tag)
2386 self.assertEquals('{%s}c' % ns,
2387 c.tag)
2388
2406
2408 Element = self.etree.Element
2409 ns = 'http://xml.infrae.com/1'
2410 ns2 = 'http://xml.infrae.com/2'
2411 a = Element('a')
2412 a.set('{%s}foo' % ns, 'Foo')
2413 a.set('{%s}bar' % ns2, 'Bar')
2414 self.assertEquals(
2415 'Foo',
2416 a.get('{%s}foo' % ns))
2417 self.assertEquals(
2418 'Bar',
2419 a.get('{%s}bar' % ns2))
2420 try:
2421 self.assertXML(
2422 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2),
2423 a)
2424 except AssertionError:
2425 self.assertXML(
2426 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns),
2427 a)
2428
2430 Element = self.etree.Element
2431 one = self.etree.fromstring(
2432 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
2433 baz = one[0][0]
2434
2435 two = Element('root')
2436 two.append(baz)
2437
2438
2439 del one, baz
2440 self.assertEquals('{http://a.b.c}baz', two[0].tag)
2441
2443 tostring = self.etree.tostring
2444 root = self.etree.XML(
2445 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
2446 baz = root[0][0]
2447
2448 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2449 tostring(baz))
2450 self.assertEquals(["http://a.b.c"], nsdecl)
2451
2453 tostring = self.etree.tostring
2454 root = self.etree.XML(
2455 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')
2456 baz = root[0][0]
2457
2458 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2459 tostring(baz))
2460 self.assertEquals(["http://a.b.c"], nsdecl)
2461
2463 tostring = self.etree.tostring
2464 root = self.etree.XML(
2465 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')
2466 baz = root[0][0]
2467
2468 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2469 tostring(baz))
2470
2471 self.assertEquals(["http://a.b.c"], nsdecl)
2472
2485
2487 Element = self.etree.Element
2488
2489 root = Element('element')
2490
2491 subelement = Element('subelement',
2492 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2493 self.assertEquals(1, len(subelement.attrib))
2494 self.assertEquals(
2495 "foo",
2496 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2497
2498 root.append(subelement)
2499 self.assertEquals(1, len(subelement.attrib))
2500 self.assertEquals(
2501 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
2502 subelement.attrib.items())
2503 self.assertEquals(
2504 "foo",
2505 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2506
2508 parse = self.etree.parse
2509 tostring = self.etree.tostring
2510
2511 ns_href = "http://a.b.c"
2512 one = parse(
2513 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
2514 baz = one.getroot()[0][0]
2515
2516 parsed = parse(StringIO( tostring(baz) )).getroot()
2517 self.assertEquals('{%s}baz' % ns_href, parsed.tag)
2518
2530
2544
2558
2572
2574 tostring = self.etree.tostring
2575 Element = self.etree.Element
2576 SubElement = self.etree.SubElement
2577
2578 a = Element('a')
2579 a.text = "A"
2580 a.tail = "tail"
2581 b = SubElement(a, 'b')
2582 b.text = "B"
2583 b.tail = "TAIL"
2584 c = SubElement(a, 'c')
2585 c.text = "C"
2586
2587 self.assertEquals('ABTAILCtail',
2588 tostring(a, method="text"))
2589
2591 iterparse = self.etree.iterparse
2592 f = StringIO('<a><b></b><c/></a>')
2593
2594 iterator = iterparse(f)
2595 self.assertEquals(None,
2596 iterator.root)
2597 events = list(iterator)
2598 root = iterator.root
2599 self.assertEquals(
2600 [('end', root[0]), ('end', root[1]), ('end', root)],
2601 events)
2602
2613
2615 iterparse = self.etree.iterparse
2616 f = StringIO('<a><b></b><c/></a>')
2617
2618 iterator = iterparse(f, events=('start',))
2619 events = list(iterator)
2620 root = iterator.root
2621 self.assertEquals(
2622 [('start', root), ('start', root[0]), ('start', root[1])],
2623 events)
2624
2626 iterparse = self.etree.iterparse
2627 f = StringIO('<a><b></b><c/></a>')
2628
2629 iterator = iterparse(f, events=('start','end'))
2630 events = list(iterator)
2631 root = iterator.root
2632 self.assertEquals(
2633 [('start', root), ('start', root[0]), ('end', root[0]),
2634 ('start', root[1]), ('end', root[1]), ('end', root)],
2635 events)
2636
2638 iterparse = self.etree.iterparse
2639 f = StringIO('<a><b></b><c/></a>')
2640
2641 iterator = iterparse(f)
2642 for event, elem in iterator:
2643 elem.clear()
2644
2645 root = iterator.root
2646 self.assertEquals(0,
2647 len(root))
2648
2650 iterparse = self.etree.iterparse
2651 CHILD_COUNT = 12345
2652 f = StringIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
2653
2654 i = 0
2655 for key in iterparse(f):
2656 event, element = key
2657 i += 1
2658 self.assertEquals(i, CHILD_COUNT + 1)
2659
2661 iterparse = self.etree.iterparse
2662 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2663
2664 attr_name = '{testns}bla'
2665 events = []
2666 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2667 for event, elem in iterator:
2668 events.append(event)
2669 if event == 'start':
2670 if elem.tag != '{ns1}a':
2671 elem.set(attr_name, 'value')
2672
2673 self.assertEquals(
2674 ['start-ns', 'start', 'start', 'start-ns', 'start',
2675 'end', 'end-ns', 'end', 'end', 'end-ns'],
2676 events)
2677
2678 root = iterator.root
2679 self.assertEquals(
2680 None,
2681 root.get(attr_name))
2682 self.assertEquals(
2683 'value',
2684 root[0].get(attr_name))
2685
2687 iterparse = self.etree.iterparse
2688 f = StringIO('<a><b><d/></b><c/></a>')
2689
2690 counts = []
2691 for event, elem in iterparse(f):
2692 counts.append(len(list(elem.getiterator())))
2693 self.assertEquals(
2694 [1,2,1,4],
2695 counts)
2696
2709
2711 tostring = self.etree.tostring
2712 f = StringIO('<root><![CDATA[test]]></root>')
2713 context = self.etree.iterparse(f)
2714 content = [ el.text for event,el in context ]
2715
2716 self.assertEquals(['test'], content)
2717 self.assertEquals('<root>test</root>',
2718 tostring(context.root))
2719
2727
2731
2735
2737
2738 parse = self.etree.parse
2739 f = StringIO('<a><b></c></b></a>')
2740 self.assertRaises(SyntaxError, parse, f)
2741 f.close()
2742
2749
2759
2761 parse = self.etree.parse
2762
2763 f = StringIO('<a><b></b></a>')
2764 tree = parse(f)
2765 f.close()
2766 self.assertXML(
2767 '<a><b></b></a>',
2768 tree.getroot()
2769 )
2770
2778
2780
2781 parse = self.etree.parse
2782 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2783 self.assertXML('<html></html>',
2784 tree.getroot())
2785
2794
2807
2815
2825
2827 ElementTree = self.etree.ElementTree
2828 Element = self.etree.Element
2829
2830 a = Element('a')
2831 a.text = u'Søk på nettet'
2832
2833 f = StringIO()
2834 tree = ElementTree(element=a)
2835 tree.write(f, encoding='iso-8859-1')
2836 result = f.getvalue()
2837 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2838 self.assertEncodingDeclaration(result,'iso-8859-1')
2839 result = result.split('?>', 1)[-1].replace('\n','')
2840 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2841 result)
2842
2857
2859 XMLParser = self.etree.XMLParser
2860
2861 text = u'Søk på nettet'
2862 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
2863 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text)
2864 ).encode('iso-8859-1')
2865
2866 self.assertRaises(self.etree.ParseError,
2867 self.etree.parse,
2868 StringIO(xml_latin1))
2869
2870 tree = self.etree.parse(StringIO(xml_latin1),
2871 XMLParser(encoding="iso-8859-1"))
2872 a = tree.getroot()
2873 self.assertEquals(a.text, text)
2874
2876
2877 XML = self.etree.XML
2878 test_utf = (u'<?xml version="1.0" encoding="iso-8859-1"?>' + \
2879 u'<a>Søk på nettet</a>')
2880 self.assertRaises(SyntaxError, XML, test_utf)
2881
2896
2905
2914
2925
2937
2950
2964
2966 utext = u'Søk på nettet'
2967 uxml = u'<p>%s</p>' % utext
2968 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2969 isoxml = prologue + uxml.encode('iso-8859-1')
2970 tree = self.etree.XML(isoxml)
2971 self.assertEquals(utext, tree.text)
2972
2974 utext = u'Søk på nettet'
2975 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \
2976 u'<p>%s</p>' % utext
2977 bom = '\xEF\xBB\xBF'
2978 xml = bom + uxml.encode("utf-8")
2979 tree = etree.XML(xml)
2980 self.assertEquals(utext, tree.text)
2981
2983 utext = u'Søk på nettet'
2984 uxml = u'<p>%s</p>' % utext
2985 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2986 isoxml = prologue + uxml.encode('iso-8859-1')
2987 el = self.etree.parse(StringIO(isoxml)).getroot()
2988 self.assertEquals(utext, el.text)
2989
3003
3005 Element = self.etree.Element
3006
3007 a = Element('a')
3008 a.text = 'Foo'
3009
3010 b = copy.deepcopy(a)
3011 self.assertEquals('Foo', b.text)
3012
3013 b.text = 'Bar'
3014 self.assertEquals('Bar', b.text)
3015 self.assertEquals('Foo', a.text)
3016
3017 del a
3018 self.assertEquals('Bar', b.text)
3019
3021 Element = self.etree.Element
3022
3023 a = Element('a')
3024 a.tail = 'Foo'
3025
3026 b = copy.deepcopy(a)
3027 self.assertEquals('Foo', b.tail)
3028
3029 b.tail = 'Bar'
3030 self.assertEquals('Bar', b.tail)
3031 self.assertEquals('Foo', a.tail)
3032
3033 del a
3034 self.assertEquals('Bar', b.tail)
3035
3037 Element = self.etree.Element
3038 SubElement = self.etree.SubElement
3039
3040 root = Element('root')
3041 a = SubElement(root, 'a')
3042 a.text = 'FooText'
3043 a.tail = 'FooTail'
3044
3045 b = copy.deepcopy(a)
3046 self.assertEquals('FooText', b.text)
3047 self.assertEquals('FooTail', b.tail)
3048
3049 b.text = 'BarText'
3050 b.tail = 'BarTail'
3051 self.assertEquals('BarTail', b.tail)
3052 self.assertEquals('FooTail', a.tail)
3053 self.assertEquals('BarText', b.text)
3054 self.assertEquals('FooText', a.text)
3055
3056 del a
3057 self.assertEquals('BarTail', b.tail)
3058 self.assertEquals('BarText', b.text)
3059
3061 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
3062 <parent><node t:foo="bar" /></parent>
3063 </doc>''')
3064 self.assertEquals(
3065 root[0][0].get('{tns}foo'),
3066 copy.deepcopy(root[0])[0].get('{tns}foo') )
3067 self.assertEquals(
3068 root[0][0].get('{tns}foo'),
3069 copy.deepcopy(root[0][0]).get('{tns}foo') )
3070
3085
3097
3110
3111
3124
3126
3127 etree = self.etree
3128 e = etree.Element('foo')
3129 self.assertEquals(False, bool(e))
3130 etree.SubElement(e, 'bar')
3131 self.assertEquals(True, bool(e))
3132 e = etree.Element('foo')
3133 e.text = 'hey'
3134 self.assertEquals(False, bool(e))
3135 e = etree.Element('foo')
3136 e.tail = 'bar'
3137 self.assertEquals(False, bool(e))
3138 e = etree.Element('foo')
3139 e.set('bar', 'Bar')
3140 self.assertEquals(False, bool(e))
3141
3143 etree = self.etree
3144
3145 a = etree.Element('a')
3146 b = etree.SubElement(a, 'b')
3147
3148 t = etree.ElementTree(a)
3149 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3150
3151 t1 = etree.ElementTree(a)
3152 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
3153 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3154
3155 t2 = etree.ElementTree(b)
3156 self.assertEquals(self._rootstring(t2), '<b/>')
3157 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
3158 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3159
3167
3169 etree = self.etree
3170 qname1 = etree.QName('myns', 'a')
3171 qname2 = etree.QName('myns', 'a')
3172 self.assertEquals(qname1, "{myns}a")
3173 self.assertEquals("{myns}a", qname2)
3174 self.assertEquals(qname1, qname1)
3175 self.assertEquals(qname1, qname2)
3176
3178 etree = self.etree
3179 qname = etree.QName('myns', 'a')
3180
3181 a = etree.Element(qname)
3182 a.set(qname, "value")
3183
3184 self.assertEquals(a.get(qname), "value")
3185 self.assertEquals(a.get("{myns}a"), "value")
3186
3188 etree = self.etree
3189 qname = etree.QName('myns', 'a')
3190
3191 a = etree.Element(qname)
3192 a.attrib[qname] = "value"
3193
3194 self.assertEquals(a.attrib[qname], "value")
3195 self.assertEquals(a.attrib.get(qname), "value")
3196
3197 self.assertEquals(a.attrib["{myns}a"], "value")
3198 self.assertEquals(a.attrib.get("{myns}a"), "value")
3199
3201 etree = self.etree
3202 qname = etree.QName('http://myns', 'a')
3203 a = etree.Element(qname)
3204 a.set(qname, qname)
3205
3206 self.assertXML(
3207 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>',
3208 a)
3209
3219
3229
3236
3237
3238
3254
3259
3268
3282
3293
3294
3295
3297 assertEquals = self.assertEquals
3298 assertFalse = self.assertFalse
3299
3300 events = []
3301 class Target(object):
3302 def start(self, tag, attrib):
3303 events.append("start")
3304 assertFalse(attrib)
3305 assertEquals("TAG", tag)
3306 def end(self, tag):
3307 events.append("end")
3308 assertEquals("TAG", tag)
3309 def close(self):
3310 return "DONE"
3311
3312 parser = self.etree.XMLParser(target=Target())
3313
3314 parser.feed("<TAG/>")
3315 done = parser.close()
3316
3317 self.assertEquals("DONE", done)
3318 self.assertEquals(["start", "end"], events)
3319
3321 assertEquals = self.assertEquals
3322
3323 events = []
3324 class Target(object):
3325 def start(self, tag, attrib):
3326 events.append("start-" + tag)
3327 for name, value in attrib.iteritems():
3328 assertEquals(tag + name, value)
3329 def end(self, tag):
3330 events.append("end-" + tag)
3331 def close(self):
3332 return "DONE"
3333
3334 parser = self.etree.XMLParser(target=Target())
3335
3336 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3337 done = parser.close()
3338
3339 self.assertEquals("DONE", done)
3340 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3341 events)
3342
3344 events = []
3345 class Target(object):
3346 def start(self, tag, attrib):
3347 events.append("start-" + tag)
3348 def end(self, tag):
3349 events.append("end-" + tag)
3350 def data(self, data):
3351 events.append("data-" + data)
3352 def close(self):
3353 return "DONE"
3354
3355 parser = self.etree.XMLParser(target=Target())
3356
3357 parser.feed('<root>A<sub/>B</root>')
3358 done = parser.close()
3359
3360 self.assertEquals("DONE", done)
3361 self.assertEquals(["start-root", "data-A", "start-sub",
3362 "end-sub", "data-B", "end-root"],
3363 events)
3364
3366 events = []
3367 class Target(object):
3368 def __init__(self):
3369 self._data = []
3370 def _flush_data(self):
3371 if self._data:
3372 events.append("data-" + ''.join(self._data))
3373 del self._data[:]
3374 def start(self, tag, attrib):
3375 self._flush_data()
3376 events.append("start-" + tag)
3377 def end(self, tag):
3378 self._flush_data()
3379 events.append("end-" + tag)
3380 def data(self, data):
3381 self._data.append(data)
3382 def close(self):
3383 self._flush_data()
3384 return "DONE"
3385
3386 parser = self.etree.XMLParser(target=Target())
3387
3388 dtd = '''
3389 <!DOCTYPE root [
3390 <!ELEMENT root (sub*)>
3391 <!ELEMENT sub (#PCDATA)>
3392 <!ENTITY ent "an entity">
3393 ]>
3394 '''
3395 parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
3396 done = parser.close()
3397
3398 self.assertEquals("DONE", done)
3399 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
3400 "data-this is an entity",
3401 "end-sub", "start-sub", "end-sub", "end-root"],
3402 events)
3403
3405 events = []
3406 class Target(object):
3407 def __init__(self):
3408 self._data = []
3409 def _flush_data(self):
3410 if self._data:
3411 events.append("data-" + ''.join(self._data))
3412 del self._data[:]
3413 def start(self, tag, attrib):
3414 self._flush_data()
3415 events.append("start-" + tag)
3416 def end(self, tag):
3417 self._flush_data()
3418 events.append("end-" + tag)
3419 def data(self, data):
3420 self._data.append(data)
3421 def close(self):
3422 self._flush_data()
3423 return "DONE"
3424
3425 parser = self.etree.XMLParser(target=Target())
3426
3427 def feed():
3428 parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
3429 parser.close()
3430
3431 self.assertRaises(self.etree.ParseError, feed)
3432
3434 builder = self.etree.TreeBuilder()
3435 el = builder.start("root", {'a':'A', 'b':'B'})
3436 self.assertEquals("root", el.tag)
3437 self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3438 builder.data("ROOTTEXT")
3439 el = builder.start("child", {'x':'X', 'y':'Y'})
3440 self.assertEquals("child", el.tag)
3441 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3442 builder.data("CHILDTEXT")
3443 el = builder.end("child")
3444 self.assertEquals("child", el.tag)
3445 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3446 self.assertEquals("CHILDTEXT", el.text)
3447 self.assertEquals(None, el.tail)
3448 builder.data("CHILDTAIL")
3449 root = builder.end("root")
3450
3451 self.assertEquals("root", root.tag)
3452 self.assertEquals("ROOTTEXT", root.text)
3453 self.assertEquals("CHILDTEXT", root[0].text)
3454 self.assertEquals("CHILDTAIL", root[0].tail)
3455
3465
3466
3467
3475
3495
3496 - def assertXML(self, expected, element, encoding='us-ascii'):
3497 """Writes element out and checks whether it is expected.
3498
3499 Does this two ways; once using StringIO, once using a real file.
3500 """
3501 self.assertEquals(expected, self._writeElement(element, encoding))
3502 self.assertEquals(expected, self._writeElementFile(element, encoding))
3503
3505 "Checks if the result XML byte string specifies the encoding."
3506 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
3507 self.assert_(has_encoding(result))
3508 result_encoding = has_encoding(result).group(1)
3509 self.assertEquals(result_encoding.upper(), encoding.upper())
3510
3512 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
3513
3515 self._check_element(tree.getroot())
3516
3518 self.assert_(hasattr(element, 'tag'))
3519 self.assert_(hasattr(element, 'attrib'))
3520 self.assert_(hasattr(element, 'text'))
3521 self.assert_(hasattr(element, 'tail'))
3522 self._check_string(element.tag)
3523 self._check_mapping(element.attrib)
3524 if element.text != None:
3525 self._check_string(element.text)
3526 if element.tail != None:
3527 self._check_string(element.tail)
3528
3530 len(string)
3531 for char in string:
3532 self.assertEquals(1, len(char))
3533 new_string = string + ""
3534 new_string = string + " "
3535 string[:0]
3536
3538 len(mapping)
3539 keys = mapping.keys()
3540 items = mapping.items()
3541 for key in keys:
3542 item = mapping[key]
3543 mapping["key"] = "value"
3544 self.assertEquals("value", mapping["key"])
3545
3546
3547 if etree:
3550
3551 if ElementTree:
3554
3555 if cElementTree:
3558
3568
3569 if __name__ == '__main__':
3570 print 'to test use test.py %s' % __file__
3571