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, shutil, tempfile, copy
13
14 from common_imports import StringIO, etree, ElementTree
15 from common_imports import HelperTestCase, fileInTestDir, canonicalize
16
18 etree = None
19
21 self._temp_dir = tempfile.mkdtemp()
22
24 shutil.rmtree(self._temp_dir)
25
27 return os.path.join(self._temp_dir, name)
28
32
34 Element = self.etree.Element
35 ElementTree = self.etree.ElementTree
36
37 element = Element('top')
38 tree = ElementTree(element)
39 self.buildNodes(element, 10, 3)
40 f = open(self.getTestFilePath('testdump.xml'), 'w')
41 tree.write(f, 'UTF-8')
42 f.close()
43 f = open(self.getTestFilePath('testdump.xml'), 'r')
44 tree = ElementTree(file=f)
45 f.close()
46 f = open(self.getTestFilePath('testdump2.xml'), 'w')
47 tree.write(f, 'UTF-8')
48 f.close()
49 f = open(self.getTestFilePath('testdump.xml'), 'r')
50 data1 = f.read()
51 f.close()
52 f = open(self.getTestFilePath('testdump2.xml'), 'r')
53 data2 = f.read()
54 f.close()
55 self.assertEquals(data1, data2)
56
58 Element = self.etree.Element
59
60 if depth == 0:
61 return
62 for i in range(children):
63 new_element = Element('element_%s_%s' % (depth, i))
64 self.buildNodes(new_element, children, depth - 1)
65 element.append(new_element)
66
68 Element = self.etree.Element
69
70 root = Element('root')
71 root.append(Element('one'))
72 root.append(Element('two'))
73 root.append(Element('three'))
74 self.assertEquals(3, len(root))
75 self.assertEquals('one', root[0].tag)
76 self.assertEquals('two', root[1].tag)
77 self.assertEquals('three', root[2].tag)
78 self.assertRaises(IndexError, root.__getitem__, 3)
79
92
110
112 ElementTree = self.etree.ElementTree
113
114 f = StringIO('<doc>Test<one>One</one></doc>')
115 doc = ElementTree(file=f)
116 root = doc.getroot()
117 self.assertEquals(1, len(root))
118 self.assertEquals('one', root[0].tag)
119 self.assertRaises(IndexError, root.__getitem__, 1)
120
122 ElementTree = self.etree.ElementTree
123
124 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
125 doc = ElementTree(file=f)
126 root = doc.getroot()
127 self.assertEquals(3, len(root))
128 self.assertEquals('one', root[0].tag)
129 self.assertEquals('two', root[1].tag)
130 self.assertEquals('three', root[2].tag)
131
133 ElementTree = self.etree.ElementTree
134
135 f = StringIO('<doc>Test</doc>')
136 doc = ElementTree(file=f)
137 root = doc.getroot()
138 self.assertEquals(0, len(root))
139
141 Element = self.etree.Element
142 SubElement = self.etree.SubElement
143 a = Element('a')
144 b = SubElement(a, 'b')
145 c = SubElement(a, 'c')
146 d = SubElement(a, 'd')
147 self.assertEquals(d, a[-1])
148 self.assertEquals(c, a[-2])
149 self.assertEquals(b, a[-3])
150 self.assertRaises(IndexError, a.__getitem__, -4)
151 a[-1] = e = Element('e')
152 self.assertEquals(e, a[-1])
153 del a[-1]
154 self.assertEquals(2, len(a))
155
157 ElementTree = self.etree.ElementTree
158
159 f = StringIO('<doc><one>One</one><two>Two</two></doc>')
160 doc = ElementTree(file=f)
161 root = doc.getroot()
162 self.assertEquals(2, len(root))
163 self.assertEquals('one', root[0].tag)
164 self.assertEquals('two', root[1].tag)
165
166 - def test_text(self):
167 ElementTree = self.etree.ElementTree
168
169 f = StringIO('<doc>This is a text</doc>')
170 doc = ElementTree(file=f)
171 root = doc.getroot()
172 self.assertEquals('This is a text', root.text)
173
174 - def test_text_empty(self):
175 ElementTree = self.etree.ElementTree
176
177 f = StringIO('<doc></doc>')
178 doc = ElementTree(file=f)
179 root = doc.getroot()
180 self.assertEquals(None, root.text)
181
182 - def test_text_other(self):
183 ElementTree = self.etree.ElementTree
184
185 f = StringIO('<doc><one>One</one></doc>')
186 doc = ElementTree(file=f)
187 root = doc.getroot()
188 self.assertEquals(None, root.text)
189 self.assertEquals('One', root[0].text)
190
192 ElementTree = self.etree.ElementTree
193
194 f = StringIO('<doc>This is > than a text</doc>')
195 doc = ElementTree(file=f)
196 root = doc.getroot()
197 self.assertEquals('This is > than a text', root.text)
198
200 Element = self.etree.Element
201
202 a = Element("a")
203 a.text = "<>&"
204 self.assertXML('<a><>&</a>',
205 a)
206
208 tostring = self.etree.tostring
209 Element = self.etree.Element
210
211 a = Element("a")
212 a.text = "<>&"
213 self.assertEquals('<a><>&</a>',
214 tostring(a))
215
217 Element = self.etree.Element
218
219 class strTest(str):
220 pass
221
222 a = Element("a")
223 a.text = strTest("text")
224 self.assertXML('<a>text</a>',
225 a)
226
228 ElementTree = self.etree.ElementTree
229
230 f = StringIO('<doc>This is <i>mixed</i> content.</doc>')
231 doc = ElementTree(file=f)
232 root = doc.getroot()
233 self.assertEquals(1, len(root))
234 self.assertEquals('This is ', root.text)
235 self.assertEquals(None, root.tail)
236 self.assertEquals('mixed', root[0].text)
237 self.assertEquals(' content.', root[0].tail)
238
245
246 a = Element("a")
247 SubElement(a, "t").tail = strTest("tail")
248 self.assertXML('<a><t></t>tail</a>',
249 a)
250
260
262 ElementTree = self.etree.ElementTree
263
264 f = StringIO('<doc one="One" two="Two"/>')
265 doc = ElementTree(file=f)
266 root = doc.getroot()
267 self.assertEquals('One', root.attrib['one'])
268 self.assertEquals('Two', root.attrib['two'])
269 self.assertRaises(KeyError, root.attrib.__getitem__, 'three')
270
272 ElementTree = self.etree.ElementTree
273
274 f = StringIO('<doc one="One" two="Two"/>')
275 doc = ElementTree(file=f)
276 root = doc.getroot()
277 self.assertEquals('One', root.attrib.get('one'))
278 self.assertEquals('Two', root.attrib.get('two'))
279 self.assertEquals(None, root.attrib.get('three'))
280 self.assertEquals('foo', root.attrib.get('three', 'foo'))
281
283 ElementTree = self.etree.ElementTree
284
285 f = StringIO('<doc one="One" two="Two"/>')
286 doc = ElementTree(file=f)
287 root = doc.getroot()
288 self.assertEquals('One', root.get('one'))
289 self.assertEquals('Two', root.get('two'))
290 self.assertEquals(None, root.get('three'))
291 self.assertEquals('foo', root.get('three', 'foo'))
292
294 XML = self.etree.XML
295
296 root = XML('<doc one="One" two="Two"/>')
297 self.assertEquals('One', root.get('one'))
298 self.assertEquals('Two', root.get('two'))
299 root.attrib.clear()
300 self.assertEquals(None, root.get('one'))
301 self.assertEquals(None, root.get('two'))
302
304 Element = self.etree.Element
305
306 root = Element("root", one="One")
307 root.set("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 XML = self.etree.XML
316
317 root = XML('<doc alpha="Alpha" beta="Beta"/>')
318 items = root.attrib.items()
319 items.sort()
320 self.assertEquals(
321 [('alpha', 'Alpha'), ('beta', 'Beta')],
322 items)
323
324 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
325
326 items = root.attrib.items()
327 items.sort()
328 self.assertEquals(
329 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
330 items)
331
333 XML = self.etree.XML
334
335 root = XML('<doc alpha="Alpha" beta="Beta"/>')
336 items = root.attrib.items()
337 items.sort()
338 self.assertEquals(
339 [('alpha', 'Alpha'), ('beta', 'Beta')],
340 items)
341
342 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
343
344 items = root.attrib.items()
345 items.sort()
346 self.assertEquals(
347 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
348 items)
349
351 XML = self.etree.XML
352
353 root = XML('<doc alpha="Alpha" beta="Beta"/>')
354 items = root.attrib.items()
355 items.sort()
356 self.assertEquals(
357 [('alpha', 'Alpha'), ('beta', 'Beta')],
358 items)
359
360 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems())
361
362 items = root.attrib.items()
363 items.sort()
364 self.assertEquals(
365 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
366 items)
367
369 XML = self.etree.XML
370
371 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
372 keys = root.attrib.keys()
373 keys.sort()
374 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
375
377 XML = self.etree.XML
378
379 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
380 keys = root.keys()
381 keys.sort()
382 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
383
385 XML = self.etree.XML
386
387 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
388 items = root.items()
389 items.sort()
390 self.assertEquals(
391 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
392 items)
393
395 XML = self.etree.XML
396
397 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
398 keys = root.keys()
399 keys.sort()
400 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
401 keys)
402
404 XML = self.etree.XML
405
406 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
407 values = root.attrib.values()
408 values.sort()
409 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
410
412 XML = self.etree.XML
413
414 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
415 values = root.attrib.values()
416 values.sort()
417 self.assertEquals(
418 ['Bar', 'Baz'], values)
419
421 XML = self.etree.XML
422
423 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
424 items = root.attrib.items()
425 items.sort()
426 self.assertEquals([
427 ('alpha', 'Alpha'),
428 ('beta', 'Beta'),
429 ('gamma', 'Gamma'),
430 ],
431 items)
432
434 XML = self.etree.XML
435
436 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
437 items = root.attrib.items()
438 items.sort()
439 self.assertEquals(
440 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
441 items)
442
444 XML = self.etree.XML
445
446 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
447
448 self.assertEquals(
449 "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}",
450 str(root.attrib))
451
453 XML = self.etree.XML
454
455 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
456 self.assertEquals(
457 True, root.attrib.has_key('bar'))
458 self.assertEquals(
459 False, root.attrib.has_key('baz'))
460 self.assertEquals(
461 False, root.attrib.has_key('hah'))
462 self.assertEquals(
463 True,
464 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
465
467 XML = self.etree.XML
468
469 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
470 self.assertEquals(
471 True, 'bar' in root.attrib)
472 self.assertEquals(
473 False, 'baz' in root.attrib)
474 self.assertEquals(
475 False, 'hah' in root.attrib)
476 self.assertEquals(
477 True,
478 '{http://ns.codespeak.net/test}baz' in root.attrib)
479
481 Element = self.etree.Element
482
483 root = Element("root")
484 root.set("attr", "TEST")
485 self.assertEquals("TEST", root.get("attr"))
486
488 XML = self.etree.XML
489
490 root = XML('<doc>This is a text.</doc>')
491 self.assertEquals(0, len(root))
492 self.assertEquals('This is a text.', root.text)
493
495 XMLID = self.etree.XMLID
496 XML = self.etree.XML
497 xml_text = '''
498 <document>
499 <h1 id="chapter1">...</h1>
500 <p id="note1" class="note">...</p>
501 <p>Regular paragraph.</p>
502 <p xml:id="xmlid">XML:ID paragraph.</p>
503 <p id="warn1" class="warning">...</p>
504 </document>
505 '''
506
507 root, dic = XMLID(xml_text)
508 root2 = XML(xml_text)
509 self.assertEquals(self._writeElement(root),
510 self._writeElement(root2))
511 expected = {
512 "chapter1" : root[0],
513 "note1" : root[1],
514 "warn1" : root[4]
515 }
516 self.assertEquals(dic, expected)
517
524
548
550 XML = self.etree.XML
551
552 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
553 result = []
554 for el in root:
555 result.append(el.tag)
556 self.assertEquals(['one', 'two', 'three'], result)
557
559 XML = self.etree.XML
560
561 root = XML('<doc></doc>')
562 result = []
563 for el in root:
564 result.append(el.tag)
565 self.assertEquals([], result)
566
568 XML = self.etree.XML
569
570 root = XML('<doc>Text</doc>')
571 result = []
572 for el in root:
573 result.append(el.tag)
574 self.assertEquals([], result)
575
582
584 XML = self.etree.XML
585
586 try:
587 reversed(())
588 except NameError:
589
590 return
591
592 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
593 result = []
594 for el in reversed(root):
595 result.append(el.tag)
596 self.assertEquals(['three', 'two', 'one'], result)
597
599 XML = self.etree.XML
600
601 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
602 result = []
603 add = True
604 for el in root:
605 result.append(el.tag)
606 if add:
607 self.etree.SubElement(root, 'four')
608 add = False
609 self.assertEquals(['one', 'two', 'three', 'four'], result)
610
612 XML = self.etree.XML
613
614 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
615 result = []
616 for el in root:
617 result.append(el.tag)
618 del root[-1]
619 self.assertEquals(['one', 'two'], result)
620
622 XML = self.etree.XML
623
624 root = XML('<doc><one/><two/></doc>')
625 result = []
626 for el0 in root:
627 result.append(el0.tag)
628 for el1 in root:
629 result.append(el1.tag)
630 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
631
633 XML = self.etree.XML
634
635 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')
636 result = []
637 for key in root.attrib:
638 result.append(key)
639 result.sort()
640 self.assertEquals(['alpha', 'beta', 'gamma'], result)
641
643 XML = self.etree.XML
644 root = XML('<a><b><c/></b><b/><c><b/></c></a>')
645 self.assertEquals(len(root.findall("c")), 1)
646 self.assertEquals(len(root.findall(".//c")), 2)
647 self.assertEquals(len(root.findall(".//b")), 3)
648 self.assertEquals(len(root.findall(".//b")[0]), 1)
649 self.assertEquals(len(root.findall(".//b")[1]), 0)
650 self.assertEquals(len(root.findall(".//b")[2]), 0)
651
653 XML = self.etree.XML
654 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
655 self.assertEquals(len(root.findall(".//{X}b")), 2)
656 self.assertEquals(len(root.findall(".//b")), 3)
657 self.assertEquals(len(root.findall("b")), 2)
658
665
672
674 Element = self.etree.Element
675
676 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
677 self.assertEquals('Foo', el.attrib['{ns1}foo'])
678 self.assertEquals('Bar', el.attrib['{ns2}bar'])
679
688
697
699 ElementTree = self.etree.ElementTree
700 XML = self.etree.XML
701
702 for i in range(10):
703 f = StringIO()
704 root = XML('<doc%s>This is a test.</doc%s>' % (i, i))
705 tree = ElementTree(element=root)
706 tree.write(f)
707 data = f.getvalue()
708 self.assertEquals(
709 '<doc%s>This is a test.</doc%s>' % (i, i),
710 canonicalize(data))
711
719
720
721
723 Element = self.etree.Element
724
725 element = Element('tag')
726 for i in range(10):
727 element.attrib['key'] = 'value'
728 value = element.attrib['key']
729 self.assertEquals(value, 'value')
730
731
743
766
767 - def test_set_text(self):
768 Element = self.etree.Element
769 SubElement = self.etree.SubElement
770
771 a = Element('a')
772 b = SubElement(a, 'b')
773 a.text = 'hoi'
774 self.assertEquals(
775 'hoi',
776 a.text)
777 self.assertEquals(
778 'b',
779 a[0].tag)
780
781 - def test_set_text2(self):
782 Element = self.etree.Element
783 SubElement = self.etree.SubElement
784
785 a = Element('a')
786 a.text = 'hoi'
787 b = SubElement(a ,'b')
788 self.assertEquals(
789 'hoi',
790 a.text)
791 self.assertEquals(
792 'b',
793 a[0].tag)
794
796 Element = self.etree.Element
797
798 a = Element('a')
799
800 a.text = 'foo'
801 a.text = None
802
803 self.assertEquals(
804 None,
805 a.text)
806 self.assertXML('<a></a>', a)
807
809 Element = self.etree.Element
810
811 a = Element('a')
812 self.assertEquals(None, a.text)
813
814 a.text = ''
815 self.assertEquals('', a.text)
816 self.assertXML('<a></a>', a)
817
832
842
854
864
874
886
895
907
919
921 ProcessingInstruction = self.etree.ProcessingInstruction
922 pi = ProcessingInstruction('foo')
923 self.assertEquals({}, pi.attrib)
924 self.assertEquals([], pi.keys())
925 self.assertEquals([], pi.items())
926 self.assertEquals(None, pi.get('hoi'))
927 self.assertEquals(0, len(pi))
928
929 for i in pi:
930 pass
931
947
965
975
984
999
1016
1034
1053
1059
1060 a = Element("a")
1061 a.tag = strTest("TAG")
1062 self.assertXML('<TAG></TAG>',
1063 a)
1064
1094
1096 Element = self.etree.Element
1097 SubElement = self.etree.SubElement
1098
1099 a = Element('a')
1100 b = SubElement(a, 'b')
1101 bs = SubElement(b, 'bs')
1102 c = SubElement(a, 'c')
1103 cs = SubElement(c, 'cs')
1104
1105 el = a[0]
1106 self.assertXML(
1107 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1108 a)
1109 self.assertXML('<b><bs></bs></b>', b)
1110 self.assertXML('<c><cs></cs></c>', c)
1111
1112 del a[0]
1113 self.assertXML(
1114 '<a><c><cs></cs></c></a>',
1115 a)
1116 self.assertXML('<b><bs></bs></b>', b)
1117 self.assertXML('<c><cs></cs></c>', c)
1118
1119 a.insert(0, el)
1120 self.assertXML(
1121 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1122 a)
1123 self.assertXML('<b><bs></bs></b>', b)
1124 self.assertXML('<c><cs></cs></c>', c)
1125
1144
1163
1165 XML = self.etree.XML
1166 a = XML('<a><b></b>B2<c></c>C2</a>')
1167 b, c = a
1168
1169 del a[:]
1170
1171 self.assertEquals("B2", b.tail)
1172 self.assertEquals("C2", c.tail)
1173
1175 XML = self.etree.XML
1176 a = XML('<a><b></b>B2<c></c>C2</a>')
1177 b, c = a
1178
1179 a[:] = []
1180
1181 self.assertEquals("B2", b.tail)
1182 self.assertEquals("C2", c.tail)
1183
1193
1195 Element = self.etree.Element
1196
1197 a = Element('a')
1198 a.text = 'foo'
1199 a.tail = 'bar'
1200 a.set('hoi', 'dag')
1201 a.clear()
1202 self.assertEquals(None, a.text)
1203 self.assertEquals(None, a.tail)
1204 self.assertEquals(None, a.get('hoi'))
1205 self.assertEquals('a', a.tag)
1206
1208 Element = self.etree.Element
1209 SubElement = self.etree.SubElement
1210
1211 a = Element('a')
1212 a.text = 'foo'
1213 a.tail = 'bar'
1214 a.set('hoi', 'dag')
1215 b = SubElement(a, 'b')
1216 c = SubElement(b, 'c')
1217 a.clear()
1218 self.assertEquals(None, a.text)
1219 self.assertEquals(None, a.tail)
1220 self.assertEquals(None, a.get('hoi'))
1221 self.assertEquals('a', a.tag)
1222 self.assertEquals(0, len(a))
1223 self.assertXML('<a></a>',
1224 a)
1225 self.assertXML('<b><c></c></b>',
1226 b)
1227
1237
1264
1280
1297
1312
1328
1344
1355
1368
1390
1399
1401 Element = self.etree.Element
1402 SubElement = self.etree.SubElement
1403
1404 a = Element('a')
1405 b = SubElement(a, 'b')
1406 c = SubElement(a, 'c')
1407 d = SubElement(b, 'd')
1408 e = SubElement(c, 'e')
1409
1410 self.assertEquals(
1411 [a, b, d, c, e],
1412 list(a.getiterator()))
1413 self.assertEquals(
1414 [d],
1415 list(d.getiterator()))
1416
1436
1457
1471
1496
1498 Element = self.etree.Element
1499 PI = self.etree.ProcessingInstruction
1500 SubElement = self.etree.SubElement
1501
1502 a = Element('a')
1503 b = SubElement(a, 'b')
1504 pi_b = PI("TEST-b")
1505 b.append(pi_b)
1506
1507 self.assertEquals(
1508 [pi_b],
1509 list(a.getiterator(PI)))
1510
1511 pi_a = PI("TEST-a")
1512 a.append(pi_a)
1513
1514 self.assertEquals(
1515 [pi_b, pi_a],
1516 list(a.getiterator(PI)))
1517
1518 self.assertEquals(
1519 [pi_b],
1520 list(b.getiterator(PI)))
1521
1523 Element = self.etree.Element
1524 SubElement = self.etree.SubElement
1525
1526 a = Element('a')
1527 a.text = 'a'
1528 b = SubElement(a, 'b')
1529 b.text = 'b'
1530 b.tail = 'b1'
1531 c = SubElement(a, 'c')
1532 c.text = 'c'
1533 c.tail = 'c1'
1534 d = SubElement(b, 'd')
1535 c.text = 'd'
1536 c.tail = 'd1'
1537 e = SubElement(c, 'e')
1538 e.text = 'e'
1539 e.tail = 'e1'
1540
1541 self.assertEquals(
1542 [a, b, d, c, e],
1543 list(a.getiterator()))
1544
1545
1546
1547
1549 Element = self.etree.Element
1550 SubElement = self.etree.SubElement
1551
1552 a = Element('a')
1553 a.text = 'a'
1554 b = SubElement(a, 'b')
1555 b.text = 'b'
1556 b.tail = 'b1'
1557 c = SubElement(a, 'c')
1558 c.text = 'c'
1559 c.tail = 'c1'
1560 d = SubElement(b, 'd')
1561 c.text = 'd'
1562 c.tail = 'd1'
1563 e = SubElement(c, 'e')
1564 e.text = 'e'
1565 e.tail = 'e1'
1566
1567 self.assertEquals(
1568 [a],
1569 list(a.getiterator('a')))
1570 a2 = SubElement(e, 'a')
1571 self.assertEquals(
1572 [a, a2],
1573 list(a.getiterator('a')))
1574 self.assertEquals(
1575 [a2],
1576 list(e.getiterator('a')))
1577
1587
1589 Element = self.etree.Element
1590 SubElement = self.etree.SubElement
1591
1592 a = Element('a')
1593 b = SubElement(a, 'b')
1594 c = SubElement(a, 'c')
1595 d = SubElement(a, 'd')
1596
1597 self.assertEquals(
1598 [b, c],
1599 a[0:2])
1600 self.assertEquals(
1601 [b, c, d],
1602 a[:])
1603 self.assertEquals(
1604 [b, c, d],
1605 a[:10])
1606 self.assertEquals(
1607 [b],
1608 a[0:1])
1609 self.assertEquals(
1610 [],
1611 a[10:12])
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(a, 'd')
1621
1622 self.assertEquals(
1623 [d],
1624 a[-1:])
1625 self.assertEquals(
1626 [c, d],
1627 a[-2:])
1628 self.assertEquals(
1629 [c],
1630 a[-2:-1])
1631 self.assertEquals(
1632 [b, c],
1633 a[-3:-1])
1634 self.assertEquals(
1635 [b, c],
1636 a[-3:2])
1637
1639 ElementTree = self.etree.ElementTree
1640
1641 f = StringIO('<a><b>B</b>B1<c>C</c>C1</a>')
1642 doc = ElementTree(file=f)
1643 a = doc.getroot()
1644 b = a[0]
1645 c = a[1]
1646 self.assertEquals(
1647 [b, c],
1648 a[:])
1649 self.assertEquals(
1650 [b],
1651 a[0:1])
1652 self.assertEquals(
1653 [c],
1654 a[1:])
1655
1679
1694
1709
1724
1726 ElementTree = self.etree.ElementTree
1727 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
1728 doc = ElementTree(file=f)
1729 a = doc.getroot()
1730 del a[1:3]
1731 self.assertXML(
1732 '<a><b></b>B2<e></e>E2</a>',
1733 a)
1734
1745
1747 Element = self.etree.Element
1748 SubElement = self.etree.SubElement
1749
1750 a = Element('a')
1751 b = SubElement(a, 'b')
1752 c = SubElement(a, 'c')
1753 d = SubElement(a, 'd')
1754
1755 e = Element('e')
1756 f = Element('f')
1757 g = Element('g')
1758
1759 s = [e, f, g]
1760 a[1:2] = s
1761 self.assertEquals(
1762 [b, e, f, g, d],
1763 list(a))
1764
1781
1798
1800 Element = self.etree.Element
1801 SubElement = self.etree.SubElement
1802
1803 a = Element('a')
1804 b = SubElement(a, 'b')
1805 c = SubElement(a, 'c')
1806 d = SubElement(a, 'd')
1807
1808 e = Element('e')
1809 f = Element('f')
1810 g = Element('g')
1811
1812 s = [e, f, g]
1813 a[3:] = s
1814 self.assertEquals(
1815 [b, c, d, e, f, g],
1816 list(a))
1817
1830
1840
1856
1875
1877 ElementTree = self.etree.ElementTree
1878 ns = 'http://xml.infrae.com/1'
1879 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
1880 t = ElementTree(file=f)
1881 a = t.getroot()
1882 self.assertEquals('{%s}a' % ns,
1883 a.tag)
1884 self.assertEquals('{%s}b' % ns,
1885 a[0].tag)
1886
1888 ElementTree = self.etree.ElementTree
1889 ns = 'http://xml.infrae.com/1'
1890 ns2 = 'http://xml.infrae.com/2'
1891 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
1892 t = ElementTree(file=f)
1893 a = t.getroot()
1894 self.assertEquals('{%s}a' % ns,
1895 a.tag)
1896 self.assertEquals('{%s}b' % ns,
1897 a[0].tag)
1898 self.assertEquals('{%s}b' % ns2,
1899 a[1].tag)
1900
1902 Element = self.etree.Element
1903 SubElement = self.etree.SubElement
1904 ns = 'http://xml.infrae.com/1'
1905 ns2 = 'http://xml.infrae.com/2'
1906 a = Element('{%s}a' % ns)
1907 b = SubElement(a, '{%s}b' % ns2)
1908 c = SubElement(a, '{%s}c' % ns)
1909 self.assertEquals('{%s}a' % ns,
1910 a.tag)
1911 self.assertEquals('{%s}b' % ns2,
1912 b.tag)
1913 self.assertEquals('{%s}c' % ns,
1914 c.tag)
1915 self.assertEquals('{%s}a' % ns,
1916 a.tag)
1917 self.assertEquals('{%s}b' % ns2,
1918 b.tag)
1919 self.assertEquals('{%s}c' % ns,
1920 c.tag)
1921
1923 Element = self.etree.Element
1924 SubElement = self.etree.SubElement
1925 ElementTree = self.etree.ElementTree
1926
1927 ns = 'http://xml.infrae.com/1'
1928 ns2 = 'http://xml.infrae.com/2'
1929 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2))
1930 t = ElementTree(file=f)
1931
1932 a = t.getroot()
1933 self.assertEquals('{%s}a' % ns,
1934 a.tag)
1935 self.assertEquals('{%s}b' % ns2,
1936 a[0].tag)
1937 self.assertEquals('{%s}b' % ns,
1938 a[1].tag)
1939
1941 Element = self.etree.Element
1942 ns = 'http://xml.infrae.com/1'
1943 ns2 = 'http://xml.infrae.com/2'
1944 a = Element('a')
1945 a.set('{%s}foo' % ns, 'Foo')
1946 a.set('{%s}bar' % ns2, 'Bar')
1947 self.assertEquals(
1948 'Foo',
1949 a.get('{%s}foo' % ns))
1950 self.assertEquals(
1951 'Bar',
1952 a.get('{%s}bar' % ns2))
1953 self.assertXML(
1954 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2),
1955 a)
1956
1971
1973 tostring = self.etree.tostring
1974 root = self.etree.XML(
1975 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
1976 baz = root[0][0]
1977
1978 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
1979 tostring(baz))
1980 self.assertEquals(["http://a.b.c"], nsdecl)
1981
1983 tostring = self.etree.tostring
1984 root = self.etree.XML(
1985 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')
1986 baz = root[0][0]
1987
1988 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
1989 tostring(baz))
1990 self.assertEquals(["http://a.b.c"], nsdecl)
1991
1993 tostring = self.etree.tostring
1994 root = self.etree.XML(
1995 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')
1996 baz = root[0][0]
1997
1998 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
1999 tostring(baz))
2000
2001 self.assertEquals(["http://a.b.c"], nsdecl)
2002
2004 Element = self.etree.Element
2005
2006 root = Element('element')
2007
2008 subelement = Element('subelement',
2009 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2010 self.assertEquals(1, len(subelement.attrib))
2011 self.assertEquals(
2012 "foo",
2013 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2014
2015 root.append(subelement)
2016 self.assertEquals(1, len(subelement.attrib))
2017 self.assertEquals(
2018 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
2019 subelement.attrib.items())
2020 self.assertEquals(
2021 "foo",
2022 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2023
2035
2049
2063
2065 iterparse = self.etree.iterparse
2066 f = StringIO('<a><b></b><c/></a>')
2067
2068 iterator = iterparse(f)
2069 self.assertEquals(None,
2070 iterator.root)
2071 events = list(iterator)
2072 root = iterator.root
2073 self.assertEquals(
2074 [('end', root[0]), ('end', root[1]), ('end', root)],
2075 events)
2076
2078 iterparse = self.etree.iterparse
2079 iterator = iterparse(fileInTestDir("test.xml"))
2080 self.assertEquals(None,
2081 iterator.root)
2082 events = list(iterator)
2083 root = iterator.root
2084 self.assertEquals(
2085 [('end', root[0]), ('end', root)],
2086 events)
2087
2089 iterparse = self.etree.iterparse
2090 f = StringIO('<a><b></b><c/></a>')
2091
2092 iterator = iterparse(f, events=('start',))
2093 events = list(iterator)
2094 root = iterator.root
2095 self.assertEquals(
2096 [('start', root), ('start', root[0]), ('start', root[1])],
2097 events)
2098
2100 iterparse = self.etree.iterparse
2101 f = StringIO('<a><b></b><c/></a>')
2102
2103 iterator = iterparse(f, events=('start','end'))
2104 events = list(iterator)
2105 root = iterator.root
2106 self.assertEquals(
2107 [('start', root), ('start', root[0]), ('end', root[0]),
2108 ('start', root[1]), ('end', root[1]), ('end', root)],
2109 events)
2110
2112 iterparse = self.etree.iterparse
2113 f = StringIO('<a><b></b><c/></a>')
2114
2115 iterator = iterparse(f)
2116 for event, elem in iterator:
2117 elem.clear()
2118
2119 root = iterator.root
2120 self.assertEquals(0,
2121 len(root))
2122
2124 iterparse = self.etree.iterparse
2125 CHILD_COUNT = 12345
2126 f = StringIO('<a>' + ('<b>test</b>'*CHILD_COUNT) + '</a>')
2127
2128 i = 0
2129 for key in iterparse(f):
2130 event, element = key
2131 i += 1
2132 self.assertEquals(i, CHILD_COUNT + 1)
2133
2135 iterparse = self.etree.iterparse
2136 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2137
2138 attr_name = '{testns}bla'
2139 events = []
2140 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2141 for event, elem in iterator:
2142 events.append(event)
2143 if event == 'start':
2144 if elem.tag != '{ns1}a':
2145 elem.set(attr_name, 'value')
2146
2147 self.assertEquals(
2148 ['start-ns', 'start', 'start', 'start-ns', 'start',
2149 'end', 'end-ns', 'end', 'end', 'end-ns'],
2150 events)
2151
2152 root = iterator.root
2153 self.assertEquals(
2154 None,
2155 root.get(attr_name))
2156 self.assertEquals(
2157 'value',
2158 root[0].get(attr_name))
2159
2161 iterparse = self.etree.iterparse
2162 f = StringIO('<a><b><d/></b><c/></a>')
2163
2164 counts = []
2165 for event, elem in iterparse(f):
2166 counts.append(len(list(elem.getiterator())))
2167 self.assertEquals(
2168 [1,2,1,4],
2169 counts)
2170
2178
2182
2192
2194 parse = self.etree.parse
2195
2196 f = StringIO('<a><b></b></a>')
2197 tree = parse(f)
2198 f.close()
2199 self.assertXML(
2200 '<a><b></b></a>',
2201 tree.getroot()
2202 )
2203
2205
2206 parse = self.etree.parse
2207 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2208 self.assertXML('<html></html>',
2209 tree.getroot())
2210
2219
2232
2240
2242 parse = self.etree.parse
2243
2244 f = open(fileInTestDir('test-string.xml'), 'r')
2245 tree = parse(f)
2246 f.close()
2247 self.assertXML(
2248 u'<a>Søk på nettet</a>'.encode('UTF-8'),
2249 tree.getroot(), 'UTF-8')
2250
2252 ElementTree = self.etree.ElementTree
2253 Element = self.etree.Element
2254
2255 a = Element('a')
2256 a.text = u'Søk på nettet'
2257
2258 f = StringIO()
2259 tree = ElementTree(element=a)
2260 tree.write(f, 'iso-8859-1')
2261 result = f.getvalue()
2262 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2263 self.assertEncodingDeclaration(result,'iso-8859-1')
2264 result = result.split('?>', 1)[-1]
2265 if result[0] == '\n':
2266 result = result[1:]
2267 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2268 result)
2269
2270
2272 XML = self.etree.XML
2273 test_utf = u'<?xml version=\'1.0\' encoding=\'iso-8859-1\'?><a>Søk på nettet</a>'
2274 self.assertRaises(SyntaxError, XML, test_utf)
2275
2290
2299
2307
2318
2330
2343
2357
2359 utext = u'Søk på nettet'
2360 uxml = u'<p>%s</p>' % utext
2361 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2362 isoxml = prologue + uxml.encode('iso-8859-1')
2363 tree = self.etree.XML(isoxml)
2364 self.assertEquals(utext, tree.text)
2365
2367 utext = u'Søk på nettet'
2368 uxml = u'<p>%s</p>' % utext
2369 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2370 isoxml = prologue + uxml.encode('iso-8859-1')
2371 el = self.etree.parse(StringIO(isoxml)).getroot()
2372 self.assertEquals(utext, el.text)
2373
2387
2389 Element = self.etree.Element
2390
2391 a = Element('a')
2392 a.text = 'Foo'
2393
2394 b = copy.deepcopy(a)
2395 self.assertEquals('Foo', b.text)
2396
2397 b.text = 'Bar'
2398 self.assertEquals('Bar', b.text)
2399 self.assertEquals('Foo', a.text)
2400
2401 del a
2402 self.assertEquals('Bar', b.text)
2403
2405 Element = self.etree.Element
2406
2407 a = Element('a')
2408 a.tail = 'Foo'
2409
2410 b = copy.deepcopy(a)
2411 self.assertEquals('Foo', b.tail)
2412
2413 b.tail = 'Bar'
2414 self.assertEquals('Bar', b.tail)
2415 self.assertEquals('Foo', a.tail)
2416
2417 del a
2418 self.assertEquals('Bar', b.tail)
2419
2421 Element = self.etree.Element
2422 SubElement = self.etree.SubElement
2423
2424 root = Element('root')
2425 a = SubElement(root, 'a')
2426 a.text = 'FooText'
2427 a.tail = 'FooTail'
2428
2429 b = copy.deepcopy(a)
2430 self.assertEquals('FooText', b.text)
2431 self.assertEquals('FooTail', b.tail)
2432
2433 b.text = 'BarText'
2434 b.tail = 'BarTail'
2435 self.assertEquals('BarTail', b.tail)
2436 self.assertEquals('FooTail', a.tail)
2437 self.assertEquals('BarText', b.text)
2438 self.assertEquals('FooText', a.text)
2439
2440 del a
2441 self.assertEquals('BarTail', b.tail)
2442 self.assertEquals('BarText', b.text)
2443
2445 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
2446 <parent><node t:foo="bar" /></parent>
2447 </doc>''')
2448 self.assertEquals(
2449 root[0][0].get('{tns}foo'),
2450 copy.deepcopy(root[0])[0].get('{tns}foo') )
2451 self.assertEquals(
2452 root[0][0].get('{tns}foo'),
2453 copy.deepcopy(root[0][0]).get('{tns}foo') )
2454
2469
2471 Element = self.etree.Element
2472
2473 a = Element('a')
2474 a.text = 'Foo'
2475
2476 b = copy.copy(a)
2477 self.assertEquals('Foo', b.text)
2478
2479 b.text = 'Bar'
2480 self.assertEquals('Bar', b.text)
2481 self.assertEquals('Foo', a.text)
2482
2483
2496
2498 etree = self.etree
2499 e = etree.Element('foo')
2500 self.assertEquals(False, bool(e))
2501 etree.SubElement(e, 'bar')
2502 self.assertEquals(True, bool(e))
2503 e = etree.Element('foo')
2504 e.text = 'hey'
2505 self.assertEquals(False, bool(e))
2506 e = etree.Element('foo')
2507 e.tail = 'bar'
2508 self.assertEquals(False, bool(e))
2509 e = etree.Element('foo')
2510 e.set('bar', 'Bar')
2511 self.assertEquals(False, bool(e))
2512
2530
2538
2540 etree = self.etree
2541 qname1 = etree.QName('myns', 'a')
2542 qname2 = etree.QName('myns', 'a')
2543 self.assertEquals(qname1, "{myns}a")
2544 self.assertEquals("{myns}a", qname2)
2545 self.assertEquals(qname1, qname1)
2546 self.assertEquals(qname1, qname2)
2547
2549 """Write out element for comparison.
2550 """
2551 ElementTree = self.etree.ElementTree
2552 f = StringIO()
2553 tree = ElementTree(element=element)
2554 tree.write(f, encoding)
2555 data = unicode(f.getvalue(), encoding)
2556 return canonicalize(data)
2557
2559 """Write out element for comparison, using real file.
2560 """
2561 ElementTree = self.etree.ElementTree
2562 handle, filename = tempfile.mkstemp()
2563 try:
2564 f = open(filename, 'wb')
2565 tree = ElementTree(element=element)
2566 tree.write(f, encoding)
2567 f.close()
2568 f = open(filename, 'rb')
2569 data = unicode(f.read(), encoding)
2570 f.close()
2571 finally:
2572 os.close(handle)
2573 os.remove(filename)
2574 return canonicalize(data)
2575
2576 - def assertXML(self, expected, element, encoding='us-ascii'):
2577 """Writes element out and checks whether it is expected.
2578
2579 Does this two ways; once using StringIO, once using a real file.
2580 """
2581 self.assertEquals(expected, self._writeElement(element, encoding))
2582 self.assertEquals(expected, self._writeElementFile(element, encoding))
2583
2585 "Checks if the result XML byte string specifies the encoding."
2586 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
2587 self.assert_(has_encoding(result))
2588 result_encoding = has_encoding(result).group(1)
2589 self.assertEquals(result_encoding.upper(), encoding.upper())
2590
2592 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
2593
2596
2598 self.assert_(hasattr(element, 'tag'))
2599 self.assert_(hasattr(element, 'attrib'))
2600 self.assert_(hasattr(element, 'text'))
2601 self.assert_(hasattr(element, 'tail'))
2602 self._check_string(element.tag)
2603 self._check_mapping(element.attrib)
2604 if element.text != None:
2605 self._check_string(element.text)
2606 if element.tail != None:
2607 self._check_string(element.tail)
2608
2610 len(string)
2611 for char in string:
2612 self.assertEquals(1, len(char))
2613 new_string = string + ""
2614 new_string = string + " "
2615 string[:0]
2616
2618 len(mapping)
2619 keys = mapping.keys()
2620 items = mapping.items()
2621 for key in keys:
2622 item = mapping[key]
2623 mapping["key"] = "value"
2624 self.assertEquals("value", mapping["key"])
2625
2626
2629
2630 if ElementTree:
2633
2640
2641 if __name__ == '__main__':
2642 unittest.main()
2643