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
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
35
37 for i in range(10):
38 e = self.etree.Element('foo')
39 self.assertEquals(e.tag, 'foo')
40 self.assertEquals(e.text, None)
41 self.assertEquals(e.tail, None)
42
55
68
86
88 ElementTree = self.etree.ElementTree
89
90 f = StringIO('<doc>Test<one>One</one></doc>')
91 doc = ElementTree(file=f)
92 root = doc.getroot()
93 self.assertEquals(1, len(root))
94 self.assertEquals('one', root[0].tag)
95 self.assertRaises(IndexError, operator.getitem, root, 1)
96
98 ElementTree = self.etree.ElementTree
99
100 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
101 doc = ElementTree(file=f)
102 root = doc.getroot()
103 self.assertEquals(3, len(root))
104 self.assertEquals('one', root[0].tag)
105 self.assertEquals('two', root[1].tag)
106 self.assertEquals('three', root[2].tag)
107
109 ElementTree = self.etree.ElementTree
110
111 f = StringIO('<doc>Test</doc>')
112 doc = ElementTree(file=f)
113 root = doc.getroot()
114 self.assertEquals(0, len(root))
115
117 Element = self.etree.Element
118 SubElement = self.etree.SubElement
119 a = Element('a')
120 b = SubElement(a, 'b')
121 c = SubElement(a, 'c')
122 d = SubElement(a, 'd')
123 self.assertEquals(d, a[-1])
124 self.assertEquals(c, a[-2])
125 self.assertEquals(b, a[-3])
126 self.assertRaises(IndexError, operator.getitem, a, -4)
127 a[-1] = e = Element('e')
128 self.assertEquals(e, a[-1])
129 del a[-1]
130 self.assertEquals(2, len(a))
131
141
142 - def test_text(self):
143 ElementTree = self.etree.ElementTree
144
145 f = StringIO('<doc>This is a text</doc>')
146 doc = ElementTree(file=f)
147 root = doc.getroot()
148 self.assertEquals('This is a text', root.text)
149
150 - def test_text_empty(self):
151 ElementTree = self.etree.ElementTree
152
153 f = StringIO('<doc></doc>')
154 doc = ElementTree(file=f)
155 root = doc.getroot()
156 self.assertEquals(None, root.text)
157
158 - def test_text_other(self):
159 ElementTree = self.etree.ElementTree
160
161 f = StringIO('<doc><one>One</one></doc>')
162 doc = ElementTree(file=f)
163 root = doc.getroot()
164 self.assertEquals(None, root.text)
165 self.assertEquals('One', root[0].text)
166
168 ElementTree = self.etree.ElementTree
169
170 f = StringIO('<doc>This is > than a text</doc>')
171 doc = ElementTree(file=f)
172 root = doc.getroot()
173 self.assertEquals('This is > than a text', root.text)
174
176 Element = self.etree.Element
177
178 a = Element("a")
179 a.text = "<>&"
180 self.assertXML('<a><>&</a>',
181 a)
182
184 tostring = self.etree.tostring
185 Element = self.etree.Element
186
187 a = Element("a")
188 a.text = "<>&"
189 self.assertEquals('<a><>&</a>',
190 tostring(a))
191
193 Element = self.etree.Element
194
195 class strTest(str):
196 pass
197
198 a = Element("a")
199 a.text = strTest("text")
200 self.assertXML('<a>text</a>',
201 a)
202
214
221
222 a = Element("a")
223 SubElement(a, "t").tail = strTest("tail")
224 self.assertXML('<a><t></t>tail</a>',
225 a)
226
228
229 XML = self.etree.XML
230
231 root = XML('<doc>This is <i>mixed</i> content.</doc>')
232 self.assertEquals(1, len(root))
233 self.assertEquals('This is ', root.text)
234 self.assertEquals(None, root.tail)
235 self.assertEquals('mixed', root[0].text)
236 self.assertEquals(' content.', root[0].tail)
237
238 del root[0].tail
239
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(None, root[0].tail)
245
246 root[0].tail = "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('TAIL', root[0].tail)
253
263
273
284
286 ElementTree = self.etree.ElementTree
287
288 f = StringIO('<doc one="One" two="Two"/>')
289 doc = ElementTree(file=f)
290 root = doc.getroot()
291 self.assertEquals('One', root.get('one'))
292 self.assertEquals('Two', root.get('two'))
293 self.assertEquals(None, root.get('three'))
294 self.assertEquals('foo', root.get('three', 'foo'))
295
297 XML = self.etree.XML
298
299 root = XML('<doc one="One" two="Two"/>')
300 self.assertEquals('One', root.get('one'))
301 self.assertEquals('Two', root.get('two'))
302 root.attrib.clear()
303 self.assertEquals(None, root.get('one'))
304 self.assertEquals(None, root.get('two'))
305
307 Element = self.etree.Element
308
309 root = Element("root", one="One")
310 root.set("two", "Two")
311 self.assertEquals('One', root.get('one'))
312 self.assertEquals('Two', root.get('two'))
313 root.attrib.clear()
314 self.assertEquals(None, root.get('one'))
315 self.assertEquals(None, root.get('two'))
316
318 Element = self.etree.Element
319 SubElement = self.etree.SubElement
320
321 attribNS = '{http://foo/bar}x'
322
323 parent = Element('parent')
324 parent.set(attribNS, 'a')
325 child = SubElement(parent, 'child')
326 child.set(attribNS, 'b')
327
328 self.assertEquals('a', parent.get(attribNS))
329 self.assertEquals('b', child.get(attribNS))
330
331 parent.clear()
332 self.assertEquals(None, parent.get(attribNS))
333 self.assertEquals('b', child.get(attribNS))
334
336 XML = self.etree.XML
337
338 root = XML('<doc alpha="Alpha" beta="Beta"/>')
339 items = root.attrib.items()
340 items.sort()
341 self.assertEquals(
342 [('alpha', 'Alpha'), ('beta', 'Beta')],
343 items)
344
345 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
346
347 items = root.attrib.items()
348 items.sort()
349 self.assertEquals(
350 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
351 items)
352
354 XML = self.etree.XML
355
356 root = XML('<doc alpha="Alpha" beta="Beta"/>')
357 items = root.attrib.items()
358 items.sort()
359 self.assertEquals(
360 [('alpha', 'Alpha'), ('beta', 'Beta')],
361 items)
362
363 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
364
365 items = root.attrib.items()
366 items.sort()
367 self.assertEquals(
368 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
369 items)
370
372 XML = self.etree.XML
373
374 root = XML('<doc alpha="Alpha" beta="Beta"/>')
375 items = root.attrib.items()
376 items.sort()
377 self.assertEquals(
378 [('alpha', 'Alpha'), ('beta', 'Beta')],
379 items)
380
381 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems())
382
383 items = root.attrib.items()
384 items.sort()
385 self.assertEquals(
386 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
387 items)
388
390 XML = self.etree.XML
391
392 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
393 keys = root.attrib.keys()
394 keys.sort()
395 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
396
398 XML = self.etree.XML
399
400 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
401 keys = root.keys()
402 keys.sort()
403 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
404
406 XML = self.etree.XML
407
408 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
409 items = root.items()
410 items.sort()
411 self.assertEquals(
412 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
413 items)
414
416 XML = self.etree.XML
417
418 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
419 keys = root.keys()
420 keys.sort()
421 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
422 keys)
423
425 XML = self.etree.XML
426
427 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
428 values = root.attrib.values()
429 values.sort()
430 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
431
433 XML = self.etree.XML
434
435 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
436 values = root.attrib.values()
437 values.sort()
438 self.assertEquals(
439 ['Bar', 'Baz'], values)
440
442 XML = self.etree.XML
443
444 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
445 items = root.attrib.items()
446 items.sort()
447 self.assertEquals([
448 ('alpha', 'Alpha'),
449 ('beta', 'Beta'),
450 ('gamma', 'Gamma'),
451 ],
452 items)
453
455 XML = self.etree.XML
456
457 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
458 items = root.attrib.items()
459 items.sort()
460 self.assertEquals(
461 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
462 items)
463
465 XML = self.etree.XML
466
467 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
468 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
469
470 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
471 try:
472 self.assertEquals(expected, str(root.attrib))
473 except AssertionError:
474 self.assertEquals(alternative, str(root.attrib))
475
477 XML = self.etree.XML
478
479 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
480 self.assertEquals(
481 True, root.attrib.has_key('bar'))
482 self.assertEquals(
483 False, root.attrib.has_key('baz'))
484 self.assertEquals(
485 False, root.attrib.has_key('hah'))
486 self.assertEquals(
487 True,
488 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
489
491 XML = self.etree.XML
492
493 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
494 self.assertEquals(
495 True, 'bar' in root.attrib)
496 self.assertEquals(
497 False, 'baz' in root.attrib)
498 self.assertEquals(
499 False, 'hah' in root.attrib)
500 self.assertEquals(
501 True,
502 '{http://ns.codespeak.net/test}baz' in root.attrib)
503
510
512 XML = self.etree.XML
513
514 root = XML('<doc>This is a text.</doc>')
515 self.assertEquals(0, len(root))
516 self.assertEquals('This is a text.', root.text)
517
519 XMLID = self.etree.XMLID
520 XML = self.etree.XML
521 xml_text = '''
522 <document>
523 <h1 id="chapter1">...</h1>
524 <p id="note1" class="note">...</p>
525 <p>Regular paragraph.</p>
526 <p xml:id="xmlid">XML:ID paragraph.</p>
527 <p id="warn1" class="warning">...</p>
528 </document>
529 '''
530
531 root, dic = XMLID(xml_text)
532 root2 = XML(xml_text)
533 self.assertEquals(self._writeElement(root),
534 self._writeElement(root2))
535 expected = {
536 "chapter1" : root[0],
537 "note1" : root[1],
538 "warn1" : root[4]
539 }
540 self.assertEquals(dic, expected)
541
548
556
563
570
594
596 XML = self.etree.XML
597
598 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
599 result = []
600 for el in root:
601 result.append(el.tag)
602 self.assertEquals(['one', 'two', 'three'], result)
603
605 XML = self.etree.XML
606
607 root = XML('<doc></doc>')
608 result = []
609 for el in root:
610 result.append(el.tag)
611 self.assertEquals([], result)
612
614 XML = self.etree.XML
615
616 root = XML('<doc>Text</doc>')
617 result = []
618 for el in root:
619 result.append(el.tag)
620 self.assertEquals([], result)
621
628
630 XML = self.etree.XML
631 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
632 result = []
633 for el in reversed(root):
634 result.append(el.tag)
635 self.assertEquals(['three', 'two', 'one'], result)
636
638 XML = self.etree.XML
639
640 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
641 result = []
642 add = True
643 for el in root:
644 result.append(el.tag)
645 if add:
646 self.etree.SubElement(root, 'four')
647 add = False
648 self.assertEquals(['one', 'two', 'three', 'four'], result)
649
651 XML = self.etree.XML
652
653 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
654 result = []
655 for el in root:
656 result.append(el.tag)
657 del root[-1]
658 self.assertEquals(['one', 'two'], result)
659
661 XML = self.etree.XML
662
663 root = XML('<doc><one/><two/></doc>')
664 result = []
665 for el0 in root:
666 result.append(el0.tag)
667 for el1 in root:
668 result.append(el1.tag)
669 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
670
672 XML = self.etree.XML
673
674 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')
675 result = []
676 for key in root.attrib:
677 result.append(key)
678 result.sort()
679 self.assertEquals(['alpha', 'beta', 'gamma'], result)
680
682 XML = self.etree.XML
683 root = XML('<a><b><c/></b><b/><c><b/></c></a>')
684 self.assertEquals(len(list(root.findall("c"))), 1)
685 self.assertEquals(len(list(root.findall(".//c"))), 2)
686 self.assertEquals(len(list(root.findall(".//b"))), 3)
687 self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
688 self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
689 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
690
692 XML = self.etree.XML
693 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
694 self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
695 self.assertEquals(len(list(root.findall(".//b"))), 3)
696 self.assertEquals(len(list(root.findall("b"))), 2)
697
704
711
713 Element = self.etree.Element
714
715 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
716 self.assertEquals('Foo', el.attrib['{ns1}foo'])
717 self.assertEquals('Bar', el.attrib['{ns2}bar'])
718
727
736
750
769
771 ElementTree = self.etree.ElementTree
772 Element = self.etree.Element
773 SubElement = self.etree.SubElement
774
775 a = Element('a')
776 a.text = "A"
777 a.tail = "tail"
778 b = SubElement(a, 'b')
779 b.text = "B"
780 b.tail = "TAIL"
781 c = SubElement(a, 'c')
782 c.text = "C"
783
784 tree = ElementTree(element=a)
785 f = StringIO()
786 tree.write(f, method="text")
787 data = f.getvalue()
788
789 self.assertEquals('ABTAILCtail',
790 data)
791
799
800
801
803 Element = self.etree.Element
804
805 element = Element('tag')
806 for i in range(10):
807 element.attrib['key'] = 'value'
808 value = element.attrib['key']
809 self.assertEquals(value, 'value')
810
811
823
846
847 - def test_set_text(self):
848 Element = self.etree.Element
849 SubElement = self.etree.SubElement
850
851 a = Element('a')
852 b = SubElement(a, 'b')
853 a.text = 'hoi'
854 self.assertEquals(
855 'hoi',
856 a.text)
857 self.assertEquals(
858 'b',
859 a[0].tag)
860
861 - def test_set_text2(self):
862 Element = self.etree.Element
863 SubElement = self.etree.SubElement
864
865 a = Element('a')
866 a.text = 'hoi'
867 b = SubElement(a ,'b')
868 self.assertEquals(
869 'hoi',
870 a.text)
871 self.assertEquals(
872 'b',
873 a[0].tag)
874
876 Element = self.etree.Element
877
878 a = Element('a')
879
880 a.text = 'foo'
881 a.text = None
882
883 self.assertEquals(
884 None,
885 a.text)
886 self.assertXML('<a></a>', a)
887
889 Element = self.etree.Element
890
891 a = Element('a')
892 self.assertEquals(None, a.text)
893
894 a.text = ''
895 self.assertEquals('', a.text)
896 self.assertXML('<a></a>', a)
897
912
922
934
944
954
966
975
987
999
1011
1013 ProcessingInstruction = self.etree.ProcessingInstruction
1014 pi = ProcessingInstruction('foo')
1015 self.assertEquals({}, pi.attrib)
1016 self.assertEquals([], pi.keys())
1017 self.assertEquals([], pi.items())
1018 self.assertEquals(None, pi.get('hoi'))
1019 self.assertEquals(0, len(pi))
1020
1021 for i in pi:
1022 pass
1023
1039
1057
1067
1076
1091
1108
1126
1145
1151
1152 a = Element("a")
1153 a.tag = strTest("TAG")
1154 self.assertXML('<TAG></TAG>',
1155 a)
1156
1186
1188 Element = self.etree.Element
1189 SubElement = self.etree.SubElement
1190
1191 a = Element('a')
1192 b = SubElement(a, 'b')
1193 bs = SubElement(b, 'bs')
1194 c = SubElement(a, 'c')
1195 cs = SubElement(c, 'cs')
1196
1197 el = a[0]
1198 self.assertXML(
1199 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1200 a)
1201 self.assertXML('<b><bs></bs></b>', b)
1202 self.assertXML('<c><cs></cs></c>', c)
1203
1204 del a[0]
1205 self.assertXML(
1206 '<a><c><cs></cs></c></a>',
1207 a)
1208 self.assertXML('<b><bs></bs></b>', b)
1209 self.assertXML('<c><cs></cs></c>', c)
1210
1211 a.insert(0, el)
1212 self.assertXML(
1213 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1214 a)
1215 self.assertXML('<b><bs></bs></b>', b)
1216 self.assertXML('<c><cs></cs></c>', c)
1217
1236
1255
1257 XML = self.etree.XML
1258 a = XML('<a><b></b>B2<c></c>C2</a>')
1259 b, c = a
1260
1261 a[:] = []
1262
1263 self.assertEquals("B2", b.tail)
1264 self.assertEquals("C2", c.tail)
1265
1275
1277 Element = self.etree.Element
1278
1279 a = Element('a')
1280 a.text = 'foo'
1281 a.tail = 'bar'
1282 a.set('hoi', 'dag')
1283 a.clear()
1284 self.assertEquals(None, a.text)
1285 self.assertEquals(None, a.tail)
1286 self.assertEquals(None, a.get('hoi'))
1287 self.assertEquals('a', a.tag)
1288
1290 Element = self.etree.Element
1291 SubElement = self.etree.SubElement
1292
1293 a = Element('a')
1294 a.text = 'foo'
1295 a.tail = 'bar'
1296 a.set('hoi', 'dag')
1297 b = SubElement(a, 'b')
1298 c = SubElement(b, 'c')
1299 a.clear()
1300 self.assertEquals(None, a.text)
1301 self.assertEquals(None, a.tail)
1302 self.assertEquals(None, a.get('hoi'))
1303 self.assertEquals('a', a.tag)
1304 self.assertEquals(0, len(a))
1305 self.assertXML('<a></a>',
1306 a)
1307 self.assertXML('<b><c></c></b>',
1308 b)
1309
1319
1346
1362
1379
1394
1410
1426
1437
1450
1472
1481
1483 Element = self.etree.Element
1484 SubElement = self.etree.SubElement
1485
1486 a = Element('a')
1487 b = SubElement(a, 'b')
1488 c = SubElement(a, 'c')
1489 d = SubElement(b, 'd')
1490 e = SubElement(c, 'e')
1491
1492 self.assertEquals(
1493 [a, b, d, c, e],
1494 list(a.iter()))
1495 self.assertEquals(
1496 [d],
1497 list(d.iter()))
1498
1500 Element = self.etree.Element
1501 SubElement = self.etree.SubElement
1502
1503 a = Element('a')
1504 b = SubElement(a, 'b')
1505 c = SubElement(a, 'c')
1506 d = SubElement(b, 'd')
1507 e = SubElement(c, 'e')
1508
1509 self.assertEquals(
1510 [a, b, d, c, e],
1511 list(a.getiterator()))
1512 self.assertEquals(
1513 [d],
1514 list(d.getiterator()))
1515
1535
1556
1570
1595
1597 Element = self.etree.Element
1598 PI = self.etree.ProcessingInstruction
1599 SubElement = self.etree.SubElement
1600
1601 a = Element('a')
1602 b = SubElement(a, 'b')
1603 pi_b = PI("TEST-b")
1604 b.append(pi_b)
1605
1606 self.assertEquals(
1607 [pi_b],
1608 list(a.getiterator(PI)))
1609
1610 pi_a = PI("TEST-a")
1611 a.append(pi_a)
1612
1613 self.assertEquals(
1614 [pi_b, pi_a],
1615 list(a.getiterator(PI)))
1616
1617 self.assertEquals(
1618 [pi_b],
1619 list(b.getiterator(PI)))
1620
1622 Element = self.etree.Element
1623 SubElement = self.etree.SubElement
1624
1625 a = Element('a')
1626 a.text = 'a'
1627 b = SubElement(a, 'b')
1628 b.text = 'b'
1629 b.tail = 'b1'
1630 c = SubElement(a, 'c')
1631 c.text = 'c'
1632 c.tail = 'c1'
1633 d = SubElement(b, 'd')
1634 c.text = 'd'
1635 c.tail = 'd1'
1636 e = SubElement(c, 'e')
1637 e.text = 'e'
1638 e.tail = 'e1'
1639
1640 self.assertEquals(
1641 [a, b, d, c, e],
1642 list(a.getiterator()))
1643
1644
1645
1646
1648 Element = self.etree.Element
1649 SubElement = self.etree.SubElement
1650
1651 a = Element('a')
1652 a.text = 'a'
1653 b = SubElement(a, 'b')
1654 b.text = 'b'
1655 b.tail = 'b1'
1656 c = SubElement(a, 'c')
1657 c.text = 'c'
1658 c.tail = 'c1'
1659 d = SubElement(b, 'd')
1660 c.text = 'd'
1661 c.tail = 'd1'
1662 e = SubElement(c, 'e')
1663 e.text = 'e'
1664 e.tail = 'e1'
1665
1666 self.assertEquals(
1667 [a],
1668 list(a.getiterator('a')))
1669 a2 = SubElement(e, 'a')
1670 self.assertEquals(
1671 [a, a2],
1672 list(a.getiterator('a')))
1673 self.assertEquals(
1674 [a2],
1675 list(e.getiterator('a')))
1676
1686
1688 Element = self.etree.Element
1689 SubElement = self.etree.SubElement
1690
1691 a = Element('a')
1692 b = SubElement(a, 'b')
1693 c = SubElement(a, 'c')
1694 d = SubElement(a, 'd')
1695
1696 self.assertEquals(
1697 [b, c],
1698 a[0:2])
1699 self.assertEquals(
1700 [b, c, d],
1701 a[:])
1702 self.assertEquals(
1703 [b, c, d],
1704 a[:10])
1705 self.assertEquals(
1706 [b],
1707 a[0:1])
1708 self.assertEquals(
1709 [],
1710 a[10:12])
1711
1713 Element = self.etree.Element
1714 SubElement = self.etree.SubElement
1715
1716 a = Element('a')
1717 b = SubElement(a, 'b')
1718 c = SubElement(a, 'c')
1719 d = SubElement(a, 'd')
1720
1721 self.assertEquals(
1722 [d],
1723 a[-1:])
1724 self.assertEquals(
1725 [c, d],
1726 a[-2:])
1727 self.assertEquals(
1728 [c],
1729 a[-2:-1])
1730 self.assertEquals(
1731 [b, c],
1732 a[-3:-1])
1733 self.assertEquals(
1734 [b, c],
1735 a[-3:2])
1736
1738 Element = self.etree.Element
1739 SubElement = self.etree.SubElement
1740
1741 a = Element('a')
1742 b = SubElement(a, 'b')
1743 c = SubElement(a, 'c')
1744 d = SubElement(a, 'd')
1745 e = SubElement(a, 'e')
1746
1747 self.assertEquals(
1748 [e,d,c,b],
1749 a[::-1])
1750 self.assertEquals(
1751 [b,d],
1752 a[::2])
1753 self.assertEquals(
1754 [e,c],
1755 a[::-2])
1756 self.assertEquals(
1757 [d,c],
1758 a[-2:0:-1])
1759 self.assertEquals(
1760 [e],
1761 a[:1:-2])
1762
1764 ElementTree = self.etree.ElementTree
1765
1766 f = StringIO('<a><b>B</b>B1<c>C</c>C1</a>')
1767 doc = ElementTree(file=f)
1768 a = doc.getroot()
1769 b = a[0]
1770 c = a[1]
1771 self.assertEquals(
1772 [b, c],
1773 a[:])
1774 self.assertEquals(
1775 [b],
1776 a[0:1])
1777 self.assertEquals(
1778 [c],
1779 a[1:])
1780
1804
1819
1834
1849
1864
1879
1894
1896 ElementTree = self.etree.ElementTree
1897 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
1898 doc = ElementTree(file=f)
1899 a = doc.getroot()
1900 del a[1:3]
1901 self.assertXML(
1902 '<a><b></b>B2<e></e>E2</a>',
1903 a)
1904
1906 XML = self.etree.XML
1907 a = XML('<a><b></b>B2<c></c>C2</a>')
1908 b, c = a
1909
1910 del a[:]
1911
1912 self.assertEquals("B2", b.tail)
1913 self.assertEquals("C2", c.tail)
1914
1925
1927 Element = self.etree.Element
1928 SubElement = self.etree.SubElement
1929
1930 a = Element('a')
1931 b = SubElement(a, 'b')
1932 c = SubElement(a, 'c')
1933 d = SubElement(a, 'd')
1934
1935 e = Element('e')
1936 f = Element('f')
1937 g = Element('g')
1938
1939 s = [e, f, g]
1940 a[1:2] = s
1941 self.assertEquals(
1942 [b, e, f, g, d],
1943 list(a))
1944
1962
1978
1993
2008
2010 Element = self.etree.Element
2011 SubElement = self.etree.SubElement
2012
2013 a = Element('{ns}a')
2014 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
2015 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
2016 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
2017
2018 s = [d, c, b]
2019 a[:] = s
2020 self.assertEquals(
2021 [d, c, b],
2022 list(a))
2023 self.assertEquals(
2024 ['{ns}d', '{ns}c', '{ns}b'],
2025 [ child.tag for child in a ])
2026
2027 self.assertEquals(
2028 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
2029 [ child.attrib.keys() for child in a ])
2030
2032 Element = self.etree.Element
2033 SubElement = self.etree.SubElement
2034
2035 a = Element('{ns}a')
2036 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
2037 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
2038 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
2039
2040 s = [d, c, b]
2041 a[:] = s
2042 self.assertEquals(
2043 [d, c, b],
2044 list(a))
2045 self.assertEquals(
2046 ['{ns3}d', '{ns2}c', '{ns1}b'],
2047 [ child.tag for child in a ])
2048
2049 self.assertEquals(
2050 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
2051 [ child.attrib.keys() for child in a ])
2052
2054 Element = self.etree.Element
2055 SubElement = self.etree.SubElement
2056
2057 a = Element('a')
2058 b = SubElement(a, 'b')
2059 c = SubElement(a, 'c')
2060
2061 e = Element('e')
2062 f = Element('f')
2063 g = Element('g')
2064 h = Element('h')
2065
2066 s = [e, f]
2067 a[99:] = s
2068 self.assertEquals(
2069 [a, b, e, f],
2070 list(a))
2071
2072 s = [g, h]
2073 a[:0] = s
2074 self.assertEquals(
2075 [g, h, a, b, e, f],
2076 list(a))
2077
2100
2117
2134
2151
2153 Element = self.etree.Element
2154 SubElement = self.etree.SubElement
2155
2156 a = Element('a')
2157 b = SubElement(a, 'b')
2158 c = SubElement(a, 'c')
2159 d = SubElement(a, 'd')
2160
2161 e = Element('e')
2162 f = Element('f')
2163 g = Element('g')
2164
2165 s = [e, f, g]
2166 a[3:] = s
2167 self.assertEquals(
2168 [b, c, d, e, f, g],
2169 list(a))
2170
2183
2193
2209
2228
2230 ElementTree = self.etree.ElementTree
2231 ns = 'http://xml.infrae.com/1'
2232 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
2233 t = ElementTree(file=f)
2234 a = t.getroot()
2235 self.assertEquals('{%s}a' % ns,
2236 a.tag)
2237 self.assertEquals('{%s}b' % ns,
2238 a[0].tag)
2239
2241 ElementTree = self.etree.ElementTree
2242 ns = 'http://xml.infrae.com/1'
2243 ns2 = 'http://xml.infrae.com/2'
2244 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2245 t = ElementTree(file=f)
2246 a = t.getroot()
2247 self.assertEquals('{%s}a' % ns,
2248 a.tag)
2249 self.assertEquals('{%s}b' % ns,
2250 a[0].tag)
2251 self.assertEquals('{%s}b' % ns2,
2252 a[1].tag)
2253
2255 Element = self.etree.Element
2256 SubElement = self.etree.SubElement
2257 ns = 'http://xml.infrae.com/1'
2258 ns2 = 'http://xml.infrae.com/2'
2259 a = Element('{%s}a' % ns)
2260 b = SubElement(a, '{%s}b' % ns2)
2261 c = SubElement(a, '{%s}c' % ns)
2262 self.assertEquals('{%s}a' % ns,
2263 a.tag)
2264 self.assertEquals('{%s}b' % ns2,
2265 b.tag)
2266 self.assertEquals('{%s}c' % ns,
2267 c.tag)
2268 self.assertEquals('{%s}a' % ns,
2269 a.tag)
2270 self.assertEquals('{%s}b' % ns2,
2271 b.tag)
2272 self.assertEquals('{%s}c' % ns,
2273 c.tag)
2274
2292
2294 Element = self.etree.Element
2295 ns = 'http://xml.infrae.com/1'
2296 ns2 = 'http://xml.infrae.com/2'
2297 a = Element('a')
2298 a.set('{%s}foo' % ns, 'Foo')
2299 a.set('{%s}bar' % ns2, 'Bar')
2300 self.assertEquals(
2301 'Foo',
2302 a.get('{%s}foo' % ns))
2303 self.assertEquals(
2304 'Bar',
2305 a.get('{%s}bar' % ns2))
2306 try:
2307 self.assertXML(
2308 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2),
2309 a)
2310 except AssertionError:
2311 self.assertXML(
2312 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns),
2313 a)
2314
2329
2331 tostring = self.etree.tostring
2332 root = self.etree.XML(
2333 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
2334 baz = root[0][0]
2335
2336 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2337 tostring(baz))
2338 self.assertEquals(["http://a.b.c"], nsdecl)
2339
2341 tostring = self.etree.tostring
2342 root = self.etree.XML(
2343 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')
2344 baz = root[0][0]
2345
2346 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2347 tostring(baz))
2348 self.assertEquals(["http://a.b.c"], nsdecl)
2349
2351 tostring = self.etree.tostring
2352 root = self.etree.XML(
2353 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')
2354 baz = root[0][0]
2355
2356 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2357 tostring(baz))
2358
2359 self.assertEquals(["http://a.b.c"], nsdecl)
2360
2373
2375 Element = self.etree.Element
2376
2377 root = Element('element')
2378
2379 subelement = Element('subelement',
2380 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2381 self.assertEquals(1, len(subelement.attrib))
2382 self.assertEquals(
2383 "foo",
2384 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2385
2386 root.append(subelement)
2387 self.assertEquals(1, len(subelement.attrib))
2388 self.assertEquals(
2389 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
2390 subelement.attrib.items())
2391 self.assertEquals(
2392 "foo",
2393 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2394
2406
2420
2434
2448
2450 tostring = self.etree.tostring
2451 Element = self.etree.Element
2452 SubElement = self.etree.SubElement
2453
2454 a = Element('a')
2455 a.text = "A"
2456 a.tail = "tail"
2457 b = SubElement(a, 'b')
2458 b.text = "B"
2459 b.tail = "TAIL"
2460 c = SubElement(a, 'c')
2461 c.text = "C"
2462
2463 self.assertEquals('ABTAILCtail',
2464 tostring(a, method="text"))
2465
2467 iterparse = self.etree.iterparse
2468 f = StringIO('<a><b></b><c/></a>')
2469
2470 iterator = iterparse(f)
2471 self.assertEquals(None,
2472 iterator.root)
2473 events = list(iterator)
2474 root = iterator.root
2475 self.assertEquals(
2476 [('end', root[0]), ('end', root[1]), ('end', root)],
2477 events)
2478
2489
2491 iterparse = self.etree.iterparse
2492 f = StringIO('<a><b></b><c/></a>')
2493
2494 iterator = iterparse(f, events=('start',))
2495 events = list(iterator)
2496 root = iterator.root
2497 self.assertEquals(
2498 [('start', root), ('start', root[0]), ('start', root[1])],
2499 events)
2500
2502 iterparse = self.etree.iterparse
2503 f = StringIO('<a><b></b><c/></a>')
2504
2505 iterator = iterparse(f, events=('start','end'))
2506 events = list(iterator)
2507 root = iterator.root
2508 self.assertEquals(
2509 [('start', root), ('start', root[0]), ('end', root[0]),
2510 ('start', root[1]), ('end', root[1]), ('end', root)],
2511 events)
2512
2514 iterparse = self.etree.iterparse
2515 f = StringIO('<a><b></b><c/></a>')
2516
2517 iterator = iterparse(f)
2518 for event, elem in iterator:
2519 elem.clear()
2520
2521 root = iterator.root
2522 self.assertEquals(0,
2523 len(root))
2524
2526 iterparse = self.etree.iterparse
2527 CHILD_COUNT = 12345
2528 f = StringIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
2529
2530 i = 0
2531 for key in iterparse(f):
2532 event, element = key
2533 i += 1
2534 self.assertEquals(i, CHILD_COUNT + 1)
2535
2537 iterparse = self.etree.iterparse
2538 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2539
2540 attr_name = '{testns}bla'
2541 events = []
2542 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2543 for event, elem in iterator:
2544 events.append(event)
2545 if event == 'start':
2546 if elem.tag != '{ns1}a':
2547 elem.set(attr_name, 'value')
2548
2549 self.assertEquals(
2550 ['start-ns', 'start', 'start', 'start-ns', 'start',
2551 'end', 'end-ns', 'end', 'end', 'end-ns'],
2552 events)
2553
2554 root = iterator.root
2555 self.assertEquals(
2556 None,
2557 root.get(attr_name))
2558 self.assertEquals(
2559 'value',
2560 root[0].get(attr_name))
2561
2563 iterparse = self.etree.iterparse
2564 f = StringIO('<a><b><d/></b><c/></a>')
2565
2566 counts = []
2567 for event, elem in iterparse(f):
2568 counts.append(len(list(elem.getiterator())))
2569 self.assertEquals(
2570 [1,2,1,4],
2571 counts)
2572
2580
2584
2594
2596 parse = self.etree.parse
2597
2598 f = StringIO('<a><b></b></a>')
2599 tree = parse(f)
2600 f.close()
2601 self.assertXML(
2602 '<a><b></b></a>',
2603 tree.getroot()
2604 )
2605
2607
2608 parse = self.etree.parse
2609 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2610 self.assertXML('<html></html>',
2611 tree.getroot())
2612
2621
2634
2642
2652
2654 ElementTree = self.etree.ElementTree
2655 Element = self.etree.Element
2656
2657 a = Element('a')
2658 a.text = u'Søk på nettet'
2659
2660 f = StringIO()
2661 tree = ElementTree(element=a)
2662 tree.write(f, encoding='iso-8859-1')
2663 result = f.getvalue()
2664 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2665 self.assertEncodingDeclaration(result,'iso-8859-1')
2666 result = result.split('?>', 1)[-1].replace('\n','')
2667 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2668 result)
2669
2684
2686 XMLParser = self.etree.XMLParser
2687
2688 text = u'Søk på nettet'
2689 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
2690 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text)
2691 ).encode('iso-8859-1')
2692
2693 self.assertRaises(self.etree.ParseError,
2694 self.etree.parse,
2695 StringIO(xml_latin1))
2696
2697 tree = self.etree.parse(StringIO(xml_latin1),
2698 XMLParser(encoding="iso-8859-1"))
2699 a = tree.getroot()
2700 self.assertEquals(a.text, text)
2701
2703
2704 XML = self.etree.XML
2705 test_utf = (u'<?xml version="1.0" encoding="iso-8859-1"?>' + \
2706 u'<a>Søk på nettet</a>')
2707 self.assertRaises(SyntaxError, XML, test_utf)
2708
2723
2732
2741
2752
2764
2777
2791
2793 utext = u'Søk på nettet'
2794 uxml = u'<p>%s</p>' % utext
2795 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2796 isoxml = prologue + uxml.encode('iso-8859-1')
2797 tree = self.etree.XML(isoxml)
2798 self.assertEquals(utext, tree.text)
2799
2801 utext = u'Søk på nettet'
2802 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \
2803 u'<p>%s</p>' % utext
2804 bom = '\xEF\xBB\xBF'
2805 xml = bom + uxml.encode("utf-8")
2806 tree = etree.XML(xml)
2807 self.assertEquals(utext, tree.text)
2808
2810 utext = u'Søk på nettet'
2811 uxml = u'<p>%s</p>' % utext
2812 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2813 isoxml = prologue + uxml.encode('iso-8859-1')
2814 el = self.etree.parse(StringIO(isoxml)).getroot()
2815 self.assertEquals(utext, el.text)
2816
2830
2832 Element = self.etree.Element
2833
2834 a = Element('a')
2835 a.text = 'Foo'
2836
2837 b = copy.deepcopy(a)
2838 self.assertEquals('Foo', b.text)
2839
2840 b.text = 'Bar'
2841 self.assertEquals('Bar', b.text)
2842 self.assertEquals('Foo', a.text)
2843
2844 del a
2845 self.assertEquals('Bar', b.text)
2846
2848 Element = self.etree.Element
2849
2850 a = Element('a')
2851 a.tail = 'Foo'
2852
2853 b = copy.deepcopy(a)
2854 self.assertEquals('Foo', b.tail)
2855
2856 b.tail = 'Bar'
2857 self.assertEquals('Bar', b.tail)
2858 self.assertEquals('Foo', a.tail)
2859
2860 del a
2861 self.assertEquals('Bar', b.tail)
2862
2864 Element = self.etree.Element
2865 SubElement = self.etree.SubElement
2866
2867 root = Element('root')
2868 a = SubElement(root, 'a')
2869 a.text = 'FooText'
2870 a.tail = 'FooTail'
2871
2872 b = copy.deepcopy(a)
2873 self.assertEquals('FooText', b.text)
2874 self.assertEquals('FooTail', b.tail)
2875
2876 b.text = 'BarText'
2877 b.tail = 'BarTail'
2878 self.assertEquals('BarTail', b.tail)
2879 self.assertEquals('FooTail', a.tail)
2880 self.assertEquals('BarText', b.text)
2881 self.assertEquals('FooText', a.text)
2882
2883 del a
2884 self.assertEquals('BarTail', b.tail)
2885 self.assertEquals('BarText', b.text)
2886
2888 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
2889 <parent><node t:foo="bar" /></parent>
2890 </doc>''')
2891 self.assertEquals(
2892 root[0][0].get('{tns}foo'),
2893 copy.deepcopy(root[0])[0].get('{tns}foo') )
2894 self.assertEquals(
2895 root[0][0].get('{tns}foo'),
2896 copy.deepcopy(root[0][0]).get('{tns}foo') )
2897
2912
2925
2926
2939
2941
2942 etree = self.etree
2943 e = etree.Element('foo')
2944 self.assertEquals(False, bool(e))
2945 etree.SubElement(e, 'bar')
2946 self.assertEquals(True, bool(e))
2947 e = etree.Element('foo')
2948 e.text = 'hey'
2949 self.assertEquals(False, bool(e))
2950 e = etree.Element('foo')
2951 e.tail = 'bar'
2952 self.assertEquals(False, bool(e))
2953 e = etree.Element('foo')
2954 e.set('bar', 'Bar')
2955 self.assertEquals(False, bool(e))
2956
2958 etree = self.etree
2959
2960 a = etree.Element('a')
2961 b = etree.SubElement(a, 'b')
2962
2963 t = etree.ElementTree(a)
2964 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2965
2966 t1 = etree.ElementTree(a)
2967 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
2968 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2969
2970 t2 = etree.ElementTree(b)
2971 self.assertEquals(self._rootstring(t2), '<b/>')
2972 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
2973 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2974
2982
2984 etree = self.etree
2985 qname1 = etree.QName('myns', 'a')
2986 qname2 = etree.QName('myns', 'a')
2987 self.assertEquals(qname1, "{myns}a")
2988 self.assertEquals("{myns}a", qname2)
2989 self.assertEquals(qname1, qname1)
2990 self.assertEquals(qname1, qname2)
2991
2993 etree = self.etree
2994 qname = etree.QName('myns', 'a')
2995
2996 a = etree.Element(qname)
2997 a.set(qname, "value")
2998
2999 self.assertEquals(a.get(qname), "value")
3000 self.assertEquals(a.get("{myns}a"), "value")
3001
3003 etree = self.etree
3004 qname = etree.QName('myns', 'a')
3005
3006 a = etree.Element(qname)
3007 a.attrib[qname] = "value"
3008
3009 self.assertEquals(a.attrib[qname], "value")
3010 self.assertEquals(a.attrib.get(qname), "value")
3011
3012 self.assertEquals(a.attrib["{myns}a"], "value")
3013 self.assertEquals(a.attrib.get("{myns}a"), "value")
3014
3016 etree = self.etree
3017 qname = etree.QName('http://myns', 'a')
3018 a = etree.Element(qname)
3019 a.set(qname, qname)
3020
3021 self.assertXML(
3022 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>',
3023 a)
3024
3034
3044
3051
3052
3053
3069
3074
3083
3097
3108
3109
3110
3112 assertEquals = self.assertEquals
3113 assertFalse = self.assertFalse
3114
3115 events = []
3116 class Target(object):
3117 def start(self, tag, attrib):
3118 events.append("start")
3119 assertFalse(attrib)
3120 assertEquals("TAG", tag)
3121 def end(self, tag):
3122 events.append("end")
3123 assertEquals("TAG", tag)
3124 def close(self):
3125 return "DONE"
3126
3127 parser = self.etree.XMLParser(target=Target())
3128
3129 parser.feed("<TAG/>")
3130 done = parser.close()
3131
3132 self.assertEquals("DONE", done)
3133 self.assertEquals(["start", "end"], events)
3134
3136 assertEquals = self.assertEquals
3137
3138 events = []
3139 class Target(object):
3140 def start(self, tag, attrib):
3141 events.append("start-" + tag)
3142 for name, value in attrib.iteritems():
3143 assertEquals(tag + name, value)
3144 def end(self, tag):
3145 events.append("end-" + tag)
3146 def close(self):
3147 return "DONE"
3148
3149 parser = self.etree.XMLParser(target=Target())
3150
3151 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3152 done = parser.close()
3153
3154 self.assertEquals("DONE", done)
3155 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3156 events)
3157
3159 events = []
3160 class Target(object):
3161 def start(self, tag, attrib):
3162 events.append("start-" + tag)
3163 def end(self, tag):
3164 events.append("end-" + tag)
3165 def data(self, data):
3166 events.append("data-" + data)
3167 def close(self):
3168 return "DONE"
3169
3170 parser = self.etree.XMLParser(target=Target())
3171
3172 parser.feed('<root>A<sub/>B</root>')
3173 done = parser.close()
3174
3175 self.assertEquals("DONE", done)
3176 self.assertEquals(["start-root", "data-A", "start-sub",
3177 "end-sub", "data-B", "end-root"],
3178 events)
3179
3181 builder = self.etree.TreeBuilder()
3182 el = builder.start("root", {'a':'A', 'b':'B'})
3183 self.assertEquals("root", el.tag)
3184 self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3185 builder.data("ROOTTEXT")
3186 el = builder.start("child", {'x':'X', 'y':'Y'})
3187 self.assertEquals("child", el.tag)
3188 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3189 builder.data("CHILDTEXT")
3190 el = builder.end("child")
3191 self.assertEquals("child", el.tag)
3192 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3193 self.assertEquals("CHILDTEXT", el.text)
3194 self.assertEquals(None, el.tail)
3195 builder.data("CHILDTAIL")
3196 root = builder.end("root")
3197
3198 self.assertEquals("root", root.tag)
3199 self.assertEquals("ROOTTEXT", root.text)
3200 self.assertEquals("CHILDTEXT", root[0].text)
3201 self.assertEquals("CHILDTAIL", root[0].tail)
3202
3212
3213
3214
3222
3242
3243 - def assertXML(self, expected, element, encoding='us-ascii'):
3244 """Writes element out and checks whether it is expected.
3245
3246 Does this two ways; once using StringIO, once using a real file.
3247 """
3248 self.assertEquals(expected, self._writeElement(element, encoding))
3249 self.assertEquals(expected, self._writeElementFile(element, encoding))
3250
3252 "Checks if the result XML byte string specifies the encoding."
3253 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
3254 self.assert_(has_encoding(result))
3255 result_encoding = has_encoding(result).group(1)
3256 self.assertEquals(result_encoding.upper(), encoding.upper())
3257
3259 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
3260
3262 self._check_element(tree.getroot())
3263
3265 self.assert_(hasattr(element, 'tag'))
3266 self.assert_(hasattr(element, 'attrib'))
3267 self.assert_(hasattr(element, 'text'))
3268 self.assert_(hasattr(element, 'tail'))
3269 self._check_string(element.tag)
3270 self._check_mapping(element.attrib)
3271 if element.text != None:
3272 self._check_string(element.text)
3273 if element.tail != None:
3274 self._check_string(element.tail)
3275
3277 len(string)
3278 for char in string:
3279 self.assertEquals(1, len(char))
3280 new_string = string + ""
3281 new_string = string + " "
3282 string[:0]
3283
3285 len(mapping)
3286 keys = mapping.keys()
3287 items = mapping.items()
3288 for key in keys:
3289 item = mapping[key]
3290 mapping["key"] = "value"
3291 self.assertEquals("value", mapping["key"])
3292
3293
3294 try:
3295 unittest.TestCase.assertFalse
3296 except AttributeError:
3297 assertFalse = unittest.TestCase.failIf
3298
3299
3300 if etree:
3303
3304 if ElementTree:
3307
3308 if cElementTree:
3311
3321
3322 if __name__ == '__main__':
3323 print 'to test use test.py %s' % __file__
3324