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 Element = self.etree.Element
1974
1975 root = Element('element')
1976
1977 subelement = Element('subelement',
1978 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
1979 self.assertEquals(1, len(subelement.attrib))
1980 self.assertEquals(
1981 "foo",
1982 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
1983
1984 root.append(subelement)
1985 self.assertEquals(1, len(subelement.attrib))
1986 self.assertEquals(
1987 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
1988 subelement.attrib.items())
1989 self.assertEquals(
1990 "foo",
1991 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
1992
2004
2018
2032
2034 iterparse = self.etree.iterparse
2035 f = StringIO('<a><b></b><c/></a>')
2036
2037 iterator = iterparse(f)
2038 self.assertEquals(None,
2039 iterator.root)
2040 events = list(iterator)
2041 root = iterator.root
2042 self.assertEquals(
2043 [('end', root[0]), ('end', root[1]), ('end', root)],
2044 events)
2045
2047 iterparse = self.etree.iterparse
2048 iterator = iterparse(fileInTestDir("test.xml"))
2049 self.assertEquals(None,
2050 iterator.root)
2051 events = list(iterator)
2052 root = iterator.root
2053 self.assertEquals(
2054 [('end', root[0]), ('end', root)],
2055 events)
2056
2058 iterparse = self.etree.iterparse
2059 f = StringIO('<a><b></b><c/></a>')
2060
2061 iterator = iterparse(f, events=('start',))
2062 events = list(iterator)
2063 root = iterator.root
2064 self.assertEquals(
2065 [('start', root), ('start', root[0]), ('start', root[1])],
2066 events)
2067
2069 iterparse = self.etree.iterparse
2070 f = StringIO('<a><b></b><c/></a>')
2071
2072 iterator = iterparse(f, events=('start','end'))
2073 events = list(iterator)
2074 root = iterator.root
2075 self.assertEquals(
2076 [('start', root), ('start', root[0]), ('end', root[0]),
2077 ('start', root[1]), ('end', root[1]), ('end', root)],
2078 events)
2079
2081 iterparse = self.etree.iterparse
2082 f = StringIO('<a><b></b><c/></a>')
2083
2084 iterator = iterparse(f)
2085 for event, elem in iterator:
2086 elem.clear()
2087
2088 root = iterator.root
2089 self.assertEquals(0,
2090 len(root))
2091
2093 iterparse = self.etree.iterparse
2094 CHILD_COUNT = 12345
2095 f = StringIO('<a>' + ('<b>test</b>'*CHILD_COUNT) + '</a>')
2096
2097 i = 0
2098 for key in iterparse(f):
2099 event, element = key
2100 i += 1
2101 self.assertEquals(i, CHILD_COUNT + 1)
2102
2104 iterparse = self.etree.iterparse
2105 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2106
2107 attr_name = '{testns}bla'
2108 events = []
2109 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2110 for event, elem in iterator:
2111 events.append(event)
2112 if event == 'start':
2113 if elem.tag != '{ns1}a':
2114 elem.set(attr_name, 'value')
2115
2116 self.assertEquals(
2117 ['start-ns', 'start', 'start', 'start-ns', 'start',
2118 'end', 'end-ns', 'end', 'end', 'end-ns'],
2119 events)
2120
2121 root = iterator.root
2122 self.assertEquals(
2123 None,
2124 root.get(attr_name))
2125 self.assertEquals(
2126 'value',
2127 root[0].get(attr_name))
2128
2130 iterparse = self.etree.iterparse
2131 f = StringIO('<a><b><d/></b><c/></a>')
2132
2133 counts = []
2134 for event, elem in iterparse(f):
2135 counts.append(len(list(elem.getiterator())))
2136 self.assertEquals(
2137 [1,2,1,4],
2138 counts)
2139
2147
2151
2161
2163 parse = self.etree.parse
2164
2165 f = StringIO('<a><b></b></a>')
2166 tree = parse(f)
2167 f.close()
2168 self.assertXML(
2169 '<a><b></b></a>',
2170 tree.getroot()
2171 )
2172
2174
2175 parse = self.etree.parse
2176 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2177 self.assertXML('<html></html>',
2178 tree.getroot())
2179
2188
2201
2209
2211 parse = self.etree.parse
2212
2213 f = open(fileInTestDir('test-string.xml'), 'r')
2214 tree = parse(f)
2215 f.close()
2216 self.assertXML(
2217 u'<a>Søk på nettet</a>'.encode('UTF-8'),
2218 tree.getroot(), 'UTF-8')
2219
2221 ElementTree = self.etree.ElementTree
2222 Element = self.etree.Element
2223
2224 a = Element('a')
2225 a.text = u'Søk på nettet'
2226
2227 f = StringIO()
2228 tree = ElementTree(element=a)
2229 tree.write(f, 'iso-8859-1')
2230 result = f.getvalue()
2231 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2232 self.assertEncodingDeclaration(result,'iso-8859-1')
2233 result = result.split('?>', 1)[-1]
2234 if result[0] == '\n':
2235 result = result[1:]
2236 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2237 result)
2238
2239
2241 XML = self.etree.XML
2242 test_utf = u'<?xml version=\'1.0\' encoding=\'iso-8859-1\'?><a>Søk på nettet</a>'
2243 self.assertRaises(SyntaxError, XML, test_utf)
2244
2259
2268
2276
2287
2299
2312
2326
2328 utext = u'Søk på nettet'
2329 uxml = u'<p>%s</p>' % utext
2330 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2331 isoxml = prologue + uxml.encode('iso-8859-1')
2332 tree = self.etree.XML(isoxml)
2333 self.assertEquals(utext, tree.text)
2334
2336 utext = u'Søk på nettet'
2337 uxml = u'<p>%s</p>' % utext
2338 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2339 isoxml = prologue + uxml.encode('iso-8859-1')
2340 el = self.etree.parse(StringIO(isoxml)).getroot()
2341 self.assertEquals(utext, el.text)
2342
2356
2358 Element = self.etree.Element
2359
2360 a = Element('a')
2361 a.text = 'Foo'
2362
2363 b = copy.deepcopy(a)
2364 self.assertEquals('Foo', b.text)
2365
2366 b.text = 'Bar'
2367 self.assertEquals('Bar', b.text)
2368 self.assertEquals('Foo', a.text)
2369
2370 del a
2371 self.assertEquals('Bar', b.text)
2372
2374 Element = self.etree.Element
2375
2376 a = Element('a')
2377 a.tail = 'Foo'
2378
2379 b = copy.deepcopy(a)
2380 self.assertEquals('Foo', b.tail)
2381
2382 b.tail = 'Bar'
2383 self.assertEquals('Bar', b.tail)
2384 self.assertEquals('Foo', a.tail)
2385
2386 del a
2387 self.assertEquals('Bar', b.tail)
2388
2390 Element = self.etree.Element
2391 SubElement = self.etree.SubElement
2392
2393 root = Element('root')
2394 a = SubElement(root, 'a')
2395 a.text = 'FooText'
2396 a.tail = 'FooTail'
2397
2398 b = copy.deepcopy(a)
2399 self.assertEquals('FooText', b.text)
2400 self.assertEquals('FooTail', b.tail)
2401
2402 b.text = 'BarText'
2403 b.tail = 'BarTail'
2404 self.assertEquals('BarTail', b.tail)
2405 self.assertEquals('FooTail', a.tail)
2406 self.assertEquals('BarText', b.text)
2407 self.assertEquals('FooText', a.text)
2408
2409 del a
2410 self.assertEquals('BarTail', b.tail)
2411 self.assertEquals('BarText', b.text)
2412
2414 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
2415 <parent><node t:foo="bar" /></parent>
2416 </doc>''')
2417 self.assertEquals(
2418 root[0][0].get('{tns}foo'),
2419 copy.deepcopy(root[0])[0].get('{tns}foo') )
2420 self.assertEquals(
2421 root[0][0].get('{tns}foo'),
2422 copy.deepcopy(root[0][0]).get('{tns}foo') )
2423
2438
2440 Element = self.etree.Element
2441
2442 a = Element('a')
2443 a.text = 'Foo'
2444
2445 b = copy.copy(a)
2446 self.assertEquals('Foo', b.text)
2447
2448 b.text = 'Bar'
2449 self.assertEquals('Bar', b.text)
2450 self.assertEquals('Foo', a.text)
2451
2452
2465
2467 etree = self.etree
2468 e = etree.Element('foo')
2469 self.assertEquals(False, bool(e))
2470 etree.SubElement(e, 'bar')
2471 self.assertEquals(True, bool(e))
2472 e = etree.Element('foo')
2473 e.text = 'hey'
2474 self.assertEquals(False, bool(e))
2475 e = etree.Element('foo')
2476 e.tail = 'bar'
2477 self.assertEquals(False, bool(e))
2478 e = etree.Element('foo')
2479 e.set('bar', 'Bar')
2480 self.assertEquals(False, bool(e))
2481
2499
2507
2509 etree = self.etree
2510 qname1 = etree.QName('myns', 'a')
2511 qname2 = etree.QName('myns', 'a')
2512 self.assertEquals(qname1, "{myns}a")
2513 self.assertEquals("{myns}a", qname2)
2514 self.assertEquals(qname1, qname1)
2515 self.assertEquals(qname1, qname2)
2516
2518 """Write out element for comparison.
2519 """
2520 ElementTree = self.etree.ElementTree
2521 f = StringIO()
2522 tree = ElementTree(element=element)
2523 tree.write(f, encoding)
2524 data = unicode(f.getvalue(), encoding)
2525 return canonicalize(data)
2526
2528 """Write out element for comparison, using real file.
2529 """
2530 ElementTree = self.etree.ElementTree
2531 handle, filename = tempfile.mkstemp()
2532 try:
2533 f = open(filename, 'wb')
2534 tree = ElementTree(element=element)
2535 tree.write(f, encoding)
2536 f.close()
2537 f = open(filename, 'rb')
2538 data = unicode(f.read(), encoding)
2539 f.close()
2540 finally:
2541 os.close(handle)
2542 os.remove(filename)
2543 return canonicalize(data)
2544
2545 - def assertXML(self, expected, element, encoding='us-ascii'):
2546 """Writes element out and checks whether it is expected.
2547
2548 Does this two ways; once using StringIO, once using a real file.
2549 """
2550 self.assertEquals(expected, self._writeElement(element, encoding))
2551 self.assertEquals(expected, self._writeElementFile(element, encoding))
2552
2554 "Checks if the result XML byte string specifies the encoding."
2555 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
2556 self.assert_(has_encoding(result))
2557 result_encoding = has_encoding(result).group(1)
2558 self.assertEquals(result_encoding.upper(), encoding.upper())
2559
2561 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
2562
2565
2567 self.assert_(hasattr(element, 'tag'))
2568 self.assert_(hasattr(element, 'attrib'))
2569 self.assert_(hasattr(element, 'text'))
2570 self.assert_(hasattr(element, 'tail'))
2571 self._check_string(element.tag)
2572 self._check_mapping(element.attrib)
2573 if element.text != None:
2574 self._check_string(element.text)
2575 if element.tail != None:
2576 self._check_string(element.tail)
2577
2579 len(string)
2580 for char in string:
2581 self.assertEquals(1, len(char))
2582 new_string = string + ""
2583 new_string = string + " "
2584 string[:0]
2585
2587 len(mapping)
2588 keys = mapping.keys()
2589 items = mapping.items()
2590 for key in keys:
2591 item = mapping[key]
2592 mapping["key"] = "value"
2593 self.assertEquals("value", mapping["key"])
2594
2595
2598
2599 if ElementTree:
2602
2609
2610 if __name__ == '__main__':
2611 unittest.main()
2612