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
2443
2445 tostring = self.etree.tostring
2446 root = self.etree.XML(
2447 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
2448 baz = root[0][0]
2449
2450 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2451 tostring(baz))
2452 self.assertEquals(["http://a.b.c"], nsdecl)
2453
2455 tostring = self.etree.tostring
2456 root = self.etree.XML(
2457 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')
2458 baz = root[0][0]
2459
2460 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2461 tostring(baz))
2462 self.assertEquals(["http://a.b.c"], nsdecl)
2463
2465 tostring = self.etree.tostring
2466 root = self.etree.XML(
2467 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')
2468 baz = root[0][0]
2469
2470 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2471 tostring(baz))
2472
2473 self.assertEquals(["http://a.b.c"], nsdecl)
2474
2487
2489 Element = self.etree.Element
2490
2491 root = Element('element')
2492
2493 subelement = Element('subelement',
2494 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2495 self.assertEquals(1, len(subelement.attrib))
2496 self.assertEquals(
2497 "foo",
2498 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2499
2500 root.append(subelement)
2501 self.assertEquals(1, len(subelement.attrib))
2502 self.assertEquals(
2503 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
2504 subelement.attrib.items())
2505 self.assertEquals(
2506 "foo",
2507 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2508
2510 parse = self.etree.parse
2511 tostring = self.etree.tostring
2512
2513 ns_href = "http://a.b.c"
2514 one = parse(
2515 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
2516 baz = one.getroot()[0][0]
2517
2518 parsed = parse(StringIO( tostring(baz) )).getroot()
2519 self.assertEquals('{%s}baz' % ns_href, parsed.tag)
2520
2532
2546
2560
2574
2576 tostring = self.etree.tostring
2577 Element = self.etree.Element
2578 SubElement = self.etree.SubElement
2579
2580 a = Element('a')
2581 a.text = "A"
2582 a.tail = "tail"
2583 b = SubElement(a, 'b')
2584 b.text = "B"
2585 b.tail = "TAIL"
2586 c = SubElement(a, 'c')
2587 c.text = "C"
2588
2589 self.assertEquals('ABTAILCtail',
2590 tostring(a, method="text"))
2591
2593 iterparse = self.etree.iterparse
2594 f = StringIO('<a><b></b><c/></a>')
2595
2596 iterator = iterparse(f)
2597 self.assertEquals(None,
2598 iterator.root)
2599 events = list(iterator)
2600 root = iterator.root
2601 self.assertEquals(
2602 [('end', root[0]), ('end', root[1]), ('end', root)],
2603 events)
2604
2615
2617 iterparse = self.etree.iterparse
2618 f = StringIO('<a><b></b><c/></a>')
2619
2620 iterator = iterparse(f, events=('start',))
2621 events = list(iterator)
2622 root = iterator.root
2623 self.assertEquals(
2624 [('start', root), ('start', root[0]), ('start', root[1])],
2625 events)
2626
2628 iterparse = self.etree.iterparse
2629 f = StringIO('<a><b></b><c/></a>')
2630
2631 iterator = iterparse(f, events=('start','end'))
2632 events = list(iterator)
2633 root = iterator.root
2634 self.assertEquals(
2635 [('start', root), ('start', root[0]), ('end', root[0]),
2636 ('start', root[1]), ('end', root[1]), ('end', root)],
2637 events)
2638
2640 iterparse = self.etree.iterparse
2641 f = StringIO('<a><b></b><c/></a>')
2642
2643 iterator = iterparse(f)
2644 for event, elem in iterator:
2645 elem.clear()
2646
2647 root = iterator.root
2648 self.assertEquals(0,
2649 len(root))
2650
2652 iterparse = self.etree.iterparse
2653 CHILD_COUNT = 12345
2654 f = StringIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
2655
2656 i = 0
2657 for key in iterparse(f):
2658 event, element = key
2659 i += 1
2660 self.assertEquals(i, CHILD_COUNT + 1)
2661
2663 iterparse = self.etree.iterparse
2664 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2665
2666 attr_name = '{testns}bla'
2667 events = []
2668 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2669 for event, elem in iterator:
2670 events.append(event)
2671 if event == 'start':
2672 if elem.tag != '{ns1}a':
2673 elem.set(attr_name, 'value')
2674
2675 self.assertEquals(
2676 ['start-ns', 'start', 'start', 'start-ns', 'start',
2677 'end', 'end-ns', 'end', 'end', 'end-ns'],
2678 events)
2679
2680 root = iterator.root
2681 self.assertEquals(
2682 None,
2683 root.get(attr_name))
2684 self.assertEquals(
2685 'value',
2686 root[0].get(attr_name))
2687
2689 iterparse = self.etree.iterparse
2690 f = StringIO('<a><b><d/></b><c/></a>')
2691
2692 counts = []
2693 for event, elem in iterparse(f):
2694 counts.append(len(list(elem.getiterator())))
2695 self.assertEquals(
2696 [1,2,1,4],
2697 counts)
2698
2706
2710
2714
2716
2717 parse = self.etree.parse
2718 f = StringIO('<a><b></c></b></a>')
2719 self.assertRaises(SyntaxError, parse, f)
2720 f.close()
2721
2728
2738
2740 parse = self.etree.parse
2741
2742 f = StringIO('<a><b></b></a>')
2743 tree = parse(f)
2744 f.close()
2745 self.assertXML(
2746 '<a><b></b></a>',
2747 tree.getroot()
2748 )
2749
2751
2752 parse = self.etree.parse
2753 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2754 self.assertXML('<html></html>',
2755 tree.getroot())
2756
2765
2778
2786
2796
2798 ElementTree = self.etree.ElementTree
2799 Element = self.etree.Element
2800
2801 a = Element('a')
2802 a.text = u'Søk på nettet'
2803
2804 f = StringIO()
2805 tree = ElementTree(element=a)
2806 tree.write(f, encoding='iso-8859-1')
2807 result = f.getvalue()
2808 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2809 self.assertEncodingDeclaration(result,'iso-8859-1')
2810 result = result.split('?>', 1)[-1].replace('\n','')
2811 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2812 result)
2813
2828
2830 XMLParser = self.etree.XMLParser
2831
2832 text = u'Søk på nettet'
2833 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
2834 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text)
2835 ).encode('iso-8859-1')
2836
2837 self.assertRaises(self.etree.ParseError,
2838 self.etree.parse,
2839 StringIO(xml_latin1))
2840
2841 tree = self.etree.parse(StringIO(xml_latin1),
2842 XMLParser(encoding="iso-8859-1"))
2843 a = tree.getroot()
2844 self.assertEquals(a.text, text)
2845
2847
2848 XML = self.etree.XML
2849 test_utf = (u'<?xml version="1.0" encoding="iso-8859-1"?>' + \
2850 u'<a>Søk på nettet</a>')
2851 self.assertRaises(SyntaxError, XML, test_utf)
2852
2867
2876
2885
2896
2908
2921
2935
2937 utext = u'Søk på nettet'
2938 uxml = u'<p>%s</p>' % utext
2939 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2940 isoxml = prologue + uxml.encode('iso-8859-1')
2941 tree = self.etree.XML(isoxml)
2942 self.assertEquals(utext, tree.text)
2943
2945 utext = u'Søk på nettet'
2946 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \
2947 u'<p>%s</p>' % utext
2948 bom = '\xEF\xBB\xBF'
2949 xml = bom + uxml.encode("utf-8")
2950 tree = etree.XML(xml)
2951 self.assertEquals(utext, tree.text)
2952
2954 utext = u'Søk på nettet'
2955 uxml = u'<p>%s</p>' % utext
2956 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2957 isoxml = prologue + uxml.encode('iso-8859-1')
2958 el = self.etree.parse(StringIO(isoxml)).getroot()
2959 self.assertEquals(utext, el.text)
2960
2974
2976 Element = self.etree.Element
2977
2978 a = Element('a')
2979 a.text = 'Foo'
2980
2981 b = copy.deepcopy(a)
2982 self.assertEquals('Foo', b.text)
2983
2984 b.text = 'Bar'
2985 self.assertEquals('Bar', b.text)
2986 self.assertEquals('Foo', a.text)
2987
2988 del a
2989 self.assertEquals('Bar', b.text)
2990
2992 Element = self.etree.Element
2993
2994 a = Element('a')
2995 a.tail = 'Foo'
2996
2997 b = copy.deepcopy(a)
2998 self.assertEquals('Foo', b.tail)
2999
3000 b.tail = 'Bar'
3001 self.assertEquals('Bar', b.tail)
3002 self.assertEquals('Foo', a.tail)
3003
3004 del a
3005 self.assertEquals('Bar', b.tail)
3006
3008 Element = self.etree.Element
3009 SubElement = self.etree.SubElement
3010
3011 root = Element('root')
3012 a = SubElement(root, 'a')
3013 a.text = 'FooText'
3014 a.tail = 'FooTail'
3015
3016 b = copy.deepcopy(a)
3017 self.assertEquals('FooText', b.text)
3018 self.assertEquals('FooTail', b.tail)
3019
3020 b.text = 'BarText'
3021 b.tail = 'BarTail'
3022 self.assertEquals('BarTail', b.tail)
3023 self.assertEquals('FooTail', a.tail)
3024 self.assertEquals('BarText', b.text)
3025 self.assertEquals('FooText', a.text)
3026
3027 del a
3028 self.assertEquals('BarTail', b.tail)
3029 self.assertEquals('BarText', b.text)
3030
3032 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
3033 <parent><node t:foo="bar" /></parent>
3034 </doc>''')
3035 self.assertEquals(
3036 root[0][0].get('{tns}foo'),
3037 copy.deepcopy(root[0])[0].get('{tns}foo') )
3038 self.assertEquals(
3039 root[0][0].get('{tns}foo'),
3040 copy.deepcopy(root[0][0]).get('{tns}foo') )
3041
3056
3068
3081
3082
3095
3097
3098 etree = self.etree
3099 e = etree.Element('foo')
3100 self.assertEquals(False, bool(e))
3101 etree.SubElement(e, 'bar')
3102 self.assertEquals(True, bool(e))
3103 e = etree.Element('foo')
3104 e.text = 'hey'
3105 self.assertEquals(False, bool(e))
3106 e = etree.Element('foo')
3107 e.tail = 'bar'
3108 self.assertEquals(False, bool(e))
3109 e = etree.Element('foo')
3110 e.set('bar', 'Bar')
3111 self.assertEquals(False, bool(e))
3112
3114 etree = self.etree
3115
3116 a = etree.Element('a')
3117 b = etree.SubElement(a, 'b')
3118
3119 t = etree.ElementTree(a)
3120 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3121
3122 t1 = etree.ElementTree(a)
3123 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
3124 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3125
3126 t2 = etree.ElementTree(b)
3127 self.assertEquals(self._rootstring(t2), '<b/>')
3128 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
3129 self.assertEquals(self._rootstring(t), '<a><b/></a>')
3130
3138
3140 etree = self.etree
3141 qname1 = etree.QName('myns', 'a')
3142 qname2 = etree.QName('myns', 'a')
3143 self.assertEquals(qname1, "{myns}a")
3144 self.assertEquals("{myns}a", qname2)
3145 self.assertEquals(qname1, qname1)
3146 self.assertEquals(qname1, qname2)
3147
3149 etree = self.etree
3150 qname = etree.QName('myns', 'a')
3151
3152 a = etree.Element(qname)
3153 a.set(qname, "value")
3154
3155 self.assertEquals(a.get(qname), "value")
3156 self.assertEquals(a.get("{myns}a"), "value")
3157
3159 etree = self.etree
3160 qname = etree.QName('myns', 'a')
3161
3162 a = etree.Element(qname)
3163 a.attrib[qname] = "value"
3164
3165 self.assertEquals(a.attrib[qname], "value")
3166 self.assertEquals(a.attrib.get(qname), "value")
3167
3168 self.assertEquals(a.attrib["{myns}a"], "value")
3169 self.assertEquals(a.attrib.get("{myns}a"), "value")
3170
3172 etree = self.etree
3173 qname = etree.QName('http://myns', 'a')
3174 a = etree.Element(qname)
3175 a.set(qname, qname)
3176
3177 self.assertXML(
3178 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>',
3179 a)
3180
3190
3200
3207
3208
3209
3225
3230
3239
3253
3264
3265
3266
3268 assertEquals = self.assertEquals
3269 assertFalse = self.assertFalse
3270
3271 events = []
3272 class Target(object):
3273 def start(self, tag, attrib):
3274 events.append("start")
3275 assertFalse(attrib)
3276 assertEquals("TAG", tag)
3277 def end(self, tag):
3278 events.append("end")
3279 assertEquals("TAG", tag)
3280 def close(self):
3281 return "DONE"
3282
3283 parser = self.etree.XMLParser(target=Target())
3284
3285 parser.feed("<TAG/>")
3286 done = parser.close()
3287
3288 self.assertEquals("DONE", done)
3289 self.assertEquals(["start", "end"], events)
3290
3292 assertEquals = self.assertEquals
3293
3294 events = []
3295 class Target(object):
3296 def start(self, tag, attrib):
3297 events.append("start-" + tag)
3298 for name, value in attrib.iteritems():
3299 assertEquals(tag + name, value)
3300 def end(self, tag):
3301 events.append("end-" + tag)
3302 def close(self):
3303 return "DONE"
3304
3305 parser = self.etree.XMLParser(target=Target())
3306
3307 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3308 done = parser.close()
3309
3310 self.assertEquals("DONE", done)
3311 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3312 events)
3313
3315 events = []
3316 class Target(object):
3317 def start(self, tag, attrib):
3318 events.append("start-" + tag)
3319 def end(self, tag):
3320 events.append("end-" + tag)
3321 def data(self, data):
3322 events.append("data-" + data)
3323 def close(self):
3324 return "DONE"
3325
3326 parser = self.etree.XMLParser(target=Target())
3327
3328 parser.feed('<root>A<sub/>B</root>')
3329 done = parser.close()
3330
3331 self.assertEquals("DONE", done)
3332 self.assertEquals(["start-root", "data-A", "start-sub",
3333 "end-sub", "data-B", "end-root"],
3334 events)
3335
3337 events = []
3338 class Target(object):
3339 def __init__(self):
3340 self._data = []
3341 def _flush_data(self):
3342 if self._data:
3343 events.append("data-" + ''.join(self._data))
3344 del self._data[:]
3345 def start(self, tag, attrib):
3346 self._flush_data()
3347 events.append("start-" + tag)
3348 def end(self, tag):
3349 self._flush_data()
3350 events.append("end-" + tag)
3351 def data(self, data):
3352 self._data.append(data)
3353 def close(self):
3354 self._flush_data()
3355 return "DONE"
3356
3357 parser = self.etree.XMLParser(target=Target())
3358
3359 dtd = '''
3360 <!DOCTYPE root [
3361 <!ELEMENT root (sub*)>
3362 <!ELEMENT sub (#PCDATA)>
3363 <!ENTITY ent "an entity">
3364 ]>
3365 '''
3366 parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
3367 done = parser.close()
3368
3369 self.assertEquals("DONE", done)
3370 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
3371 "data-this is an entity",
3372 "end-sub", "start-sub", "end-sub", "end-root"],
3373 events)
3374
3376 events = []
3377 class Target(object):
3378 def __init__(self):
3379 self._data = []
3380 def _flush_data(self):
3381 if self._data:
3382 events.append("data-" + ''.join(self._data))
3383 del self._data[:]
3384 def start(self, tag, attrib):
3385 self._flush_data()
3386 events.append("start-" + tag)
3387 def end(self, tag):
3388 self._flush_data()
3389 events.append("end-" + tag)
3390 def data(self, data):
3391 self._data.append(data)
3392 def close(self):
3393 self._flush_data()
3394 return "DONE"
3395
3396 parser = self.etree.XMLParser(target=Target())
3397
3398 def feed():
3399 parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
3400 parser.close()
3401
3402 self.assertRaises(self.etree.ParseError, feed)
3403
3405 builder = self.etree.TreeBuilder()
3406 el = builder.start("root", {'a':'A', 'b':'B'})
3407 self.assertEquals("root", el.tag)
3408 self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3409 builder.data("ROOTTEXT")
3410 el = builder.start("child", {'x':'X', 'y':'Y'})
3411 self.assertEquals("child", el.tag)
3412 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3413 builder.data("CHILDTEXT")
3414 el = builder.end("child")
3415 self.assertEquals("child", el.tag)
3416 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3417 self.assertEquals("CHILDTEXT", el.text)
3418 self.assertEquals(None, el.tail)
3419 builder.data("CHILDTAIL")
3420 root = builder.end("root")
3421
3422 self.assertEquals("root", root.tag)
3423 self.assertEquals("ROOTTEXT", root.text)
3424 self.assertEquals("CHILDTEXT", root[0].text)
3425 self.assertEquals("CHILDTAIL", root[0].tail)
3426
3436
3437
3438
3446
3466
3467 - def assertXML(self, expected, element, encoding='us-ascii'):
3468 """Writes element out and checks whether it is expected.
3469
3470 Does this two ways; once using StringIO, once using a real file.
3471 """
3472 self.assertEquals(expected, self._writeElement(element, encoding))
3473 self.assertEquals(expected, self._writeElementFile(element, encoding))
3474
3476 "Checks if the result XML byte string specifies the encoding."
3477 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
3478 self.assert_(has_encoding(result))
3479 result_encoding = has_encoding(result).group(1)
3480 self.assertEquals(result_encoding.upper(), encoding.upper())
3481
3483 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
3484
3486 self._check_element(tree.getroot())
3487
3489 self.assert_(hasattr(element, 'tag'))
3490 self.assert_(hasattr(element, 'attrib'))
3491 self.assert_(hasattr(element, 'text'))
3492 self.assert_(hasattr(element, 'tail'))
3493 self._check_string(element.tag)
3494 self._check_mapping(element.attrib)
3495 if element.text != None:
3496 self._check_string(element.text)
3497 if element.tail != None:
3498 self._check_string(element.tail)
3499
3501 len(string)
3502 for char in string:
3503 self.assertEquals(1, len(char))
3504 new_string = string + ""
3505 new_string = string + " "
3506 string[:0]
3507
3509 len(mapping)
3510 keys = mapping.keys()
3511 items = mapping.items()
3512 for key in keys:
3513 item = mapping[key]
3514 mapping["key"] = "value"
3515 self.assertEquals("value", mapping["key"])
3516
3517
3518 if etree:
3521
3522 if ElementTree:
3525
3526 if cElementTree:
3529
3539
3540 if __name__ == '__main__':
3541 print 'to test use test.py %s' % __file__
3542