| Home | Trees | Indices | Help |
|
|---|
|
|
1 # -*- coding: utf-8 -*-
2
3 """
4 Tests for the ElementTree API
5
6 Only test cases that apply equally well to etree and ElementTree
7 belong here. Note that there is a second test module called test_io.py
8 for IO related test cases.
9 """
10
11 import unittest, doctest
12 import os, re, tempfile, copy, operator, gc
13
14 from common_imports import StringIO, etree, ElementTree, cElementTree
15 from common_imports import fileInTestDir, canonicalize, HelperTestCase
16
17 if cElementTree is not None:
18 if tuple([int(n) for n in
19 getattr(cElementTree, "VERSION", "0.0").split(".")]) <= (1,0,7):
20 cElementTree = None
21
22 try:
23 reversed
24 except NameError:
25 # Python 2.3
29
31 etree = None
32
34 for i in range(10):
35 e = self.etree.Element('foo')
36 self.assertEquals(e.tag, 'foo')
37 self.assertEquals(e.text, None)
38 self.assertEquals(e.tail, None)
39
41 Element = self.etree.Element
42
43 root = Element('root')
44 root.append(Element('one'))
45 root.append(Element('two'))
46 root.append(Element('three'))
47 self.assertEquals(3, len(root))
48 self.assertEquals('one', root[0].tag)
49 self.assertEquals('two', root[1].tag)
50 self.assertEquals('three', root[2].tag)
51 self.assertRaises(IndexError, operator.getitem, root, 3)
52
54 Element = self.etree.Element
55 SubElement = self.etree.SubElement
56
57 root = Element('root')
58 SubElement(root, 'one')
59 SubElement(root, 'two')
60 SubElement(root, 'three')
61 self.assertEquals(3, len(root))
62 self.assertEquals('one', root[0].tag)
63 self.assertEquals('two', root[1].tag)
64 self.assertEquals('three', root[2].tag)
65
67 Element = self.etree.Element
68 SubElement = self.etree.SubElement
69
70 root1 = Element('root')
71 SubElement(root1, 'one')
72 self.assert_(root1[0] in root1)
73
74 root2 = Element('root')
75 SubElement(root2, 'two')
76 SubElement(root2, 'three')
77 self.assert_(root2[0] in root2)
78 self.assert_(root2[1] in root2)
79
80 self.assertFalse(root1[0] in root2)
81 self.assertFalse(root2[0] in root1)
82 self.assertFalse(None in root2)
83
85 ElementTree = self.etree.ElementTree
86
87 f = StringIO('<doc>Test<one>One</one></doc>')
88 doc = ElementTree(file=f)
89 root = doc.getroot()
90 self.assertEquals(1, len(root))
91 self.assertEquals('one', root[0].tag)
92 self.assertRaises(IndexError, operator.getitem, root, 1)
93
95 ElementTree = self.etree.ElementTree
96
97 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
98 doc = ElementTree(file=f)
99 root = doc.getroot()
100 self.assertEquals(3, len(root))
101 self.assertEquals('one', root[0].tag)
102 self.assertEquals('two', root[1].tag)
103 self.assertEquals('three', root[2].tag)
104
106 ElementTree = self.etree.ElementTree
107
108 f = StringIO('<doc>Test</doc>')
109 doc = ElementTree(file=f)
110 root = doc.getroot()
111 self.assertEquals(0, len(root))
112
114 Element = self.etree.Element
115 SubElement = self.etree.SubElement
116 a = Element('a')
117 b = SubElement(a, 'b')
118 c = SubElement(a, 'c')
119 d = SubElement(a, 'd')
120 self.assertEquals(d, a[-1])
121 self.assertEquals(c, a[-2])
122 self.assertEquals(b, a[-3])
123 self.assertRaises(IndexError, operator.getitem, a, -4)
124 a[-1] = e = Element('e')
125 self.assertEquals(e, a[-1])
126 del a[-1]
127 self.assertEquals(2, len(a))
128
130 ElementTree = self.etree.ElementTree
131
132 f = StringIO('<doc><one>One</one><two>Two</two></doc>')
133 doc = ElementTree(file=f)
134 root = doc.getroot()
135 self.assertEquals(2, len(root))
136 self.assertEquals('one', root[0].tag)
137 self.assertEquals('two', root[1].tag)
138
140 ElementTree = self.etree.ElementTree
141
142 f = StringIO('<doc>This is a text</doc>')
143 doc = ElementTree(file=f)
144 root = doc.getroot()
145 self.assertEquals('This is a text', root.text)
146
148 ElementTree = self.etree.ElementTree
149
150 f = StringIO('<doc></doc>')
151 doc = ElementTree(file=f)
152 root = doc.getroot()
153 self.assertEquals(None, root.text)
154
156 ElementTree = self.etree.ElementTree
157
158 f = StringIO('<doc><one>One</one></doc>')
159 doc = ElementTree(file=f)
160 root = doc.getroot()
161 self.assertEquals(None, root.text)
162 self.assertEquals('One', root[0].text)
163
165 ElementTree = self.etree.ElementTree
166
167 f = StringIO('<doc>This is > than a text</doc>')
168 doc = ElementTree(file=f)
169 root = doc.getroot()
170 self.assertEquals('This is > than a text', root.text)
171
173 Element = self.etree.Element
174
175 a = Element("a")
176 a.text = "<>&"
177 self.assertXML('<a><>&</a>',
178 a)
179
181 tostring = self.etree.tostring
182 Element = self.etree.Element
183
184 a = Element("a")
185 a.text = "<>&"
186 self.assertEquals('<a><>&</a>',
187 tostring(a))
188
194
195 a = Element("a")
196 a.text = strTest("text")
197 self.assertXML('<a>text</a>',
198 a)
199
201 ElementTree = self.etree.ElementTree
202
203 f = StringIO('<doc>This is <i>mixed</i> content.</doc>')
204 doc = ElementTree(file=f)
205 root = doc.getroot()
206 self.assertEquals(1, len(root))
207 self.assertEquals('This is ', root.text)
208 self.assertEquals(None, root.tail)
209 self.assertEquals('mixed', root[0].text)
210 self.assertEquals(' content.', root[0].tail)
211
213 Element = self.etree.Element
214 SubElement = self.etree.SubElement
215
216 class strTest(str):
217 pass
218
219 a = Element("a")
220 SubElement(a, "t").tail = strTest("tail")
221 self.assertXML('<a><t></t>tail</a>',
222 a)
223
225 # this is discouraged for ET compat, should not be tested...
226 XML = self.etree.XML
227
228 root = XML('<doc>This is <i>mixed</i> content.</doc>')
229 self.assertEquals(1, len(root))
230 self.assertEquals('This is ', root.text)
231 self.assertEquals(None, root.tail)
232 self.assertEquals('mixed', root[0].text)
233 self.assertEquals(' content.', root[0].tail)
234
235 del root[0].tail
236
237 self.assertEquals(1, len(root))
238 self.assertEquals('This is ', root.text)
239 self.assertEquals(None, root.tail)
240 self.assertEquals('mixed', root[0].text)
241 self.assertEquals(None, root[0].tail)
242
243 root[0].tail = "TAIL"
244
245 self.assertEquals(1, len(root))
246 self.assertEquals('This is ', root.text)
247 self.assertEquals(None, root.tail)
248 self.assertEquals('mixed', root[0].text)
249 self.assertEquals('TAIL', root[0].tail)
250
252 Element = self.etree.Element
253 ElementTree = self.etree.ElementTree
254
255 el = Element('hoi')
256 doc = ElementTree(el)
257 root = doc.getroot()
258 self.assertEquals(None, root.text)
259 self.assertEquals('hoi', root.tag)
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, operator.getitem, root.attrib, '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 Element = self.etree.Element
316 SubElement = self.etree.SubElement
317
318 attribNS = '{http://foo/bar}x'
319
320 parent = Element('parent')
321 parent.set(attribNS, 'a')
322 child = SubElement(parent, 'child')
323 child.set(attribNS, 'b')
324
325 self.assertEquals('a', parent.get(attribNS))
326 self.assertEquals('b', child.get(attribNS))
327
328 parent.clear()
329 self.assertEquals(None, parent.get(attribNS))
330 self.assertEquals('b', child.get(attribNS))
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'})
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'}.items())
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"/>')
372 items = root.attrib.items()
373 items.sort()
374 self.assertEquals(
375 [('alpha', 'Alpha'), ('beta', 'Beta')],
376 items)
377
378 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems())
379
380 items = root.attrib.items()
381 items.sort()
382 self.assertEquals(
383 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
384 items)
385
387 XML = self.etree.XML
388
389 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
390 keys = root.attrib.keys()
391 keys.sort()
392 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
393
395 XML = self.etree.XML
396
397 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
398 keys = root.keys()
399 keys.sort()
400 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
401
403 XML = self.etree.XML
404
405 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
406 items = root.items()
407 items.sort()
408 self.assertEquals(
409 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
410 items)
411
413 XML = self.etree.XML
414
415 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
416 keys = root.keys()
417 keys.sort()
418 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
419 keys)
420
422 XML = self.etree.XML
423
424 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
425 values = root.attrib.values()
426 values.sort()
427 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
428
430 XML = self.etree.XML
431
432 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
433 values = root.attrib.values()
434 values.sort()
435 self.assertEquals(
436 ['Bar', 'Baz'], values)
437
439 XML = self.etree.XML
440
441 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
442 items = root.attrib.items()
443 items.sort()
444 self.assertEquals([
445 ('alpha', 'Alpha'),
446 ('beta', 'Beta'),
447 ('gamma', 'Gamma'),
448 ],
449 items)
450
452 XML = self.etree.XML
453
454 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
455 items = root.attrib.items()
456 items.sort()
457 self.assertEquals(
458 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
459 items)
460
462 XML = self.etree.XML
463
464 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
465 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
466
467 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
468 try:
469 self.assertEquals(expected, str(root.attrib))
470 except AssertionError:
471 self.assertEquals(alternative, str(root.attrib))
472
474 XML = self.etree.XML
475
476 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
477 self.assertEquals(
478 True, root.attrib.has_key('bar'))
479 self.assertEquals(
480 False, root.attrib.has_key('baz'))
481 self.assertEquals(
482 False, root.attrib.has_key('hah'))
483 self.assertEquals(
484 True,
485 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
486
488 XML = self.etree.XML
489
490 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')
491 self.assertEquals(
492 True, 'bar' in root.attrib)
493 self.assertEquals(
494 False, 'baz' in root.attrib)
495 self.assertEquals(
496 False, 'hah' in root.attrib)
497 self.assertEquals(
498 True,
499 '{http://ns.codespeak.net/test}baz' in root.attrib)
500
502 Element = self.etree.Element
503
504 root = Element("root")
505 root.set("attr", "TEST")
506 self.assertEquals("TEST", root.get("attr"))
507
509 XML = self.etree.XML
510
511 root = XML('<doc>This is a text.</doc>')
512 self.assertEquals(0, len(root))
513 self.assertEquals('This is a text.', root.text)
514
516 XMLID = self.etree.XMLID
517 XML = self.etree.XML
518 xml_text = '''
519 <document>
520 <h1 id="chapter1">...</h1>
521 <p id="note1" class="note">...</p>
522 <p>Regular paragraph.</p>
523 <p xml:id="xmlid">XML:ID paragraph.</p>
524 <p id="warn1" class="warning">...</p>
525 </document>
526 '''
527
528 root, dic = XMLID(xml_text)
529 root2 = XML(xml_text)
530 self.assertEquals(self._writeElement(root),
531 self._writeElement(root2))
532 expected = {
533 "chapter1" : root[0],
534 "note1" : root[1],
535 "warn1" : root[4]
536 }
537 self.assertEquals(dic, expected)
538
540 fromstring = self.etree.fromstring
541
542 root = fromstring('<doc>This is a text.</doc>')
543 self.assertEquals(0, len(root))
544 self.assertEquals('This is a text.', root.text)
545
547 fromstringlist = self.etree.fromstringlist
548
549 root = fromstringlist(["<do", "c>T", "hi", "s is",
550 " a text.<", "/doc", ">"])
551 self.assertEquals(0, len(root))
552 self.assertEquals('This is a text.', root.text)
553
555 fromstringlist = self.etree.fromstringlist
556
557 root = fromstringlist(list('<doc>This is a text.</doc>'))
558 self.assertEquals(0, len(root))
559 self.assertEquals('This is a text.', root.text)
560
562 fromstringlist = self.etree.fromstringlist
563
564 root = fromstringlist(['<doc>This is a text.</doc>'])
565 self.assertEquals(0, len(root))
566 self.assertEquals('This is a text.', root.text)
567
569 iselement = self.etree.iselement
570 Element = self.etree.Element
571 ElementTree = self.etree.ElementTree
572 XML = self.etree.XML
573 Comment = self.etree.Comment
574 ProcessingInstruction = self.etree.ProcessingInstruction
575
576 el = Element('hoi')
577 self.assert_(iselement(el))
578
579 el2 = XML('<foo/>')
580 self.assert_(iselement(el2))
581
582 tree = ElementTree(element=Element('dag'))
583 self.assert_(not iselement(tree))
584 self.assert_(iselement(tree.getroot()))
585
586 c = Comment('test')
587 self.assert_(iselement(c))
588
589 p = ProcessingInstruction("test", "some text")
590 self.assert_(iselement(p))
591
593 XML = self.etree.XML
594
595 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
596 result = []
597 for el in root:
598 result.append(el.tag)
599 self.assertEquals(['one', 'two', 'three'], result)
600
602 XML = self.etree.XML
603
604 root = XML('<doc></doc>')
605 result = []
606 for el in root:
607 result.append(el.tag)
608 self.assertEquals([], result)
609
611 XML = self.etree.XML
612
613 root = XML('<doc>Text</doc>')
614 result = []
615 for el in root:
616 result.append(el.tag)
617 self.assertEquals([], result)
618
620 # this would cause a crash in the past
621 fromstring = self.etree.fromstring
622 root = etree.fromstring('<html><p></p>x</html>')
623 for elem in root:
624 elem.tail = ''
625
627 XML = self.etree.XML
628 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
629 result = []
630 for el in reversed(root):
631 result.append(el.tag)
632 self.assertEquals(['three', 'two', 'one'], result)
633
635 XML = self.etree.XML
636
637 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
638 result = []
639 add = True
640 for el in root:
641 result.append(el.tag)
642 if add:
643 self.etree.SubElement(root, 'four')
644 add = False
645 self.assertEquals(['one', 'two', 'three', 'four'], result)
646
648 XML = self.etree.XML
649
650 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
651 result = []
652 for el in root:
653 result.append(el.tag)
654 del root[-1]
655 self.assertEquals(['one', 'two'], result)
656
658 XML = self.etree.XML
659
660 root = XML('<doc><one/><two/></doc>')
661 result = []
662 for el0 in root:
663 result.append(el0.tag)
664 for el1 in root:
665 result.append(el1.tag)
666 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
667
669 XML = self.etree.XML
670
671 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')
672 result = []
673 for key in root.attrib:
674 result.append(key)
675 result.sort()
676 self.assertEquals(['alpha', 'beta', 'gamma'], result)
677
679 XML = self.etree.XML
680 root = XML('<a><b><c/></b><b/><c><b/></c></a>')
681 self.assertEquals(len(list(root.findall("c"))), 1)
682 self.assertEquals(len(list(root.findall(".//c"))), 2)
683 self.assertEquals(len(list(root.findall(".//b"))), 3)
684 self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
685 self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
686 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
687
689 XML = self.etree.XML
690 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
691 self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
692 self.assertEquals(len(list(root.findall(".//b"))), 3)
693 self.assertEquals(len(list(root.findall("b"))), 2)
694
696 Element = self.etree.Element
697
698 el = Element('tag', foo='Foo', bar='Bar')
699 self.assertEquals('Foo', el.attrib['foo'])
700 self.assertEquals('Bar', el.attrib['bar'])
701
703 Element = self.etree.Element
704
705 el = Element('tag', {'foo':'Foo', 'bar':'Bar'})
706 self.assertEquals('Foo', el.attrib['foo'])
707 self.assertEquals('Bar', el.attrib['bar'])
708
710 Element = self.etree.Element
711
712 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
713 self.assertEquals('Foo', el.attrib['{ns1}foo'])
714 self.assertEquals('Bar', el.attrib['{ns2}bar'])
715
717 Element = self.etree.Element
718 SubElement = self.etree.SubElement
719
720 el = Element('tag')
721 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz")
722 self.assertEquals("Baz", el[0].attrib['baz'])
723 self.assertEquals('Foo', el[0].attrib['foo'])
724
726 Element = self.etree.Element
727 SubElement = self.etree.SubElement
728
729 el = Element('tag')
730 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
731 self.assertEquals('Foo', el[0].attrib['{ns1}foo'])
732 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])
733
735 ElementTree = self.etree.ElementTree
736 XML = self.etree.XML
737
738 for i in range(10):
739 f = StringIO()
740 root = XML('<doc%s>This is a test.</doc%s>' % (i, i))
741 tree = ElementTree(element=root)
742 tree.write(f)
743 data = f.getvalue()
744 self.assertEquals(
745 '<doc%s>This is a test.</doc%s>' % (i, i),
746 canonicalize(data))
747
749 ElementTree = self.etree.ElementTree
750 Element = self.etree.Element
751 SubElement = self.etree.SubElement
752
753 html = Element('html')
754 body = SubElement(html, 'body')
755 p = SubElement(body, 'p')
756 p.text = "html"
757 SubElement(p, 'br').tail = "test"
758
759 tree = ElementTree(element=html)
760 f = StringIO()
761 tree.write(f, method="html")
762 data = f.getvalue().replace('\n','')
763
764 self.assertEquals('<html><body><p>html<br>test</p></body></html>',
765 data)
766
768 ElementTree = self.etree.ElementTree
769 Element = self.etree.Element
770 SubElement = self.etree.SubElement
771
772 a = Element('a')
773 a.text = "A"
774 a.tail = "tail"
775 b = SubElement(a, 'b')
776 b.text = "B"
777 b.tail = "TAIL"
778 c = SubElement(a, 'c')
779 c.text = "C"
780
781 tree = ElementTree(element=a)
782 f = StringIO()
783 tree.write(f, method="text")
784 data = f.getvalue()
785
786 self.assertEquals('ABTAILCtail',
787 data)
788
790 ElementTree = self.etree.ElementTree
791 XML = self.etree.XML
792
793 tree = ElementTree( XML('<doc>This is a test.</doc>') )
794 self.assertRaises(IOError, tree.write,
795 "definitely////\\-\\nonexisting\\-\\////FILE")
796
797 # this could trigger a crash, apparently because the document
798 # reference was prematurely garbage collected
800 Element = self.etree.Element
801
802 element = Element('tag')
803 for i in range(10):
804 element.attrib['key'] = 'value'
805 value = element.attrib['key']
806 self.assertEquals(value, 'value')
807
808 # from doctest; for some reason this caused crashes too
810 Element = self.etree.Element
811 ElementTree = self.etree.ElementTree
812
813 f = StringIO()
814 for i in range(10):
815 element = Element('tag%s' % i)
816 self._check_element(element)
817 tree = ElementTree(element)
818 tree.write(f)
819 self._check_element_tree(tree)
820
822 Element = self.etree.Element
823 SubElement = self.etree.SubElement
824
825 el = Element('foo')
826 el2 = SubElement(el, 'bar')
827 el3 = SubElement(el2, 'baz')
828
829 al = Element('foo2')
830 al2 = SubElement(al, 'bar2')
831 al3 = SubElement(al2, 'baz2')
832
833 # now move al2 into el
834 el.append(al2)
835
836 # now change al3 directly
837 al3.text = 'baz2-modified'
838
839 # it should have changed through this route too
840 self.assertEquals(
841 'baz2-modified',
842 el[1][0].text)
843
845 Element = self.etree.Element
846 SubElement = self.etree.SubElement
847
848 a = Element('a')
849 b = SubElement(a, 'b')
850 a.text = 'hoi'
851 self.assertEquals(
852 'hoi',
853 a.text)
854 self.assertEquals(
855 'b',
856 a[0].tag)
857
859 Element = self.etree.Element
860 SubElement = self.etree.SubElement
861
862 a = Element('a')
863 a.text = 'hoi'
864 b = SubElement(a ,'b')
865 self.assertEquals(
866 'hoi',
867 a.text)
868 self.assertEquals(
869 'b',
870 a[0].tag)
871
873 Element = self.etree.Element
874
875 a = Element('a')
876
877 a.text = 'foo'
878 a.text = None
879
880 self.assertEquals(
881 None,
882 a.text)
883 self.assertXML('<a></a>', a)
884
886 Element = self.etree.Element
887
888 a = Element('a')
889 self.assertEquals(None, a.text)
890
891 a.text = ''
892 self.assertEquals('', a.text)
893 self.assertXML('<a></a>', a)
894
896 Element = self.etree.Element
897 SubElement = self.etree.SubElement
898
899 a = Element('a')
900 a.tail = 'dag'
901 self.assertEquals('dag',
902 a.tail)
903 b = SubElement(a, 'b')
904 b.tail = 'hoi'
905 self.assertEquals('hoi',
906 b.tail)
907 self.assertEquals('dag',
908 a.tail)
909
911 Element = self.etree.Element
912
913 a = Element('a')
914 b = Element('b')
915 b.tail = 'b_tail'
916 a.append(b)
917 self.assertEquals('b_tail',
918 b.tail)
919
921 Element = self.etree.Element
922 SubElement = self.etree.SubElement
923
924 a = Element('a')
925 b = SubElement(a, 'b')
926 b.tail = 'foo'
927 b.tail = 'bar'
928 self.assertEquals('bar',
929 b.tail)
930 self.assertXML('<a><b></b>bar</a>', a)
931
933 Element = self.etree.Element
934 a = Element('a')
935 a.tail = 'foo'
936 a.tail = None
937 self.assertEquals(
938 None,
939 a.tail)
940 self.assertXML('<a></a>', a)
941
943 Element = self.etree.Element
944 SubElement = self.etree.SubElement
945 Comment = self.etree.Comment
946
947 a = Element('a')
948 a.append(Comment('foo'))
949 self.assertEquals(a[0].tag, Comment)
950 self.assertEquals(a[0].text, 'foo')
951
953 Element = self.etree.Element
954 SubElement = self.etree.SubElement
955 Comment = self.etree.Comment
956
957 a = Element('a')
958 a.append(Comment('foo'))
959 self.assertEquals(a[0].text, 'foo')
960
961 a[0].text = "TEST"
962 self.assertEquals(a[0].text, 'TEST')
963
965 Element = self.etree.Element
966 SubElement = self.etree.SubElement
967 Comment = self.etree.Comment
968
969 a = Element('a')
970 a.append(Comment(' foo '))
971 self.assertEquals(a[0].text, ' foo ')
972
974 Comment = self.etree.Comment
975 c = Comment('foo')
976 self.assertEquals({}, c.attrib)
977 self.assertEquals([], c.keys())
978 self.assertEquals([], c.items())
979 self.assertEquals(None, c.get('hoi'))
980 self.assertEquals(0, len(c))
981 # should not iterate
982 for i in c:
983 pass
984
986 # lxml.etree separates target and text
987 Element = self.etree.Element
988 SubElement = self.etree.SubElement
989 ProcessingInstruction = self.etree.ProcessingInstruction
990
991 a = Element('a')
992 a.append(ProcessingInstruction('foo', 'some more text'))
993 self.assertEquals(a[0].tag, ProcessingInstruction)
994 self.assertXML("<a><?foo some more text?></a>",
995 a)
996
998 # lxml.etree separates target and text
999 Element = self.etree.Element
1000 SubElement = self.etree.SubElement
1001 ProcessingInstruction = self.etree.PI
1002
1003 a = Element('a')
1004 a.append(ProcessingInstruction('foo', 'some more text'))
1005 self.assertEquals(a[0].tag, ProcessingInstruction)
1006 self.assertXML("<a><?foo some more text?></a>",
1007 a)
1008
1010 ProcessingInstruction = self.etree.ProcessingInstruction
1011 pi = ProcessingInstruction('foo')
1012 self.assertEquals({}, pi.attrib)
1013 self.assertEquals([], pi.keys())
1014 self.assertEquals([], pi.items())
1015 self.assertEquals(None, pi.get('hoi'))
1016 self.assertEquals(0, len(pi))
1017 # should not iterate
1018 for i in pi:
1019 pass
1020
1022 Element = self.etree.Element
1023 SubElement = self.etree.SubElement
1024
1025 a = Element('a')
1026 b = SubElement(a, 'b')
1027 c = Element('c')
1028 a[0] = c
1029 self.assertEquals(
1030 c,
1031 a[0])
1032 self.assertXML('<a><c></c></a>',
1033 a)
1034 self.assertXML('<b></b>',
1035 b)
1036
1038 Element = self.etree.Element
1039 SubElement = self.etree.SubElement
1040
1041 a = Element('a')
1042 for i in range(5):
1043 b = SubElement(a, 'b%s' % i)
1044 c = SubElement(b, 'c')
1045 for i in range(5):
1046 d = Element('d')
1047 e = SubElement(d, 'e')
1048 a[i] = d
1049 self.assertXML(
1050 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>',
1051 a)
1052 self.assertXML('<c></c>',
1053 c)
1054
1056 Element = self.etree.Element
1057 SubElement = self.etree.SubElement
1058
1059 a = Element('a')
1060 SubElement(a, 'b')
1061 d = Element('d')
1062 a[0] = d
1063 self.assertXML('<a><d></d></a>', a)
1064
1066 Element = self.etree.Element
1067 SubElement = self.etree.SubElement
1068
1069 a = Element('a')
1070 b = SubElement(a, 'b')
1071
1072 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))
1073
1075 Element = self.etree.Element
1076 SubElement = self.etree.SubElement
1077
1078 a = Element('a')
1079 b = SubElement(a, 'b')
1080 b.tail = 'B2'
1081 c = Element('c')
1082 c.tail = 'C2'
1083
1084 a[0] = c
1085 self.assertXML(
1086 '<a><c></c>C2</a>',
1087 a)
1088
1090 Element = self.etree.Element
1091 SubElement = self.etree.SubElement
1092
1093 a = Element('a')
1094 b = SubElement(a, 'b')
1095
1096 a.tag = 'c'
1097
1098 self.assertEquals(
1099 'c',
1100 a.tag)
1101
1102 self.assertXML(
1103 '<c><b></b></c>',
1104 a)
1105
1107 Element = self.etree.Element
1108 SubElement = self.etree.SubElement
1109 tostring = self.etree.tostring
1110
1111 a = Element('{a}a')
1112 b1 = SubElement(a, '{a}b')
1113 b2 = SubElement(a, '{b}b')
1114
1115 self.assertEquals('{a}b', b1.tag)
1116
1117 b1.tag = 'c'
1118
1119 # can't use C14N here!
1120 self.assertEquals('c', b1.tag)
1121 self.assertEquals('<c', tostring(b1)[:2])
1122 self.assert_('<c' in tostring(a))
1123
1125 Element = self.etree.Element
1126 SubElement = self.etree.SubElement
1127 tostring = self.etree.tostring
1128
1129 a = Element('{a}a')
1130 b1 = SubElement(a, '{a}b')
1131 b2 = SubElement(a, '{b}b')
1132
1133 a.tag = 'c'
1134
1135 self.assertEquals(
1136 'c',
1137 a.tag)
1138
1139 # can't use C14N here!
1140 self.assertEquals('c', a.tag)
1141 self.assertEquals('<c', tostring(a)[:2])
1142
1148
1149 a = Element("a")
1150 a.tag = strTest("TAG")
1151 self.assertXML('<TAG></TAG>',
1152 a)
1153
1155 Element = self.etree.Element
1156 SubElement = self.etree.SubElement
1157
1158 a = Element('a')
1159 b = SubElement(a, 'b')
1160 c = SubElement(a, 'c')
1161 d = SubElement(a, 'd')
1162
1163 del a[1]
1164 self.assertXML(
1165 '<a><b></b><d></d></a>',
1166 a)
1167
1168 del a[0]
1169 self.assertXML(
1170 '<a><d></d></a>',
1171 a)
1172
1173 del a[0]
1174 self.assertXML(
1175 '<a></a>',
1176 a)
1177 # move deleted element into other tree afterwards
1178 other = Element('other')
1179 other.append(c)
1180 self.assertXML(
1181 '<other><c></c></other>',
1182 other)
1183
1185 Element = self.etree.Element
1186 SubElement = self.etree.SubElement
1187
1188 a = Element('a')
1189 b = SubElement(a, 'b')
1190 bs = SubElement(b, 'bs')
1191 c = SubElement(a, 'c')
1192 cs = SubElement(c, 'cs')
1193
1194 el = a[0]
1195 self.assertXML(
1196 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1197 a)
1198 self.assertXML('<b><bs></bs></b>', b)
1199 self.assertXML('<c><cs></cs></c>', c)
1200
1201 del a[0]
1202 self.assertXML(
1203 '<a><c><cs></cs></c></a>',
1204 a)
1205 self.assertXML('<b><bs></bs></b>', b)
1206 self.assertXML('<c><cs></cs></c>', c)
1207
1208 a.insert(0, el)
1209 self.assertXML(
1210 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1211 a)
1212 self.assertXML('<b><bs></bs></b>', b)
1213 self.assertXML('<c><cs></cs></c>', c)
1214
1216 Element = self.etree.Element
1217 SubElement = self.etree.SubElement
1218
1219 a = Element('a')
1220 b = SubElement(a, 'b')
1221 bs = SubElement(b, 'bs')
1222 c = SubElement(a, 'c')
1223 cs = SubElement(c, 'cs')
1224
1225 el = a[0]
1226 del a[0]
1227 a[0] = el
1228 self.assertXML(
1229 '<a><b><bs></bs></b></a>',
1230 a)
1231 self.assertXML('<b><bs></bs></b>', b)
1232 self.assertXML('<c><cs></cs></c>', c)
1233
1235 Element = self.etree.Element
1236 SubElement = self.etree.SubElement
1237
1238 a = Element('a')
1239 b = SubElement(a, 'b')
1240 bs = SubElement(b, 'bs')
1241 c = SubElement(a, 'c')
1242 cs = SubElement(c, 'cs')
1243
1244 el = a[0]
1245 del a[0]
1246 a[0:0] = [el]
1247 self.assertXML(
1248 '<a><b><bs></bs></b><c><cs></cs></c></a>',
1249 a)
1250 self.assertXML('<b><bs></bs></b>', b)
1251 self.assertXML('<c><cs></cs></c>', c)
1252
1254 XML = self.etree.XML
1255 a = XML('<a><b></b>B2<c></c>C2</a>')
1256 b, c = a
1257
1258 a[:] = []
1259
1260 self.assertEquals("B2", b.tail)
1261 self.assertEquals("C2", c.tail)
1262
1264 ElementTree = self.etree.ElementTree
1265 f = StringIO('<a><b></b>B2<c></c>C2</a>')
1266 doc = ElementTree(file=f)
1267 a = doc.getroot()
1268 del a[0]
1269 self.assertXML(
1270 '<a><c></c>C2</a>',
1271 a)
1272
1274 Element = self.etree.Element
1275
1276 a = Element('a')
1277 a.text = 'foo'
1278 a.tail = 'bar'
1279 a.set('hoi', 'dag')
1280 a.clear()
1281 self.assertEquals(None, a.text)
1282 self.assertEquals(None, a.tail)
1283 self.assertEquals(None, a.get('hoi'))
1284 self.assertEquals('a', a.tag)
1285
1287 Element = self.etree.Element
1288 SubElement = self.etree.SubElement
1289
1290 a = Element('a')
1291 a.text = 'foo'
1292 a.tail = 'bar'
1293 a.set('hoi', 'dag')
1294 b = SubElement(a, 'b')
1295 c = SubElement(b, 'c')
1296 a.clear()
1297 self.assertEquals(None, a.text)
1298 self.assertEquals(None, a.tail)
1299 self.assertEquals(None, a.get('hoi'))
1300 self.assertEquals('a', a.tag)
1301 self.assertEquals(0, len(a))
1302 self.assertXML('<a></a>',
1303 a)
1304 self.assertXML('<b><c></c></b>',
1305 b)
1306
1308 ElementTree = self.etree.ElementTree
1309 f = StringIO('<a><b></b>B2<c></c>C2</a>')
1310 doc = ElementTree(file=f)
1311 a = doc.getroot()
1312 a.clear()
1313 self.assertXML(
1314 '<a></a>',
1315 a)
1316
1318 Element = self.etree.Element
1319 SubElement = self.etree.SubElement
1320
1321 a = Element('a')
1322 b = SubElement(a, 'b')
1323 c = SubElement(a, 'c')
1324 d = Element('d')
1325 a.insert(0, d)
1326
1327 self.assertEquals(
1328 d,
1329 a[0])
1330
1331 self.assertXML(
1332 '<a><d></d><b></b><c></c></a>',
1333 a)
1334
1335 e = Element('e')
1336 a.insert(2, e)
1337 self.assertEquals(
1338 e,
1339 a[2])
1340 self.assertXML(
1341 '<a><d></d><b></b><e></e><c></c></a>',
1342 a)
1343
1345 Element = self.etree.Element
1346 SubElement = self.etree.SubElement
1347
1348 a = Element('a')
1349 b = SubElement(a, 'b')
1350 c = Element('c')
1351
1352 a.insert(2, c)
1353 self.assertEquals(
1354 c,
1355 a[1])
1356 self.assertXML(
1357 '<a><b></b><c></c></a>',
1358 a)
1359
1361 Element = self.etree.Element
1362 SubElement = self.etree.SubElement
1363
1364 a = Element('a')
1365 b = SubElement(a, 'b')
1366 c = SubElement(a, 'c')
1367
1368 d = Element('d')
1369 a.insert(-1, d)
1370 self.assertEquals(
1371 d,
1372 a[-2])
1373 self.assertXML(
1374 '<a><b></b><d></d><c></c></a>',
1375 a)
1376
1378 Element = self.etree.Element
1379 SubElement = self.etree.SubElement
1380
1381 a = Element('a')
1382 b = SubElement(a, 'b')
1383
1384 c = Element('c')
1385 c.tail = 'C2'
1386
1387 a.insert(0, c)
1388 self.assertXML(
1389 '<a><c></c>C2<b></b></a>',
1390 a)
1391
1393 Element = self.etree.Element
1394 SubElement = self.etree.SubElement
1395
1396 a = Element('a')
1397 b = SubElement(a, 'b')
1398 c = SubElement(a, 'c')
1399
1400 a.remove(b)
1401 self.assertEquals(
1402 c,
1403 a[0])
1404 self.assertXML(
1405 '<a><c></c></a>',
1406 a)
1407
1409 Element = self.etree.Element
1410 SubElement = self.etree.SubElement
1411
1412 a = Element('{http://test}a')
1413 b = SubElement(a, '{http://test}b')
1414 c = SubElement(a, '{http://test}c')
1415
1416 a.remove(b)
1417 self.assertXML(
1418 '<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>',
1419 a)
1420 self.assertXML(
1421 '<ns0:b xmlns:ns0="http://test"></ns0:b>',
1422 b)
1423
1425 Element = self.etree.Element
1426 SubElement = self.etree.SubElement
1427
1428 a = Element('a')
1429 b = SubElement(a, 'b')
1430 c = SubElement(a, 'c')
1431 d = Element('d')
1432 self.assertRaises(
1433 ValueError, a.remove, d)
1434
1436 Element = self.etree.Element
1437 SubElement = self.etree.SubElement
1438
1439 a = Element('a')
1440 b = SubElement(a, 'b')
1441 b.tail = 'b2'
1442 a.remove(b)
1443 self.assertXML(
1444 '<a></a>',
1445 a)
1446 self.assertEquals('b2', b.tail)
1447
1449 Element = self.etree.Element
1450 SubElement = self.etree.SubElement
1451
1452 a = Element('a')
1453 b = SubElement(a, 'b')
1454 c = SubElement(a, 'c')
1455 d = SubElement(b, 'd')
1456 e = SubElement(c, 'e')
1457 self.assertXML(
1458 '<a><b><d></d></b><c><e></e></c></a>',
1459 a)
1460 self.assertEquals(
1461 [b, c],
1462 a.getchildren())
1463 self.assertEquals(
1464 [d],
1465 b.getchildren())
1466 self.assertEquals(
1467 [],
1468 d.getchildren())
1469
1471 Element = self.etree.Element
1472
1473 a = Element('a')
1474 b = a.makeelement('c', {'hoi':'dag'})
1475 self.assertXML(
1476 '<c hoi="dag"></c>',
1477 b)
1478
1480 Element = self.etree.Element
1481 SubElement = self.etree.SubElement
1482
1483 a = Element('a')
1484 b = SubElement(a, 'b')
1485 c = SubElement(a, 'c')
1486 d = SubElement(b, 'd')
1487 e = SubElement(c, 'e')
1488
1489 self.assertEquals(
1490 [a, b, d, c, e],
1491 list(a.iter()))
1492 self.assertEquals(
1493 [d],
1494 list(d.iter()))
1495
1497 Element = self.etree.Element
1498 SubElement = self.etree.SubElement
1499
1500 a = Element('a')
1501 b = SubElement(a, 'b')
1502 c = SubElement(a, 'c')
1503 d = SubElement(b, 'd')
1504 e = SubElement(c, 'e')
1505
1506 self.assertEquals(
1507 [a, b, d, c, e],
1508 list(a.getiterator()))
1509 self.assertEquals(
1510 [d],
1511 list(d.getiterator()))
1512
1514 Element = self.etree.Element
1515 SubElement = self.etree.SubElement
1516
1517 a = Element('a')
1518 b = SubElement(a, 'b')
1519 c = SubElement(a, 'c')
1520 d = SubElement(b, 'd')
1521 e = SubElement(c, 'e')
1522
1523 self.assertEquals(
1524 [],
1525 list(a.getiterator('none')))
1526 self.assertEquals(
1527 [],
1528 list(e.getiterator('none')))
1529 self.assertEquals(
1530 [e],
1531 list(e.getiterator()))
1532
1534 Element = self.etree.Element
1535 SubElement = self.etree.SubElement
1536
1537 a = Element('a')
1538 b = SubElement(a, 'b')
1539 c = SubElement(a, 'c')
1540 d = SubElement(b, 'd')
1541 e = SubElement(c, 'e')
1542
1543 self.assertEquals(
1544 [a],
1545 list(a.getiterator('a')))
1546 a2 = SubElement(e, 'a')
1547 self.assertEquals(
1548 [a, a2],
1549 list(a.getiterator('a')))
1550 self.assertEquals(
1551 [a2],
1552 list(c.getiterator('a')))
1553
1555 Element = self.etree.Element
1556 SubElement = self.etree.SubElement
1557
1558 a = Element('a')
1559 b = SubElement(a, 'b')
1560 c = SubElement(a, 'c')
1561 d = SubElement(b, 'd')
1562 e = SubElement(c, 'e')
1563
1564 self.assertEquals(
1565 [a, b, d, c, e],
1566 list(a.getiterator('*')))
1567
1569 Element = self.etree.Element
1570 Comment = self.etree.Comment
1571 SubElement = self.etree.SubElement
1572
1573 a = Element('a')
1574 b = SubElement(a, 'b')
1575 comment_b = Comment("TEST-b")
1576 b.append(comment_b)
1577
1578 self.assertEquals(
1579 [comment_b],
1580 list(a.getiterator(Comment)))
1581
1582 comment_a = Comment("TEST-a")
1583 a.append(comment_a)
1584
1585 self.assertEquals(
1586 [comment_b, comment_a],
1587 list(a.getiterator(Comment)))
1588
1589 self.assertEquals(
1590 [comment_b],
1591 list(b.getiterator(Comment)))
1592
1594 Element = self.etree.Element
1595 PI = self.etree.ProcessingInstruction
1596 SubElement = self.etree.SubElement
1597
1598 a = Element('a')
1599 b = SubElement(a, 'b')
1600 pi_b = PI("TEST-b")
1601 b.append(pi_b)
1602
1603 self.assertEquals(
1604 [pi_b],
1605 list(a.getiterator(PI)))
1606
1607 pi_a = PI("TEST-a")
1608 a.append(pi_a)
1609
1610 self.assertEquals(
1611 [pi_b, pi_a],
1612 list(a.getiterator(PI)))
1613
1614 self.assertEquals(
1615 [pi_b],
1616 list(b.getiterator(PI)))
1617
1619 Element = self.etree.Element
1620 SubElement = self.etree.SubElement
1621
1622 a = Element('a')
1623 a.text = 'a'
1624 b = SubElement(a, 'b')
1625 b.text = 'b'
1626 b.tail = 'b1'
1627 c = SubElement(a, 'c')
1628 c.text = 'c'
1629 c.tail = 'c1'
1630 d = SubElement(b, 'd')
1631 c.text = 'd'
1632 c.tail = 'd1'
1633 e = SubElement(c, 'e')
1634 e.text = 'e'
1635 e.tail = 'e1'
1636
1637 self.assertEquals(
1638 [a, b, d, c, e],
1639 list(a.getiterator()))
1640 #self.assertEquals(
1641 # [d],
1642 # list(d.getiterator()))
1643
1645 Element = self.etree.Element
1646 SubElement = self.etree.SubElement
1647
1648 a = Element('a')
1649 a.text = 'a'
1650 b = SubElement(a, 'b')
1651 b.text = 'b'
1652 b.tail = 'b1'
1653 c = SubElement(a, 'c')
1654 c.text = 'c'
1655 c.tail = 'c1'
1656 d = SubElement(b, 'd')
1657 c.text = 'd'
1658 c.tail = 'd1'
1659 e = SubElement(c, 'e')
1660 e.text = 'e'
1661 e.tail = 'e1'
1662
1663 self.assertEquals(
1664 [a],
1665 list(a.getiterator('a')))
1666 a2 = SubElement(e, 'a')
1667 self.assertEquals(
1668 [a, a2],
1669 list(a.getiterator('a')))
1670 self.assertEquals(
1671 [a2],
1672 list(e.getiterator('a')))
1673
1675 Element = self.etree.Element
1676
1677 a = Element('a')
1678 a.attrib['foo'] = 'Foo'
1679 a.attrib['bar'] = 'Bar'
1680 self.assertEquals('Foo', a.attrib['foo'])
1681 del a.attrib['foo']
1682 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
1683
1685 Element = self.etree.Element
1686 SubElement = self.etree.SubElement
1687
1688 a = Element('a')
1689 b = SubElement(a, 'b')
1690 c = SubElement(a, 'c')
1691 d = SubElement(a, 'd')
1692
1693 self.assertEquals(
1694 [b, c],
1695 a[0:2])
1696 self.assertEquals(
1697 [b, c, d],
1698 a[:])
1699 self.assertEquals(
1700 [b, c, d],
1701 a[:10])
1702 self.assertEquals(
1703 [b],
1704 a[0:1])
1705 self.assertEquals(
1706 [],
1707 a[10:12])
1708
1710 Element = self.etree.Element
1711 SubElement = self.etree.SubElement
1712
1713 a = Element('a')
1714 b = SubElement(a, 'b')
1715 c = SubElement(a, 'c')
1716 d = SubElement(a, 'd')
1717
1718 self.assertEquals(
1719 [d],
1720 a[-1:])
1721 self.assertEquals(
1722 [c, d],
1723 a[-2:])
1724 self.assertEquals(
1725 [c],
1726 a[-2:-1])
1727 self.assertEquals(
1728 [b, c],
1729 a[-3:-1])
1730 self.assertEquals(
1731 [b, c],
1732 a[-3:2])
1733
1735 Element = self.etree.Element
1736 SubElement = self.etree.SubElement
1737
1738 a = Element('a')
1739 b = SubElement(a, 'b')
1740 c = SubElement(a, 'c')
1741 d = SubElement(a, 'd')
1742 e = SubElement(a, 'e')
1743
1744 self.assertEquals(
1745 [e,d,c,b],
1746 a[::-1])
1747 self.assertEquals(
1748 [b,d],
1749 a[::2])
1750 self.assertEquals(
1751 [e,c],
1752 a[::-2])
1753 self.assertEquals(
1754 [d,c],
1755 a[-2:0:-1])
1756 self.assertEquals(
1757 [e],
1758 a[:1:-2])
1759
1761 ElementTree = self.etree.ElementTree
1762
1763 f = StringIO('<a><b>B</b>B1<c>C</c>C1</a>')
1764 doc = ElementTree(file=f)
1765 a = doc.getroot()
1766 b = a[0]
1767 c = a[1]
1768 self.assertEquals(
1769 [b, c],
1770 a[:])
1771 self.assertEquals(
1772 [b],
1773 a[0:1])
1774 self.assertEquals(
1775 [c],
1776 a[1:])
1777
1779 Element = self.etree.Element
1780 Comment = self.etree.Comment
1781 SubElement = self.etree.SubElement
1782
1783 a = Element('a')
1784 b = SubElement(a, 'b')
1785 foo = Comment('foo')
1786 a.append(foo)
1787 c = SubElement(a, 'c')
1788 self.assertEquals(
1789 [b, foo, c],
1790 a[:])
1791 self.assertEquals(
1792 foo,
1793 a[1])
1794 a[1] = new = Element('new')
1795 self.assertEquals(
1796 new,
1797 a[1])
1798 self.assertXML(
1799 '<a><b></b><new></new><c></c></a>',
1800 a)
1801
1803 Element = self.etree.Element
1804 SubElement = self.etree.SubElement
1805
1806 a = Element('a')
1807 b = SubElement(a, 'b')
1808 c = SubElement(a, 'c')
1809 d = SubElement(a, 'd')
1810 e = SubElement(a, 'e')
1811
1812 del a[1:3]
1813 self.assertEquals(
1814 [b, e],
1815 list(a))
1816
1818 Element = self.etree.Element
1819 SubElement = self.etree.SubElement
1820
1821 a = Element('a')
1822 b = SubElement(a, 'b')
1823 c = SubElement(a, 'c')
1824 d = SubElement(a, 'd')
1825 e = SubElement(a, 'e')
1826
1827 del a[1:-1]
1828 self.assertEquals(
1829 [b, e],
1830 list(a))
1831
1833 Element = self.etree.Element
1834 SubElement = self.etree.SubElement
1835
1836 a = Element('a')
1837 b = SubElement(a, 'b')
1838 c = SubElement(a, 'c')
1839 d = SubElement(a, 'd')
1840 e = SubElement(a, 'e')
1841
1842 del a[-3:-1]
1843 self.assertEquals(
1844 [b, e],
1845 list(a))
1846
1848 Element = self.etree.Element
1849 SubElement = self.etree.SubElement
1850
1851 a = Element('a')
1852 b = SubElement(a, 'b')
1853 c = SubElement(a, 'c')
1854 d = SubElement(a, 'd')
1855 e = SubElement(a, 'e')
1856
1857 del a[1::2]
1858 self.assertEquals(
1859 [b, d],
1860 list(a))
1861
1863 Element = self.etree.Element
1864 SubElement = self.etree.SubElement
1865
1866 a = Element('a')
1867 b = SubElement(a, 'b')
1868 c = SubElement(a, 'c')
1869 d = SubElement(a, 'd')
1870 e = SubElement(a, 'e')
1871
1872 del a[::-1]
1873 self.assertEquals(
1874 [],
1875 list(a))
1876
1878 Element = self.etree.Element
1879 SubElement = self.etree.SubElement
1880
1881 a = Element('a')
1882 b = SubElement(a, 'b')
1883 c = SubElement(a, 'c')
1884 d = SubElement(a, 'd')
1885 e = SubElement(a, 'e')
1886
1887 del a[::-2]
1888 self.assertEquals(
1889 [b, d],
1890 list(a))
1891
1893 ElementTree = self.etree.ElementTree
1894 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
1895 doc = ElementTree(file=f)
1896 a = doc.getroot()
1897 del a[1:3]
1898 self.assertXML(
1899 '<a><b></b>B2<e></e>E2</a>',
1900 a)
1901
1903 XML = self.etree.XML
1904 a = XML('<a><b></b>B2<c></c>C2</a>')
1905 b, c = a
1906
1907 del a[:]
1908
1909 self.assertEquals("B2", b.tail)
1910 self.assertEquals("C2", c.tail)
1911
1913 # this could trigger a crash
1914 Element = self.etree.Element
1915 SubElement = self.etree.SubElement
1916 a = Element('a')
1917 b = SubElement(a, 'b')
1918 c = SubElement(b, 'c')
1919 del b # no more reference to b
1920 del a[:]
1921 self.assertEquals('c', c.tag)
1922
1924 Element = self.etree.Element
1925 SubElement = self.etree.SubElement
1926
1927 a = Element('a')
1928 b = SubElement(a, 'b')
1929 c = SubElement(a, 'c')
1930 d = SubElement(a, 'd')
1931
1932 e = Element('e')
1933 f = Element('f')
1934 g = Element('g')
1935
1936 s = [e, f, g]
1937 a[1:2] = s
1938 self.assertEquals(
1939 [b, e, f, g, d],
1940 list(a))
1941
1943 Element = self.etree.Element
1944 SubElement = self.etree.SubElement
1945
1946 a = Element('a')
1947 b = SubElement(a, 'b')
1948 c = SubElement(a, 'c')
1949
1950 e = Element('e')
1951 f = Element('f')
1952 g = Element('g')
1953
1954 s = [e, f, g]
1955 a[:] = s
1956 self.assertEquals(
1957 [e, f, g],
1958 list(a))
1959
1961 Element = self.etree.Element
1962 SubElement = self.etree.SubElement
1963
1964 a = Element('a')
1965
1966 e = Element('e')
1967 f = Element('f')
1968 g = Element('g')
1969
1970 s = [e, f, g]
1971 a[:] = s
1972 self.assertEquals(
1973 [e, f, g],
1974 list(a))
1975
1977 Element = self.etree.Element
1978 SubElement = self.etree.SubElement
1979
1980 a = Element('a')
1981 b = SubElement(a, 'b')
1982 c = SubElement(a, 'c')
1983 d = SubElement(a, 'd')
1984
1985 s = [b, c, d]
1986 a[:] = s
1987 self.assertEquals(
1988 [b, c, d],
1989 list(a))
1990
1992 Element = self.etree.Element
1993 SubElement = self.etree.SubElement
1994
1995 a = Element('a')
1996 b = SubElement(a, 'b')
1997 c = SubElement(a, 'c')
1998 d = SubElement(a, 'd')
1999
2000 s = [d, c, b]
2001 a[:] = s
2002 self.assertEquals(
2003 [d, c, b],
2004 list(a))
2005
2007 Element = self.etree.Element
2008 SubElement = self.etree.SubElement
2009
2010 a = Element('{ns}a')
2011 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
2012 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
2013 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
2014
2015 s = [d, c, b]
2016 a[:] = s
2017 self.assertEquals(
2018 [d, c, b],
2019 list(a))
2020 self.assertEquals(
2021 ['{ns}d', '{ns}c', '{ns}b'],
2022 [ child.tag for child in a ])
2023
2024 self.assertEquals(
2025 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
2026 [ child.attrib.keys() for child in a ])
2027
2029 Element = self.etree.Element
2030 SubElement = self.etree.SubElement
2031
2032 a = Element('{ns}a')
2033 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
2034 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
2035 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
2036
2037 s = [d, c, b]
2038 a[:] = s
2039 self.assertEquals(
2040 [d, c, b],
2041 list(a))
2042 self.assertEquals(
2043 ['{ns3}d', '{ns2}c', '{ns1}b'],
2044 [ child.tag for child in a ])
2045
2046 self.assertEquals(
2047 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
2048 [ child.attrib.keys() for child in a ])
2049
2051 Element = self.etree.Element
2052 SubElement = self.etree.SubElement
2053
2054 a = Element('a')
2055 b = SubElement(a, 'b')
2056 c = SubElement(a, 'c')
2057
2058 e = Element('e')
2059 f = Element('f')
2060 g = Element('g')
2061 h = Element('h')
2062
2063 s = [e, f]
2064 a[99:] = s
2065 self.assertEquals(
2066 [a, b, e, f],
2067 list(a))
2068
2069 s = [g, h]
2070 a[:0] = s
2071 self.assertEquals(
2072 [g, h, a, b, e, f],
2073 list(a))
2074
2076 Element = self.etree.Element
2077 SubElement = self.etree.SubElement
2078
2079 a = Element('a')
2080 b = SubElement(a, 'b')
2081 c = SubElement(a, 'c')
2082
2083 e = Element('e')
2084 f = Element('f')
2085
2086 s = [e]
2087 a[0:1] = s
2088 self.assertEquals(
2089 [e, c],
2090 list(a))
2091
2092 s = [f]
2093 a[1:2] = s
2094 self.assertEquals(
2095 [e, f],
2096 list(a))
2097
2099 ElementTree = self.etree.ElementTree
2100 Element = self.etree.Element
2101 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
2102 doc = ElementTree(file=f)
2103 a = doc.getroot()
2104 x = Element('x')
2105 y = Element('y')
2106 z = Element('z')
2107 x.tail = 'X2'
2108 y.tail = 'Y2'
2109 z.tail = 'Z2'
2110 a[1:3] = [x, y, z]
2111 self.assertXML(
2112 '<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>',
2113 a)
2114
2116 Element = self.etree.Element
2117 SubElement = self.etree.SubElement
2118
2119 a = Element('a')
2120 b = SubElement(a, 'b')
2121 c = SubElement(a, 'c')
2122 d = SubElement(a, 'd')
2123
2124 x = Element('x')
2125 y = Element('y')
2126
2127 a[1:-1] = [x, y]
2128 self.assertEquals(
2129 [b, x, y, d],
2130 list(a))
2131
2133 Element = self.etree.Element
2134 SubElement = self.etree.SubElement
2135
2136 a = Element('a')
2137 b = SubElement(a, 'b')
2138 c = SubElement(a, 'c')
2139 d = SubElement(a, 'd')
2140
2141 x = Element('x')
2142 y = Element('y')
2143
2144 a[1:-2] = [x, y]
2145 self.assertEquals(
2146 [b, x, y, c, d],
2147 list(a))
2148
2150 Element = self.etree.Element
2151 SubElement = self.etree.SubElement
2152
2153 a = Element('a')
2154 b = SubElement(a, 'b')
2155 c = SubElement(a, 'c')
2156 d = SubElement(a, 'd')
2157
2158 e = Element('e')
2159 f = Element('f')
2160 g = Element('g')
2161
2162 s = [e, f, g]
2163 a[3:] = s
2164 self.assertEquals(
2165 [b, c, d, e, f, g],
2166 list(a))
2167
2169 Element = self.etree.Element
2170
2171 a = Element('a')
2172
2173 b = Element('b')
2174 c = Element('c')
2175
2176 a[:] = [b, c]
2177 self.assertEquals(
2178 [b, c],
2179 list(a))
2180
2182 Element = self.etree.Element
2183 ElementTree = self.etree.ElementTree
2184
2185 a = Element('a')
2186 a.tail = 'A2'
2187 t = ElementTree(element=a)
2188 self.assertEquals('A2',
2189 a.tail)
2190
2192 Element = self.etree.Element
2193 SubElement = self.etree.SubElement
2194 ElementTree = self.etree.ElementTree
2195
2196 a = Element('a')
2197 b = SubElement(a, 'b')
2198 c = SubElement(a, 'c')
2199 d = SubElement(b, 'd')
2200 e = SubElement(c, 'e')
2201 t = ElementTree(element=a)
2202
2203 self.assertEquals(
2204 [a, b, d, c, e],
2205 list(t.getiterator()))
2206
2208 Element = self.etree.Element
2209 SubElement = self.etree.SubElement
2210 ElementTree = self.etree.ElementTree
2211 a = Element('a')
2212 b = SubElement(a, 'b')
2213 c = SubElement(a, 'c')
2214 d = SubElement(b, 'd')
2215 e = SubElement(c, 'e')
2216 t = ElementTree(element=a)
2217
2218 self.assertEquals(
2219 [a],
2220 list(t.getiterator('a')))
2221 a2 = SubElement(e, 'a')
2222 self.assertEquals(
2223 [a, a2],
2224 list(t.getiterator('a')))
2225
2227 ElementTree = self.etree.ElementTree
2228 ns = 'http://xml.infrae.com/1'
2229 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
2230 t = ElementTree(file=f)
2231 a = t.getroot()
2232 self.assertEquals('{%s}a' % ns,
2233 a.tag)
2234 self.assertEquals('{%s}b' % ns,
2235 a[0].tag)
2236
2238 ElementTree = self.etree.ElementTree
2239 ns = 'http://xml.infrae.com/1'
2240 ns2 = 'http://xml.infrae.com/2'
2241 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2242 t = ElementTree(file=f)
2243 a = t.getroot()
2244 self.assertEquals('{%s}a' % ns,
2245 a.tag)
2246 self.assertEquals('{%s}b' % ns,
2247 a[0].tag)
2248 self.assertEquals('{%s}b' % ns2,
2249 a[1].tag)
2250
2252 Element = self.etree.Element
2253 SubElement = self.etree.SubElement
2254 ns = 'http://xml.infrae.com/1'
2255 ns2 = 'http://xml.infrae.com/2'
2256 a = Element('{%s}a' % ns)
2257 b = SubElement(a, '{%s}b' % ns2)
2258 c = SubElement(a, '{%s}c' % ns)
2259 self.assertEquals('{%s}a' % ns,
2260 a.tag)
2261 self.assertEquals('{%s}b' % ns2,
2262 b.tag)
2263 self.assertEquals('{%s}c' % ns,
2264 c.tag)
2265 self.assertEquals('{%s}a' % ns,
2266 a.tag)
2267 self.assertEquals('{%s}b' % ns2,
2268 b.tag)
2269 self.assertEquals('{%s}c' % ns,
2270 c.tag)
2271
2273 Element = self.etree.Element
2274 SubElement = self.etree.SubElement
2275 ElementTree = self.etree.ElementTree
2276
2277 ns = 'http://xml.infrae.com/1'
2278 ns2 = 'http://xml.infrae.com/2'
2279 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2))
2280 t = ElementTree(file=f)
2281
2282 a = t.getroot()
2283 self.assertEquals('{%s}a' % ns,
2284 a.tag)
2285 self.assertEquals('{%s}b' % ns2,
2286 a[0].tag)
2287 self.assertEquals('{%s}b' % ns,
2288 a[1].tag)
2289
2291 Element = self.etree.Element
2292 ns = 'http://xml.infrae.com/1'
2293 ns2 = 'http://xml.infrae.com/2'
2294 a = Element('a')
2295 a.set('{%s}foo' % ns, 'Foo')
2296 a.set('{%s}bar' % ns2, 'Bar')
2297 self.assertEquals(
2298 'Foo',
2299 a.get('{%s}foo' % ns))
2300 self.assertEquals(
2301 'Bar',
2302 a.get('{%s}bar' % ns2))
2303 try:
2304 self.assertXML(
2305 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2),
2306 a)
2307 except AssertionError:
2308 self.assertXML(
2309 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns),
2310 a)
2311
2313 Element = self.etree.Element
2314 ElementTree = self.etree.ElementTree
2315
2316 one = self.etree.parse(
2317 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
2318 baz = one.getroot()[0][0]
2319
2320 two = ElementTree(Element('root'))
2321 two.getroot().append(baz)
2322 # removing the originating document could cause a crash/error before
2323 # as namespace is not moved along with it
2324 del one
2325 self.assertEquals('{http://a.b.c}baz', baz.tag)
2326
2328 tostring = self.etree.tostring
2329 root = self.etree.XML(
2330 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')
2331 baz = root[0][0]
2332
2333 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2334 tostring(baz))
2335 self.assertEquals(["http://a.b.c"], nsdecl)
2336
2338 tostring = self.etree.tostring
2339 root = self.etree.XML(
2340 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')
2341 baz = root[0][0]
2342
2343 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2344 tostring(baz))
2345 self.assertEquals(["http://a.b.c"], nsdecl)
2346
2348 tostring = self.etree.tostring
2349 root = self.etree.XML(
2350 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')
2351 baz = root[0][0]
2352
2353 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2354 tostring(baz))
2355
2356 self.assertEquals(["http://a.b.c"], nsdecl)
2357
2359 Element = self.etree.Element
2360 SubElement = self.etree.SubElement
2361
2362 root = Element("foo")
2363 bar = SubElement(root, "{http://a.b.c}bar")
2364 baz = SubElement(bar, "{http://a.b.c}baz")
2365
2366 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']",
2367 self.etree.tostring(baz))
2368
2369 self.assertEquals(["http://a.b.c"], nsdecl)
2370
2372 Element = self.etree.Element
2373
2374 root = Element('element')
2375
2376 subelement = Element('subelement',
2377 {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2378 self.assertEquals(1, len(subelement.attrib))
2379 self.assertEquals(
2380 "foo",
2381 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2382
2383 root.append(subelement)
2384 self.assertEquals(1, len(subelement.attrib))
2385 self.assertEquals(
2386 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(),
2387 subelement.attrib.items())
2388 self.assertEquals(
2389 "foo",
2390 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2391
2393 tostring = self.etree.tostring
2394 Element = self.etree.Element
2395 SubElement = self.etree.SubElement
2396
2397 a = Element('a')
2398 b = SubElement(a, 'b')
2399 c = SubElement(a, 'c')
2400
2401 self.assertEquals('<a><b></b><c></c></a>',
2402 canonicalize(tostring(a)))
2403
2405 tostring = self.etree.tostring
2406 Element = self.etree.Element
2407 SubElement = self.etree.SubElement
2408
2409 a = Element('a')
2410 b = SubElement(a, 'b')
2411 c = SubElement(a, 'c')
2412 d = SubElement(c, 'd')
2413 self.assertEquals('<b></b>',
2414 canonicalize(tostring(b)))
2415 self.assertEquals('<c><d></d></c>',
2416 canonicalize(tostring(c)))
2417
2419 tostring = self.etree.tostring
2420 Element = self.etree.Element
2421 SubElement = self.etree.SubElement
2422
2423 a = Element('a')
2424 b = SubElement(a, 'b')
2425 c = SubElement(a, 'c')
2426 d = SubElement(c, 'd')
2427 b.tail = 'Foo'
2428
2429 self.assert_(tostring(b) == '<b/>Foo' or
2430 tostring(b) == '<b />Foo')
2431
2433 tostring = self.etree.tostring
2434 Element = self.etree.Element
2435 SubElement = self.etree.SubElement
2436
2437 html = Element('html')
2438 body = SubElement(html, 'body')
2439 p = SubElement(body, 'p')
2440 p.text = "html"
2441 SubElement(p, 'br').tail = "test"
2442
2443 self.assertEquals('<html><body><p>html<br>test</p></body></html>',
2444 tostring(html, method="html"))
2445
2447 tostring = self.etree.tostring
2448 Element = self.etree.Element
2449 SubElement = self.etree.SubElement
2450
2451 a = Element('a')
2452 a.text = "A"
2453 a.tail = "tail"
2454 b = SubElement(a, 'b')
2455 b.text = "B"
2456 b.tail = "TAIL"
2457 c = SubElement(a, 'c')
2458 c.text = "C"
2459
2460 self.assertEquals('ABTAILCtail',
2461 tostring(a, method="text"))
2462
2464 iterparse = self.etree.iterparse
2465 f = StringIO('<a><b></b><c/></a>')
2466
2467 iterator = iterparse(f)
2468 self.assertEquals(None,
2469 iterator.root)
2470 events = list(iterator)
2471 root = iterator.root
2472 self.assertEquals(
2473 [('end', root[0]), ('end', root[1]), ('end', root)],
2474 events)
2475
2477 iterparse = self.etree.iterparse
2478 iterator = iterparse(fileInTestDir("test.xml"))
2479 self.assertEquals(None,
2480 iterator.root)
2481 events = list(iterator)
2482 root = iterator.root
2483 self.assertEquals(
2484 [('end', root[0]), ('end', root)],
2485 events)
2486
2488 iterparse = self.etree.iterparse
2489 f = StringIO('<a><b></b><c/></a>')
2490
2491 iterator = iterparse(f, events=('start',))
2492 events = list(iterator)
2493 root = iterator.root
2494 self.assertEquals(
2495 [('start', root), ('start', root[0]), ('start', root[1])],
2496 events)
2497
2499 iterparse = self.etree.iterparse
2500 f = StringIO('<a><b></b><c/></a>')
2501
2502 iterator = iterparse(f, events=('start','end'))
2503 events = list(iterator)
2504 root = iterator.root
2505 self.assertEquals(
2506 [('start', root), ('start', root[0]), ('end', root[0]),
2507 ('start', root[1]), ('end', root[1]), ('end', root)],
2508 events)
2509
2511 iterparse = self.etree.iterparse
2512 f = StringIO('<a><b></b><c/></a>')
2513
2514 iterator = iterparse(f)
2515 for event, elem in iterator:
2516 elem.clear()
2517
2518 root = iterator.root
2519 self.assertEquals(0,
2520 len(root))
2521
2523 iterparse = self.etree.iterparse
2524 CHILD_COUNT = 12345
2525 f = StringIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
2526
2527 i = 0
2528 for key in iterparse(f):
2529 event, element = key
2530 i += 1
2531 self.assertEquals(i, CHILD_COUNT + 1)
2532
2534 iterparse = self.etree.iterparse
2535 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
2536
2537 attr_name = '{testns}bla'
2538 events = []
2539 iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
2540 for event, elem in iterator:
2541 events.append(event)
2542 if event == 'start':
2543 if elem.tag != '{ns1}a':
2544 elem.set(attr_name, 'value')
2545
2546 self.assertEquals(
2547 ['start-ns', 'start', 'start', 'start-ns', 'start',
2548 'end', 'end-ns', 'end', 'end', 'end-ns'],
2549 events)
2550
2551 root = iterator.root
2552 self.assertEquals(
2553 None,
2554 root.get(attr_name))
2555 self.assertEquals(
2556 'value',
2557 root[0].get(attr_name))
2558
2560 iterparse = self.etree.iterparse
2561 f = StringIO('<a><b><d/></b><c/></a>')
2562
2563 counts = []
2564 for event, elem in iterparse(f):
2565 counts.append(len(list(elem.getiterator())))
2566 self.assertEquals(
2567 [1,2,1,4],
2568 counts)
2569
2571 iterparse = self.etree.iterparse
2572 f = StringIO('<a><b><d/></b><c/></a>')
2573
2574 for event, node in etree.iterparse(f): pass
2575
2576 root = etree.Element('new_root', {})
2577 root[:] = node[:]
2578
2579 self.assertEquals(
2580 ['b', 'c'],
2581 [ el.tag for el in root ])
2582
2584 parse = self.etree.parse
2585 # from file
2586 tree = parse(fileInTestDir('test.xml'))
2587 self.assertXML(
2588 '<a><b></b></a>',
2589 tree.getroot())
2590
2594
2596 parse = self.etree.parse
2597 # from file object
2598 f = open(fileInTestDir('test.xml'), 'r')
2599 tree = parse(f)
2600 f.close()
2601 self.assertXML(
2602 '<a><b></b></a>',
2603 tree.getroot())
2604
2606 parse = self.etree.parse
2607 # from StringIO
2608 f = StringIO('<a><b></b></a>')
2609 tree = parse(f)
2610 f.close()
2611 self.assertXML(
2612 '<a><b></b></a>',
2613 tree.getroot()
2614 )
2615
2617 # this can fail in libxml2 <= 2.6.22
2618 parse = self.etree.parse
2619 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>'))
2620 self.assertXML('<html></html>',
2621 tree.getroot())
2622
2624 Element = self.etree.Element
2625
2626 a = Element('a')
2627 a.text = u'Søk på nettet'
2628 self.assertXML(
2629 u'<a>Søk på nettet</a>'.encode('UTF-8'),
2630 a, 'utf-8')
2631
2633 ElementTree = self.etree.ElementTree
2634 Element = self.etree.Element
2635
2636 a = Element('a')
2637 a.text = u'Søk på nettet'
2638
2639 f = StringIO()
2640 tree = ElementTree(element=a)
2641 tree.write(f, encoding='utf-8')
2642 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'),
2643 f.getvalue().replace('\n',''))
2644
2646 parse = self.etree.parse
2647 # from file
2648 tree = parse(fileInTestDir('test-string.xml'))
2649 self.assertXML(
2650 u'<a>Søk på nettet</a>'.encode('UTF-8'),
2651 tree.getroot(), 'UTF-8')
2652
2654 parse = self.etree.parse
2655 # from file object
2656 f = open(fileInTestDir('test-string.xml'), 'r')
2657 tree = parse(f)
2658 f.close()
2659 self.assertXML(
2660 u'<a>Søk på nettet</a>'.encode('UTF-8'),
2661 tree.getroot(), 'UTF-8')
2662
2664 ElementTree = self.etree.ElementTree
2665 Element = self.etree.Element
2666
2667 a = Element('a')
2668 a.text = u'Søk på nettet'
2669
2670 f = StringIO()
2671 tree = ElementTree(element=a)
2672 tree.write(f, encoding='iso-8859-1')
2673 result = f.getvalue()
2674 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>"
2675 self.assertEncodingDeclaration(result,'iso-8859-1')
2676 result = result.split('?>', 1)[-1].replace('\n','')
2677 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'),
2678 result)
2679
2681 XMLParser = self.etree.XMLParser
2682
2683 text = u'Søk på nettet'
2684 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1')
2685
2686 self.assertRaises(self.etree.ParseError,
2687 self.etree.parse,
2688 StringIO(xml_latin1))
2689
2690 tree = self.etree.parse(StringIO(xml_latin1),
2691 XMLParser(encoding="iso-8859-1"))
2692 a = tree.getroot()
2693 self.assertEquals(a.text, text)
2694
2696 XMLParser = self.etree.XMLParser
2697
2698 text = u'Søk på nettet'
2699 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
2700 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text)
2701 ).encode('iso-8859-1')
2702
2703 self.assertRaises(self.etree.ParseError,
2704 self.etree.parse,
2705 StringIO(xml_latin1))
2706
2707 tree = self.etree.parse(StringIO(xml_latin1),
2708 XMLParser(encoding="iso-8859-1"))
2709 a = tree.getroot()
2710 self.assertEquals(a.text, text)
2711
2713 # raise error on wrong encoding declaration in unicode strings
2714 XML = self.etree.XML
2715 test_utf = (u'<?xml version="1.0" encoding="iso-8859-1"?>' + \
2716 u'<a>Søk på nettet</a>')
2717 self.assertRaises(SyntaxError, XML, test_utf)
2718
2720 ElementTree = self.etree.ElementTree
2721 Element = self.etree.Element
2722
2723 a = Element('a')
2724 a.text = u'Søk på nettet'
2725
2726 f = StringIO()
2727 tree = ElementTree(element=a)
2728 tree.write(f)
2729 data = f.getvalue().replace('\n','')
2730 self.assertEquals(
2731 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'),
2732 data)
2733
2735 Element = self.etree.Element
2736 tostring = self.etree.tostring
2737
2738 a = Element('a')
2739 a.text = u'Søk på nettet'
2740 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'),
2741 tostring(a, encoding='utf-8'))
2742
2744 Element = self.etree.Element
2745 tostring = self.etree.tostring
2746
2747 a = Element('a')
2748 a.text = u'Søk på nettet'
2749 self.assertRaises(LookupError, tostring, a,
2750 encoding='Invalid Encoding')
2751
2753 Element = self.etree.Element
2754 SubElement = self.etree.SubElement
2755 tostring = self.etree.tostring
2756
2757 a = Element('a')
2758 b = SubElement(a, 'b')
2759 b.text = u'Søk på nettet'
2760 self.assertEquals(u'<b>Søk på nettet</b>'.encode('UTF-8'),
2761 tostring(b, encoding='utf-8'))
2762
2764 Element = self.etree.Element
2765 SubElement = self.etree.SubElement
2766 tostring = self.etree.tostring
2767
2768 a = Element('a')
2769 b = SubElement(a, 'b')
2770 b.text = u'Søk på nettet'
2771 b.tail = u'Søk'
2772 self.assertEquals(u'<b>Søk på nettet</b>Søk'.encode('UTF-8'),
2773 tostring(b, encoding='utf-8'))
2774
2776 Element = self.etree.Element
2777 SubElement = self.etree.SubElement
2778 tostring = self.etree.tostring
2779
2780 a = Element('a')
2781 a.text = u'Søk på nettet'
2782
2783 expected = '<a>Søk på nettet</a>'
2784 self.assertEquals(
2785 expected,
2786 tostring(a))
2787
2789 Element = self.etree.Element
2790 SubElement = self.etree.SubElement
2791 tostring = self.etree.tostring
2792
2793 a = Element('a')
2794 b = SubElement(a, 'b')
2795 b.text = u'Søk på nettet'
2796
2797 expected = '<b>Søk på nettet</b>'
2798 self.assertEquals(
2799 expected,
2800 tostring(b))
2801
2803 utext = u'Søk på nettet'
2804 uxml = u'<p>%s</p>' % utext
2805 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2806 isoxml = prologue + uxml.encode('iso-8859-1')
2807 tree = self.etree.XML(isoxml)
2808 self.assertEquals(utext, tree.text)
2809
2811 utext = u'Søk på nettet'
2812 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \
2813 u'<p>%s</p>' % utext
2814 bom = '\xEF\xBB\xBF'
2815 xml = bom + uxml.encode("utf-8")
2816 tree = etree.XML(xml)
2817 self.assertEquals(utext, tree.text)
2818
2820 utext = u'Søk på nettet'
2821 uxml = u'<p>%s</p>' % utext
2822 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>'
2823 isoxml = prologue + uxml.encode('iso-8859-1')
2824 el = self.etree.parse(StringIO(isoxml)).getroot()
2825 self.assertEquals(utext, el.text)
2826
2828 Element = self.etree.Element
2829 ElementTree = self.etree.ElementTree
2830
2831 a = Element('a')
2832 a.text = "Foo"
2833 atree = ElementTree(a)
2834
2835 btree = copy.deepcopy(atree)
2836 self.assertEqual("Foo", atree.getroot().text)
2837 self.assertEqual("Foo", btree.getroot().text)
2838 self.assertFalse(btree is atree)
2839 self.assertFalse(btree.getroot() is atree.getroot())
2840
2842 Element = self.etree.Element
2843
2844 a = Element('a')
2845 a.text = 'Foo'
2846
2847 b = copy.deepcopy(a)
2848 self.assertEquals('Foo', b.text)
2849
2850 b.text = 'Bar'
2851 self.assertEquals('Bar', b.text)
2852 self.assertEquals('Foo', a.text)
2853
2854 del a
2855 self.assertEquals('Bar', b.text)
2856
2858 Element = self.etree.Element
2859
2860 a = Element('a')
2861 a.tail = 'Foo'
2862
2863 b = copy.deepcopy(a)
2864 self.assertEquals('Foo', b.tail)
2865
2866 b.tail = 'Bar'
2867 self.assertEquals('Bar', b.tail)
2868 self.assertEquals('Foo', a.tail)
2869
2870 del a
2871 self.assertEquals('Bar', b.tail)
2872
2874 Element = self.etree.Element
2875 SubElement = self.etree.SubElement
2876
2877 root = Element('root')
2878 a = SubElement(root, 'a')
2879 a.text = 'FooText'
2880 a.tail = 'FooTail'
2881
2882 b = copy.deepcopy(a)
2883 self.assertEquals('FooText', b.text)
2884 self.assertEquals('FooTail', b.tail)
2885
2886 b.text = 'BarText'
2887 b.tail = 'BarTail'
2888 self.assertEquals('BarTail', b.tail)
2889 self.assertEquals('FooTail', a.tail)
2890 self.assertEquals('BarText', b.text)
2891 self.assertEquals('FooText', a.text)
2892
2893 del a
2894 self.assertEquals('BarTail', b.tail)
2895 self.assertEquals('BarText', b.text)
2896
2898 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns">
2899 <parent><node t:foo="bar" /></parent>
2900 </doc>''')
2901 self.assertEquals(
2902 root[0][0].get('{tns}foo'),
2903 copy.deepcopy(root[0])[0].get('{tns}foo') )
2904 self.assertEquals(
2905 root[0][0].get('{tns}foo'),
2906 copy.deepcopy(root[0][0]).get('{tns}foo') )
2907
2909 # previously caused a crash
2910 Element = self.etree.Element
2911 tostring = self.etree.tostring
2912
2913 a = Element('a')
2914 b = copy.deepcopy(a)
2915 a.append( Element('C') )
2916 b.append( Element('X') )
2917
2918 self.assertEquals('<a><C/></a>',
2919 tostring(a).replace(' ', ''))
2920 self.assertEquals('<a><X/></a>',
2921 tostring(b).replace(' ', ''))
2922
2924 Element = self.etree.Element
2925
2926 a = Element('a')
2927 a.text = 'Foo'
2928
2929 b = copy.copy(a)
2930 self.assertEquals('Foo', b.text)
2931
2932 b.text = 'Bar'
2933 self.assertEquals('Bar', b.text)
2934 self.assertEquals('Foo', a.text)
2935 # XXX ElementTree will share nodes, but lxml.etree won't..
2936
2938 Element = self.etree.Element
2939 ElementTree = self.etree.ElementTree
2940
2941 a = Element('a')
2942 a.text = 'Foo'
2943 atree = ElementTree(a)
2944
2945 btree = copy.copy(atree)
2946 self.assertFalse(btree is atree)
2947 self.assert_(btree.getroot() is atree.getroot())
2948 self.assertEquals('Foo', atree.getroot().text)
2949
2951 # deprecated as of ET 1.3/lxml 2.0
2952 etree = self.etree
2953 e = etree.Element('foo')
2954 self.assertEquals(False, bool(e))
2955 etree.SubElement(e, 'bar')
2956 self.assertEquals(True, bool(e))
2957 e = etree.Element('foo')
2958 e.text = 'hey'
2959 self.assertEquals(False, bool(e))
2960 e = etree.Element('foo')
2961 e.tail = 'bar'
2962 self.assertEquals(False, bool(e))
2963 e = etree.Element('foo')
2964 e.set('bar', 'Bar')
2965 self.assertEquals(False, bool(e))
2966
2968 etree = self.etree
2969
2970 a = etree.Element('a')
2971 b = etree.SubElement(a, 'b')
2972
2973 t = etree.ElementTree(a)
2974 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2975
2976 t1 = etree.ElementTree(a)
2977 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
2978 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2979
2980 t2 = etree.ElementTree(b)
2981 self.assertEquals(self._rootstring(t2), '<b/>')
2982 self.assertEquals(self._rootstring(t1), '<a><b/></a>')
2983 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2984
2986 etree = self.etree
2987 qname = etree.QName('myns', 'a')
2988 a1 = etree.Element(qname)
2989 a2 = etree.SubElement(a1, qname)
2990 self.assertEquals(a1.tag, "{myns}a")
2991 self.assertEquals(a2.tag, "{myns}a")
2992
2994 etree = self.etree
2995 qname1 = etree.QName('myns', 'a')
2996 qname2 = etree.QName('myns', 'a')
2997 self.assertEquals(qname1, "{myns}a")
2998 self.assertEquals("{myns}a", qname2)
2999 self.assertEquals(qname1, qname1)
3000 self.assertEquals(qname1, qname2)
3001
3003 etree = self.etree
3004 qname = etree.QName('myns', 'a')
3005
3006 a = etree.Element(qname)
3007 a.set(qname, "value")
3008
3009 self.assertEquals(a.get(qname), "value")
3010 self.assertEquals(a.get("{myns}a"), "value")
3011
3013 etree = self.etree
3014 qname = etree.QName('myns', 'a')
3015
3016 a = etree.Element(qname)
3017 a.attrib[qname] = "value"
3018
3019 self.assertEquals(a.attrib[qname], "value")
3020 self.assertEquals(a.attrib.get(qname), "value")
3021
3022 self.assertEquals(a.attrib["{myns}a"], "value")
3023 self.assertEquals(a.attrib.get("{myns}a"), "value")
3024
3026 etree = self.etree
3027 qname = etree.QName('http://myns', 'a')
3028 a = etree.Element(qname)
3029 a.set(qname, qname)
3030
3031 self.assertXML(
3032 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>',
3033 a)
3034
3036 etree = self.etree
3037 qname = etree.QName('http://myns', 'a')
3038 a = etree.Element('a')
3039 a.set('a', qname)
3040
3041 self.assertXML(
3042 '<a xmlns:ns0="http://myns" a="ns0:a"></a>',
3043 a)
3044
3046 etree = self.etree
3047 qname = etree.QName('http://myns', 'a')
3048 a = etree.Element(qname)
3049 a.attrib[qname] = qname
3050
3051 self.assertXML(
3052 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>',
3053 a)
3054
3056 etree = self.etree
3057 parser = etree.XMLParser()
3058 if hasattr(parser, "version"):
3059 # ElementTree 1.3+, cET
3060 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))
3061
3062 # feed parser interface
3063
3065 parser = self.etree.XMLParser()
3066
3067 parser.feed('<?xml version=')
3068 parser.feed('"1.0"?><ro')
3069 parser.feed('ot><')
3070 parser.feed('a test="works"/')
3071 parser.feed('></root')
3072 parser.feed('>')
3073
3074 root = parser.close()
3075
3076 self.assertEquals(root.tag, "root")
3077 self.assertEquals(root[0].tag, "a")
3078 self.assertEquals(root[0].get("test"), "works")
3079
3081 ParseError = self.etree.ParseError
3082 parser = self.etree.XMLParser()
3083 self.assertRaises(ParseError, parser.close)
3084
3086 ParseError = self.etree.ParseError
3087 parser = self.etree.XMLParser()
3088
3089 parser.feed('<?xml version=')
3090 parser.feed('"1.0"?><ro')
3091
3092 self.assertRaises(ParseError, parser.close)
3093
3095 ParseError = self.etree.ParseError
3096 parser = self.etree.XMLParser()
3097
3098 parser.feed('<?xml version=')
3099 parser.feed('"1.0"?><ro')
3100 try:
3101 parser.feed('<><><><><><><')
3102 except ParseError:
3103 # can raise, but not required before close()
3104 pass
3105
3106 self.assertRaises(ParseError, parser.close)
3107
3109 ParseError = self.etree.ParseError
3110 parser = self.etree.XMLParser()
3111 try:
3112 parser.close()
3113 except ParseError, e:
3114 self.assertNotEquals(None, e.code)
3115 self.assertNotEquals(0, e.code)
3116 self.assert_(isinstance(e.position, tuple))
3117 self.assert_(e.position >= (0, 0))
3118
3119 # parser target interface
3120
3122 assertEquals = self.assertEquals
3123 assertFalse = self.assertFalse
3124
3125 events = []
3126 class Target(object):
3127 def start(self, tag, attrib):
3128 events.append("start")
3129 assertFalse(attrib)
3130 assertEquals("TAG", tag)
3131 def end(self, tag):
3132 events.append("end")
3133 assertEquals("TAG", tag)
3134 def close(self):
3135 return "DONE"
3136
3137 parser = self.etree.XMLParser(target=Target())
3138
3139 parser.feed("<TAG/>")
3140 done = parser.close()
3141
3142 self.assertEquals("DONE", done)
3143 self.assertEquals(["start", "end"], events)
3144
3146 assertEquals = self.assertEquals
3147
3148 events = []
3149 class Target(object):
3150 def start(self, tag, attrib):
3151 events.append("start-" + tag)
3152 for name, value in attrib.iteritems():
3153 assertEquals(tag + name, value)
3154 def end(self, tag):
3155 events.append("end-" + tag)
3156 def close(self):
3157 return "DONE"
3158
3159 parser = self.etree.XMLParser(target=Target())
3160
3161 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3162 done = parser.close()
3163
3164 self.assertEquals("DONE", done)
3165 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3166 events)
3167
3169 events = []
3170 class Target(object):
3171 def start(self, tag, attrib):
3172 events.append("start-" + tag)
3173 def end(self, tag):
3174 events.append("end-" + tag)
3175 def data(self, data):
3176 events.append("data-" + data)
3177 def close(self):
3178 return "DONE"
3179
3180 parser = self.etree.XMLParser(target=Target())
3181
3182 parser.feed('<root>A<sub/>B</root>')
3183 done = parser.close()
3184
3185 self.assertEquals("DONE", done)
3186 self.assertEquals(["start-root", "data-A", "start-sub",
3187 "end-sub", "data-B", "end-root"],
3188 events)
3189
3195 def _flush_data(self):
3196 if self._data:
3197 events.append("data-" + ''.join(self._data))
3198 del self._data[:]
3199 def start(self, tag, attrib):
3200 self._flush_data()
3201 events.append("start-" + tag)
3202 def end(self, tag):
3203 self._flush_data()
3204 events.append("end-" + tag)
3205 def data(self, data):
3206 self._data.append(data)
3207 def close(self):
3208 self._flush_data()
3209 return "DONE"
3210
3211 parser = self.etree.XMLParser(target=Target())
3212
3213 dtd = '''
3214 <!DOCTYPE root [
3215 <!ELEMENT root (sub*)>
3216 <!ELEMENT sub (#PCDATA)>
3217 <!ENTITY ent "an entity">
3218 ]>
3219 '''
3220 parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
3221 done = parser.close()
3222
3223 self.assertEquals("DONE", done)
3224 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
3225 "data-this is an entity",
3226 "end-sub", "start-sub", "end-sub", "end-root"],
3227 events)
3228
3234 def _flush_data(self):
3235 if self._data:
3236 events.append("data-" + ''.join(self._data))
3237 del self._data[:]
3238 def start(self, tag, attrib):
3239 self._flush_data()
3240 events.append("start-" + tag)
3241 def end(self, tag):
3242 self._flush_data()
3243 events.append("end-" + tag)
3244 def data(self, data):
3245 self._data.append(data)
3246 def close(self):
3247 self._flush_data()
3248 return "DONE"
3249
3250 parser = self.etree.XMLParser(target=Target())
3251
3252 def feed():
3253 parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
3254 parser.close()
3255
3256 self.assertRaises(self.etree.ParseError, feed)
3257
3259 builder = self.etree.TreeBuilder()
3260 el = builder.start("root", {'a':'A', 'b':'B'})
3261 self.assertEquals("root", el.tag)
3262 self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3263 builder.data("ROOTTEXT")
3264 el = builder.start("child", {'x':'X', 'y':'Y'})
3265 self.assertEquals("child", el.tag)
3266 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3267 builder.data("CHILDTEXT")
3268 el = builder.end("child")
3269 self.assertEquals("child", el.tag)
3270 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3271 self.assertEquals("CHILDTEXT", el.text)
3272 self.assertEquals(None, el.tail)
3273 builder.data("CHILDTAIL")
3274 root = builder.end("root")
3275
3276 self.assertEquals("root", root.tag)
3277 self.assertEquals("ROOTTEXT", root.text)
3278 self.assertEquals("CHILDTEXT", root[0].text)
3279 self.assertEquals("CHILDTAIL", root[0].tail)
3280
3282 parser = self.etree.XMLParser(target=self.etree.TreeBuilder())
3283 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>')
3284 root = parser.close()
3285
3286 self.assertEquals("root", root.tag)
3287 self.assertEquals("ROOTTEXT", root.text)
3288 self.assertEquals("CHILDTEXT", root[0].text)
3289 self.assertEquals("CHILDTAIL", root[0].tail)
3290
3291 # helper methods
3292
3294 """Write out element for comparison.
3295 """
3296 data = self.etree.tostring(element, encoding=encoding)
3297 if encoding != 'us-ascii':
3298 data = unicode(data, encoding)
3299 return canonicalize(data)
3300
3302 """Write out element for comparison, using real file.
3303 """
3304 ElementTree = self.etree.ElementTree
3305 handle, filename = tempfile.mkstemp()
3306 try:
3307 f = open(filename, 'wb')
3308 tree = ElementTree(element=element)
3309 tree.write(f, encoding=encoding)
3310 f.close()
3311 f = open(filename, 'rb')
3312 data = f.read()
3313 f.close()
3314 finally:
3315 os.close(handle)
3316 os.remove(filename)
3317 if encoding != 'us-ascii':
3318 data = unicode(data, encoding)
3319 return canonicalize(data)
3320
3322 """Writes element out and checks whether it is expected.
3323
3324 Does this two ways; once using StringIO, once using a real file.
3325 """
3326 self.assertEquals(expected, self._writeElement(element, encoding))
3327 self.assertEquals(expected, self._writeElementFile(element, encoding))
3328
3330 "Checks if the result XML byte string specifies the encoding."
3331 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match
3332 self.assert_(has_encoding(result))
3333 result_encoding = has_encoding(result).group(1)
3334 self.assertEquals(result_encoding.upper(), encoding.upper())
3335
3338
3341
3343 self.assert_(hasattr(element, 'tag'))
3344 self.assert_(hasattr(element, 'attrib'))
3345 self.assert_(hasattr(element, 'text'))
3346 self.assert_(hasattr(element, 'tail'))
3347 self._check_string(element.tag)
3348 self._check_mapping(element.attrib)
3349 if element.text != None:
3350 self._check_string(element.text)
3351 if element.tail != None:
3352 self._check_string(element.tail)
3353
3355 len(string)
3356 for char in string:
3357 self.assertEquals(1, len(char))
3358 new_string = string + ""
3359 new_string = string + " "
3360 string[:0]
3361
3363 len(mapping)
3364 keys = mapping.keys()
3365 items = mapping.items()
3366 for key in keys:
3367 item = mapping[key]
3368 mapping["key"] = "value"
3369 self.assertEquals("value", mapping["key"])
3370
3371
3372 if etree:
3375
3376 if ElementTree:
3379
3380 if cElementTree:
3383
3385 suite = unittest.TestSuite()
3386 if etree:
3387 suite.addTests([unittest.makeSuite(ETreeTestCase)])
3388 if ElementTree:
3389 suite.addTests([unittest.makeSuite(ElementTreeTestCase)])
3390 if cElementTree:
3391 suite.addTests([unittest.makeSuite(CElementTreeTestCase)])
3392 return suite
3393
3394 if __name__ == '__main__':
3395 print 'to test use test.py %s' % __file__
3396
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0 on Sun Apr 13 20:12:23 2008 | http://epydoc.sourceforge.net |