Package lxml :: Package tests :: Module test_elementtree
[hide private]
[frames] | no frames]

Source Code for Module lxml.tests.test_elementtree

   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, shutil, tempfile, copy, operator 
  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,6): 
  20          cElementTree = None 
  21   
22 -class ETreeTestCaseBase(unittest.TestCase):
23 etree = None 24
25 - def setUp(self):
26 self._temp_dir = tempfile.mkdtemp()
27
28 - def tearDown(self):
29 shutil.rmtree(self._temp_dir)
30
31 - def getTestFilePath(self, name):
32 return os.path.join(self._temp_dir, name)
33
34 - def test_element(self):
35 for i in range(10): 36 e = self.etree.Element('foo')
37
38 - def test_tree(self):
39 Element = self.etree.Element 40 ElementTree = self.etree.ElementTree 41 42 element = Element('top') 43 tree = ElementTree(element) 44 self.buildNodes(element, 10, 3) 45 f = open(self.getTestFilePath('testdump.xml'), 'w') 46 tree.write(f, 'UTF-8') 47 f.close() 48 f = open(self.getTestFilePath('testdump.xml'), 'r') 49 tree = ElementTree(file=f) 50 f.close() 51 f = open(self.getTestFilePath('testdump2.xml'), 'w') 52 tree.write(f, 'UTF-8') 53 f.close() 54 f = open(self.getTestFilePath('testdump.xml'), 'r') 55 data1 = f.read() 56 f.close() 57 f = open(self.getTestFilePath('testdump2.xml'), 'r') 58 data2 = f.read() 59 f.close() 60 self.assertEquals(data1, data2)
61
62 - def buildNodes(self, element, children, depth):
63 Element = self.etree.Element 64 65 if depth == 0: 66 return 67 for i in range(children): 68 new_element = Element('element_%s_%s' % (depth, i)) 69 self.buildNodes(new_element, children, depth - 1) 70 element.append(new_element)
71
72 - def test_simple(self):
73 Element = self.etree.Element 74 75 root = Element('root') 76 root.append(Element('one')) 77 root.append(Element('two')) 78 root.append(Element('three')) 79 self.assertEquals(3, len(root)) 80 self.assertEquals('one', root[0].tag) 81 self.assertEquals('two', root[1].tag) 82 self.assertEquals('three', root[2].tag) 83 self.assertRaises(IndexError, operator.getitem, root, 3)
84
85 - def test_subelement(self):
86 Element = self.etree.Element 87 SubElement = self.etree.SubElement 88 89 root = Element('root') 90 SubElement(root, 'one') 91 SubElement(root, 'two') 92 SubElement(root, 'three') 93 self.assertEquals(3, len(root)) 94 self.assertEquals('one', root[0].tag) 95 self.assertEquals('two', root[1].tag) 96 self.assertEquals('three', root[2].tag)
97
98 - def test_element_contains(self):
99 Element = self.etree.Element 100 SubElement = self.etree.SubElement 101 102 root1 = Element('root') 103 SubElement(root1, 'one') 104 self.assert_(root1[0] in root1) 105 106 root2 = Element('root') 107 SubElement(root2, 'two') 108 SubElement(root2, 'three') 109 self.assert_(root2[0] in root2) 110 self.assert_(root2[1] in root2) 111 112 self.assertFalse(root1[0] in root2) 113 self.assertFalse(root2[0] in root1) 114 self.assertFalse(None in root2)
115
117 ElementTree = self.etree.ElementTree 118 119 f = StringIO('<doc>Test<one>One</one></doc>') 120 doc = ElementTree(file=f) 121 root = doc.getroot() 122 self.assertEquals(1, len(root)) 123 self.assertEquals('one', root[0].tag) 124 self.assertRaises(IndexError, operator.getitem, root, 1)
125
127 ElementTree = self.etree.ElementTree 128 129 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 130 doc = ElementTree(file=f) 131 root = doc.getroot() 132 self.assertEquals(3, len(root)) 133 self.assertEquals('one', root[0].tag) 134 self.assertEquals('two', root[1].tag) 135 self.assertEquals('three', root[2].tag)
136
138 ElementTree = self.etree.ElementTree 139 140 f = StringIO('<doc>Test</doc>') 141 doc = ElementTree(file=f) 142 root = doc.getroot() 143 self.assertEquals(0, len(root))
144
146 Element = self.etree.Element 147 SubElement = self.etree.SubElement 148 a = Element('a') 149 b = SubElement(a, 'b') 150 c = SubElement(a, 'c') 151 d = SubElement(a, 'd') 152 self.assertEquals(d, a[-1]) 153 self.assertEquals(c, a[-2]) 154 self.assertEquals(b, a[-3]) 155 self.assertRaises(IndexError, operator.getitem, a, -4) 156 a[-1] = e = Element('e') 157 self.assertEquals(e, a[-1]) 158 del a[-1] 159 self.assertEquals(2, len(a))
160
161 - def test_elementtree(self):
162 ElementTree = self.etree.ElementTree 163 164 f = StringIO('<doc><one>One</one><two>Two</two></doc>') 165 doc = ElementTree(file=f) 166 root = doc.getroot() 167 self.assertEquals(2, len(root)) 168 self.assertEquals('one', root[0].tag) 169 self.assertEquals('two', root[1].tag)
170
171 - def test_text(self):
172 ElementTree = self.etree.ElementTree 173 174 f = StringIO('<doc>This is a text</doc>') 175 doc = ElementTree(file=f) 176 root = doc.getroot() 177 self.assertEquals('This is a text', root.text)
178
179 - def test_text_empty(self):
180 ElementTree = self.etree.ElementTree 181 182 f = StringIO('<doc></doc>') 183 doc = ElementTree(file=f) 184 root = doc.getroot() 185 self.assertEquals(None, root.text)
186
187 - def test_text_other(self):
188 ElementTree = self.etree.ElementTree 189 190 f = StringIO('<doc><one>One</one></doc>') 191 doc = ElementTree(file=f) 192 root = doc.getroot() 193 self.assertEquals(None, root.text) 194 self.assertEquals('One', root[0].text)
195
196 - def test_text_escape_in(self):
197 ElementTree = self.etree.ElementTree 198 199 f = StringIO('<doc>This is &gt; than a text</doc>') 200 doc = ElementTree(file=f) 201 root = doc.getroot() 202 self.assertEquals('This is > than a text', root.text)
203
204 - def test_text_escape_out(self):
205 Element = self.etree.Element 206 207 a = Element("a") 208 a.text = "<>&" 209 self.assertXML('<a>&lt;&gt;&amp;</a>', 210 a)
211
212 - def test_text_escape_tostring(self):
213 tostring = self.etree.tostring 214 Element = self.etree.Element 215 216 a = Element("a") 217 a.text = "<>&" 218 self.assertEquals('<a>&lt;&gt;&amp;</a>', 219 tostring(a))
220
221 - def test_text_str_subclass(self):
222 Element = self.etree.Element 223 224 class strTest(str): 225 pass
226 227 a = Element("a") 228 a.text = strTest("text") 229 self.assertXML('<a>text</a>', 230 a)
231
232 - def test_tail(self):
233 ElementTree = self.etree.ElementTree 234 235 f = StringIO('<doc>This is <i>mixed</i> content.</doc>') 236 doc = ElementTree(file=f) 237 root = doc.getroot() 238 self.assertEquals(1, len(root)) 239 self.assertEquals('This is ', root.text) 240 self.assertEquals(None, root.tail) 241 self.assertEquals('mixed', root[0].text) 242 self.assertEquals(' content.', root[0].tail)
243
244 - def test_tail_str_subclass(self):
245 Element = self.etree.Element 246 SubElement = self.etree.SubElement 247 248 class strTest(str): 249 pass
250 251 a = Element("a") 252 SubElement(a, "t").tail = strTest("tail") 253 self.assertXML('<a><t></t>tail</a>', 254 a) 255
256 - def test_ElementTree(self):
257 Element = self.etree.Element 258 ElementTree = self.etree.ElementTree 259 260 el = Element('hoi') 261 doc = ElementTree(el) 262 root = doc.getroot() 263 self.assertEquals(None, root.text) 264 self.assertEquals('hoi', root.tag)
265
266 - def test_attributes(self):
267 ElementTree = self.etree.ElementTree 268 269 f = StringIO('<doc one="One" two="Two"/>') 270 doc = ElementTree(file=f) 271 root = doc.getroot() 272 self.assertEquals('One', root.attrib['one']) 273 self.assertEquals('Two', root.attrib['two']) 274 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')
275
276 - def test_attributes2(self):
277 ElementTree = self.etree.ElementTree 278 279 f = StringIO('<doc one="One" two="Two"/>') 280 doc = ElementTree(file=f) 281 root = doc.getroot() 282 self.assertEquals('One', root.attrib.get('one')) 283 self.assertEquals('Two', root.attrib.get('two')) 284 self.assertEquals(None, root.attrib.get('three')) 285 self.assertEquals('foo', root.attrib.get('three', 'foo'))
286
287 - def test_attributes3(self):
288 ElementTree = self.etree.ElementTree 289 290 f = StringIO('<doc one="One" two="Two"/>') 291 doc = ElementTree(file=f) 292 root = doc.getroot() 293 self.assertEquals('One', root.get('one')) 294 self.assertEquals('Two', root.get('two')) 295 self.assertEquals(None, root.get('three')) 296 self.assertEquals('foo', root.get('three', 'foo'))
297
298 - def test_attrib_clear(self):
299 XML = self.etree.XML 300 301 root = XML('<doc one="One" two="Two"/>') 302 self.assertEquals('One', root.get('one')) 303 self.assertEquals('Two', root.get('two')) 304 root.attrib.clear() 305 self.assertEquals(None, root.get('one')) 306 self.assertEquals(None, root.get('two'))
307
308 - def test_attrib_set_clear(self):
309 Element = self.etree.Element 310 311 root = Element("root", one="One") 312 root.set("two", "Two") 313 self.assertEquals('One', root.get('one')) 314 self.assertEquals('Two', root.get('two')) 315 root.attrib.clear() 316 self.assertEquals(None, root.get('one')) 317 self.assertEquals(None, root.get('two'))
318
319 - def test_attribute_update_dict(self):
320 XML = self.etree.XML 321 322 root = XML('<doc alpha="Alpha" beta="Beta"/>') 323 items = root.attrib.items() 324 items.sort() 325 self.assertEquals( 326 [('alpha', 'Alpha'), ('beta', 'Beta')], 327 items) 328 329 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 330 331 items = root.attrib.items() 332 items.sort() 333 self.assertEquals( 334 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 335 items)
336
337 - def test_attribute_update_sequence(self):
338 XML = self.etree.XML 339 340 root = XML('<doc alpha="Alpha" beta="Beta"/>') 341 items = root.attrib.items() 342 items.sort() 343 self.assertEquals( 344 [('alpha', 'Alpha'), ('beta', 'Beta')], 345 items) 346 347 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 348 349 items = root.attrib.items() 350 items.sort() 351 self.assertEquals( 352 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 353 items)
354
355 - def test_attribute_update_iter(self):
356 XML = self.etree.XML 357 358 root = XML('<doc alpha="Alpha" beta="Beta"/>') 359 items = root.attrib.items() 360 items.sort() 361 self.assertEquals( 362 [('alpha', 'Alpha'), ('beta', 'Beta')], 363 items) 364 365 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems()) 366 367 items = root.attrib.items() 368 items.sort() 369 self.assertEquals( 370 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 371 items)
372
373 - def test_attribute_keys(self):
374 XML = self.etree.XML 375 376 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 377 keys = root.attrib.keys() 378 keys.sort() 379 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
380
381 - def test_attribute_keys2(self):
382 XML = self.etree.XML 383 384 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 385 keys = root.keys() 386 keys.sort() 387 self.assertEquals(['alpha', 'beta', 'gamma'], keys)
388
389 - def test_attribute_items2(self):
390 XML = self.etree.XML 391 392 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 393 items = root.items() 394 items.sort() 395 self.assertEquals( 396 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 397 items)
398
399 - def test_attribute_keys_ns(self):
400 XML = self.etree.XML 401 402 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 403 keys = root.keys() 404 keys.sort() 405 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 406 keys)
407
408 - def test_attribute_values(self):
409 XML = self.etree.XML 410 411 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 412 values = root.attrib.values() 413 values.sort() 414 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
415
416 - def test_attribute_values_ns(self):
417 XML = self.etree.XML 418 419 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 420 values = root.attrib.values() 421 values.sort() 422 self.assertEquals( 423 ['Bar', 'Baz'], values)
424
425 - def test_attribute_items(self):
426 XML = self.etree.XML 427 428 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 429 items = root.attrib.items() 430 items.sort() 431 self.assertEquals([ 432 ('alpha', 'Alpha'), 433 ('beta', 'Beta'), 434 ('gamma', 'Gamma'), 435 ], 436 items)
437
438 - def test_attribute_items_ns(self):
439 XML = self.etree.XML 440 441 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 442 items = root.attrib.items() 443 items.sort() 444 self.assertEquals( 445 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 446 items)
447
448 - def test_attribute_str(self):
449 XML = self.etree.XML 450 451 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 452 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 453 454 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 455 try: 456 self.assertEquals(expected, str(root.attrib)) 457 except AssertionError: 458 self.assertEquals(alternative, str(root.attrib))
459
460 - def test_attribute_has_key(self):
461 XML = self.etree.XML 462 463 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 464 self.assertEquals( 465 True, root.attrib.has_key('bar')) 466 self.assertEquals( 467 False, root.attrib.has_key('baz')) 468 self.assertEquals( 469 False, root.attrib.has_key('hah')) 470 self.assertEquals( 471 True, 472 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
473
474 - def test_attribute_contains(self):
475 XML = self.etree.XML 476 477 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 478 self.assertEquals( 479 True, 'bar' in root.attrib) 480 self.assertEquals( 481 False, 'baz' in root.attrib) 482 self.assertEquals( 483 False, 'hah' in root.attrib) 484 self.assertEquals( 485 True, 486 '{http://ns.codespeak.net/test}baz' in root.attrib)
487
488 - def test_attribute_set(self):
489 Element = self.etree.Element 490 491 root = Element("root") 492 root.set("attr", "TEST") 493 self.assertEquals("TEST", root.get("attr"))
494
495 - def test_XML(self):
496 XML = self.etree.XML 497 498 root = XML('<doc>This is a text.</doc>') 499 self.assertEquals(0, len(root)) 500 self.assertEquals('This is a text.', root.text)
501
502 - def test_XMLID(self):
503 XMLID = self.etree.XMLID 504 XML = self.etree.XML 505 xml_text = ''' 506 <document> 507 <h1 id="chapter1">...</h1> 508 <p id="note1" class="note">...</p> 509 <p>Regular paragraph.</p> 510 <p xml:id="xmlid">XML:ID paragraph.</p> 511 <p id="warn1" class="warning">...</p> 512 </document> 513 ''' 514 515 root, dic = XMLID(xml_text) 516 root2 = XML(xml_text) 517 self.assertEquals(self._writeElement(root), 518 self._writeElement(root2)) 519 expected = { 520 "chapter1" : root[0], 521 "note1" : root[1], 522 "warn1" : root[4] 523 } 524 self.assertEquals(dic, expected)
525
526 - def test_fromstring(self):
527 fromstring = self.etree.fromstring 528 529 root = fromstring('<doc>This is a text.</doc>') 530 self.assertEquals(0, len(root)) 531 self.assertEquals('This is a text.', root.text)
532
533 - def test_iselement(self):
534 iselement = self.etree.iselement 535 Element = self.etree.Element 536 ElementTree = self.etree.ElementTree 537 XML = self.etree.XML 538 Comment = self.etree.Comment 539 ProcessingInstruction = self.etree.ProcessingInstruction 540 541 el = Element('hoi') 542 self.assert_(iselement(el)) 543 544 el2 = XML('<foo/>') 545 self.assert_(iselement(el2)) 546 547 tree = ElementTree(element=Element('dag')) 548 self.assert_(not iselement(tree)) 549 self.assert_(iselement(tree.getroot())) 550 551 c = Comment('test') 552 self.assert_(iselement(c)) 553 554 p = ProcessingInstruction("test", "some text") 555 self.assert_(iselement(p))
556
557 - def test_iteration(self):
558 XML = self.etree.XML 559 560 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 561 result = [] 562 for el in root: 563 result.append(el.tag) 564 self.assertEquals(['one', 'two', 'three'], result)
565
566 - def test_iteration_empty(self):
567 XML = self.etree.XML 568 569 root = XML('<doc></doc>') 570 result = [] 571 for el in root: 572 result.append(el.tag) 573 self.assertEquals([], result)
574
575 - def test_iteration_text_only(self):
576 XML = self.etree.XML 577 578 root = XML('<doc>Text</doc>') 579 result = [] 580 for el in root: 581 result.append(el.tag) 582 self.assertEquals([], result)
583
584 - def test_iteration_crash(self):
585 # this would cause a crash in the past 586 fromstring = self.etree.fromstring 587 root = etree.fromstring('<html><p></p>x</html>') 588 for elem in root: 589 elem.tail = ''
590
591 - def test_iteration_reversed(self):
592 XML = self.etree.XML 593 594 try: 595 reversed(()) 596 except NameError: 597 # before Python 2.4 598 return 599 600 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 601 result = [] 602 for el in reversed(root): 603 result.append(el.tag) 604 self.assertEquals(['three', 'two', 'one'], result)
605
606 - def test_iteration_subelement(self):
607 XML = self.etree.XML 608 609 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 610 result = [] 611 add = True 612 for el in root: 613 result.append(el.tag) 614 if add: 615 self.etree.SubElement(root, 'four') 616 add = False 617 self.assertEquals(['one', 'two', 'three', 'four'], result)
618
619 - def test_iteration_del_child(self):
620 XML = self.etree.XML 621 622 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 623 result = [] 624 for el in root: 625 result.append(el.tag) 626 del root[-1] 627 self.assertEquals(['one', 'two'], result)
628
629 - def test_iteration_double(self):
630 XML = self.etree.XML 631 632 root = XML('<doc><one/><two/></doc>') 633 result = [] 634 for el0 in root: 635 result.append(el0.tag) 636 for el1 in root: 637 result.append(el1.tag) 638 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
639
640 - def test_attribute_iterator(self):
641 XML = self.etree.XML 642 643 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />') 644 result = [] 645 for key in root.attrib: 646 result.append(key) 647 result.sort() 648 self.assertEquals(['alpha', 'beta', 'gamma'], result)
649
650 - def test_findall(self):
651 XML = self.etree.XML 652 root = XML('<a><b><c/></b><b/><c><b/></c></a>') 653 self.assertEquals(len(list(root.findall("c"))), 1) 654 self.assertEquals(len(list(root.findall(".//c"))), 2) 655 self.assertEquals(len(list(root.findall(".//b"))), 3) 656 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 657 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 658 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
659
660 - def test_findall_ns(self):
661 XML = self.etree.XML 662 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 663 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 664 self.assertEquals(len(list(root.findall(".//b"))), 3) 665 self.assertEquals(len(list(root.findall("b"))), 2)
666
667 - def test_element_with_attributes_keywords(self):
668 Element = self.etree.Element 669 670 el = Element('tag', foo='Foo', bar='Bar') 671 self.assertEquals('Foo', el.attrib['foo']) 672 self.assertEquals('Bar', el.attrib['bar'])
673
674 - def test_element_with_attributes(self):
675 Element = self.etree.Element 676 677 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 678 self.assertEquals('Foo', el.attrib['foo']) 679 self.assertEquals('Bar', el.attrib['bar'])
680
681 - def test_element_with_attributes_ns(self):
682 Element = self.etree.Element 683 684 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 685 self.assertEquals('Foo', el.attrib['{ns1}foo']) 686 self.assertEquals('Bar', el.attrib['{ns2}bar'])
687
688 - def test_subelement_with_attributes(self):
689 Element = self.etree.Element 690 SubElement = self.etree.SubElement 691 692 el = Element('tag') 693 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 694 self.assertEquals("Baz", el[0].attrib['baz']) 695 self.assertEquals('Foo', el[0].attrib['foo'])
696
697 - def test_subelement_with_attributes_ns(self):
698 Element = self.etree.Element 699 SubElement = self.etree.SubElement 700 701 el = Element('tag') 702 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 703 self.assertEquals('Foo', el[0].attrib['{ns1}foo']) 704 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])
705
706 - def test_write(self):
707 ElementTree = self.etree.ElementTree 708 XML = self.etree.XML 709 710 for i in range(10): 711 f = StringIO() 712 root = XML('<doc%s>This is a test.</doc%s>' % (i, i)) 713 tree = ElementTree(element=root) 714 tree.write(f) 715 data = f.getvalue() 716 self.assertEquals( 717 '<doc%s>This is a test.</doc%s>' % (i, i), 718 canonicalize(data))
719
720 - def test_write_method_html(self):
721 ElementTree = self.etree.ElementTree 722 Element = self.etree.Element 723 SubElement = self.etree.SubElement 724 725 html = Element('html') 726 body = SubElement(html, 'body') 727 p = SubElement(body, 'p') 728 p.text = "html" 729 SubElement(p, 'br').tail = "test" 730 731 tree = ElementTree(element=html) 732 f = StringIO() 733 tree.write(f, method="html") 734 data = f.getvalue() 735 736 self.assertEquals('<html><body><p>html<br>test</p></body></html>', 737 data)
738
739 - def test_write_method_text(self):
740 ElementTree = self.etree.ElementTree 741 Element = self.etree.Element 742 SubElement = self.etree.SubElement 743 744 a = Element('a') 745 a.text = "A" 746 a.tail = "tail" 747 b = SubElement(a, 'b') 748 b.text = "B" 749 b.tail = "TAIL" 750 c = SubElement(a, 'c') 751 c.text = "C" 752 753 tree = ElementTree(element=a) 754 f = StringIO() 755 tree.write(f, method="text") 756 data = f.getvalue() 757 758 self.assertEquals('ABTAILCtail', 759 data)
760
761 - def test_write_fail(self):
762 ElementTree = self.etree.ElementTree 763 XML = self.etree.XML 764 765 tree = ElementTree( XML('<doc>This is a test.</doc>') ) 766 self.assertRaises(IOError, tree.write, 767 "definitely////\\-\\nonexisting\\-\\////FILE")
768 769 # this could trigger a crash, apparently because the document 770 # reference was prematurely garbage collected
771 - def test_crash(self):
772 Element = self.etree.Element 773 774 element = Element('tag') 775 for i in range(10): 776 element.attrib['key'] = 'value' 777 value = element.attrib['key'] 778 self.assertEquals(value, 'value')
779 780 # from doctest; for some reason this caused crashes too
781 - def test_write_ElementTreeDoctest(self):
782 Element = self.etree.Element 783 ElementTree = self.etree.ElementTree 784 785 f = StringIO() 786 for i in range(10): 787 element = Element('tag%s' % i) 788 self._check_element(element) 789 tree = ElementTree(element) 790 tree.write(f) 791 self._check_element_tree(tree)
792
793 - def test_subelement_reference(self):
794 Element = self.etree.Element 795 SubElement = self.etree.SubElement 796 797 el = Element('foo') 798 el2 = SubElement(el, 'bar') 799 el3 = SubElement(el2, 'baz') 800 801 al = Element('foo2') 802 al2 = SubElement(al, 'bar2') 803 al3 = SubElement(al2, 'baz2') 804 805 # now move al2 into el 806 el.append(al2) 807 808 # now change al3 directly 809 al3.text = 'baz2-modified' 810 811 # it should have changed through this route too 812 self.assertEquals( 813 'baz2-modified', 814 el[1][0].text)
815
816 - def test_set_text(self):
817 Element = self.etree.Element 818 SubElement = self.etree.SubElement 819 820 a = Element('a') 821 b = SubElement(a, 'b') 822 a.text = 'hoi' 823 self.assertEquals( 824 'hoi', 825 a.text) 826 self.assertEquals( 827 'b', 828 a[0].tag)
829
830 - def test_set_text2(self):
831 Element = self.etree.Element 832 SubElement = self.etree.SubElement 833 834 a = Element('a') 835 a.text = 'hoi' 836 b = SubElement(a ,'b') 837 self.assertEquals( 838 'hoi', 839 a.text) 840 self.assertEquals( 841 'b', 842 a[0].tag)
843
844 - def test_set_text_none(self):
845 Element = self.etree.Element 846 847 a = Element('a') 848 849 a.text = 'foo' 850 a.text = None 851 852 self.assertEquals( 853 None, 854 a.text) 855 self.assertXML('<a></a>', a)
856
857 - def test_set_text_empty(self):
858 Element = self.etree.Element 859 860 a = Element('a') 861 self.assertEquals(None, a.text) 862 863 a.text = '' 864 self.assertEquals('', a.text) 865 self.assertXML('<a></a>', a)
866
867 - def test_tail1(self):
868 Element = self.etree.Element 869 SubElement = self.etree.SubElement 870 871 a = Element('a') 872 a.tail = 'dag' 873 self.assertEquals('dag', 874 a.tail) 875 b = SubElement(a, 'b') 876 b.tail = 'hoi' 877 self.assertEquals('hoi', 878 b.tail) 879 self.assertEquals('dag', 880 a.tail)
881
882 - def test_tail_append(self):
883 Element = self.etree.Element 884 885 a = Element('a') 886 b = Element('b') 887 b.tail = 'b_tail' 888 a.append(b) 889 self.assertEquals('b_tail', 890 b.tail)
891
892 - def test_tail_set_twice(self):
893 Element = self.etree.Element 894 SubElement = self.etree.SubElement 895 896 a = Element('a') 897 b = SubElement(a, 'b') 898 b.tail = 'foo' 899 b.tail = 'bar' 900 self.assertEquals('bar', 901 b.tail) 902 self.assertXML('<a><b></b>bar</a>', a)
903
904 - def test_tail_set_none(self):
905 Element = self.etree.Element 906 a = Element('a') 907 a.tail = 'foo' 908 a.tail = None 909 self.assertEquals( 910 None, 911 a.tail) 912 self.assertXML('<a></a>', a)
913
914 - def test_comment(self):
915 Element = self.etree.Element 916 SubElement = self.etree.SubElement 917 Comment = self.etree.Comment 918 919 a = Element('a') 920 a.append(Comment('foo')) 921 self.assertEquals(a[0].tag, Comment) 922 self.assertEquals(a[0].text, 'foo')
923
924 - def test_comment_text(self):
925 Element = self.etree.Element 926 SubElement = self.etree.SubElement 927 Comment = self.etree.Comment 928 929 a = Element('a') 930 a.append(Comment('foo')) 931 self.assertEquals(a[0].text, 'foo') 932 933 a[0].text = "TEST" 934 self.assertEquals(a[0].text, 'TEST')
935
936 - def test_comment_whitespace(self):
937 Element = self.etree.Element 938 SubElement = self.etree.SubElement 939 Comment = self.etree.Comment 940 941 a = Element('a') 942 a.append(Comment(' foo ')) 943 self.assertEquals(a[0].text, ' foo ')
944
945 - def test_comment_nonsense(self):
946 Comment = self.etree.Comment 947 c = Comment('foo') 948 self.assertEquals({}, c.attrib) 949 self.assertEquals([], c.keys()) 950 self.assertEquals([], c.items()) 951 self.assertEquals(None, c.get('hoi')) 952 self.assertEquals(0, len(c)) 953 # should not iterate 954 for i in c: 955 pass
956
957 - def test_pi(self):
958 # lxml.etree separates target and text 959 Element = self.etree.Element 960 SubElement = self.etree.SubElement 961 ProcessingInstruction = self.etree.ProcessingInstruction 962 963 a = Element('a') 964 a.append(ProcessingInstruction('foo', 'some more text')) 965 self.assertEquals(a[0].tag, ProcessingInstruction) 966 self.assertXML("<a><?foo some more text?></a>", 967 a)
968
969 - def test_processinginstruction(self):
970 # lxml.etree separates target and text 971 Element = self.etree.Element 972 SubElement = self.etree.SubElement 973 ProcessingInstruction = self.etree.PI 974 975 a = Element('a') 976 a.append(ProcessingInstruction('foo', 'some more text')) 977 self.assertEquals(a[0].tag, ProcessingInstruction) 978 self.assertXML("<a><?foo some more text?></a>", 979 a)
980
981 - def test_pi_nonsense(self):
982 ProcessingInstruction = self.etree.ProcessingInstruction 983 pi = ProcessingInstruction('foo') 984 self.assertEquals({}, pi.attrib) 985 self.assertEquals([], pi.keys()) 986 self.assertEquals([], pi.items()) 987 self.assertEquals(None, pi.get('hoi')) 988 self.assertEquals(0, len(pi)) 989 # should not iterate 990 for i in pi: 991 pass
992
993 - def test_setitem(self):
994 Element = self.etree.Element 995 SubElement = self.etree.SubElement 996 997 a = Element('a') 998 b = SubElement(a, 'b') 999 c = Element('c') 1000 a[0] = c 1001 self.assertEquals( 1002 c, 1003 a[0]) 1004 self.assertXML('<a><c></c></a>', 1005 a) 1006 self.assertXML('<b></b>', 1007 b)
1008
1009 - def test_setitem2(self):
1010 Element = self.etree.Element 1011 SubElement = self.etree.SubElement 1012 1013 a = Element('a') 1014 for i in range(5): 1015 b = SubElement(a, 'b%s' % i) 1016 c = SubElement(b, 'c') 1017 for i in range(5): 1018 d = Element('d') 1019 e = SubElement(d, 'e') 1020 a[i] = d 1021 self.assertXML( 1022 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>', 1023 a) 1024 self.assertXML('<c></c>', 1025 c)
1026
1027 - def test_setitem_replace(self):
1028 Element = self.etree.Element 1029 SubElement = self.etree.SubElement 1030 1031 a = Element('a') 1032 SubElement(a, 'b') 1033 d = Element('d') 1034 a[0] = d 1035 self.assertXML('<a><d></d></a>', a)
1036
1037 - def test_setitem_indexerror(self):
1038 Element = self.etree.Element 1039 SubElement = self.etree.SubElement 1040 1041 a = Element('a') 1042 b = SubElement(a, 'b') 1043 1044 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))
1045
1046 - def test_setitem_tail(self):
1047 Element = self.etree.Element 1048 SubElement = self.etree.SubElement 1049 1050 a = Element('a') 1051 b = SubElement(a, 'b') 1052 b.tail = 'B2' 1053 c = Element('c') 1054 c.tail = 'C2' 1055 1056 a[0] = c 1057 self.assertXML( 1058 '<a><c></c>C2</a>', 1059 a)
1060
1061 - def test_tag_write(self):
1062 Element = self.etree.Element 1063 SubElement = self.etree.SubElement 1064 1065 a = Element('a') 1066 b = SubElement(a, 'b') 1067 1068 a.tag = 'c' 1069 1070 self.assertEquals( 1071 'c', 1072 a.tag) 1073 1074 self.assertXML( 1075 '<c><b></b></c>', 1076 a)
1077
1078 - def test_tag_reset_ns(self):
1079 Element = self.etree.Element 1080 SubElement = self.etree.SubElement 1081 tostring = self.etree.tostring 1082 1083 a = Element('{a}a') 1084 b1 = SubElement(a, '{a}b') 1085 b2 = SubElement(a, '{b}b') 1086 1087 self.assertEquals('{a}b', b1.tag) 1088 1089 b1.tag = 'c' 1090 1091 # can't use C14N here! 1092 self.assertEquals('c', b1.tag) 1093 self.assertEquals('<c', tostring(b1)[:2]) 1094 self.assert_('<c' in tostring(a))
1095
1096 - def test_tag_reset_root_ns(self):
1097 Element = self.etree.Element 1098 SubElement = self.etree.SubElement 1099 tostring = self.etree.tostring 1100 1101 a = Element('{a}a') 1102 b1 = SubElement(a, '{a}b') 1103 b2 = SubElement(a, '{b}b') 1104 1105 a.tag = 'c' 1106 1107 self.assertEquals( 1108 'c', 1109 a.tag) 1110 1111 # can't use C14N here! 1112 self.assertEquals('c', a.tag) 1113 self.assertEquals('<c', tostring(a)[:2])
1114
1115 - def test_tag_str_subclass(self):
1116 Element = self.etree.Element 1117 1118 class strTest(str): 1119 pass
1120 1121 a = Element("a") 1122 a.tag = strTest("TAG") 1123 self.assertXML('<TAG></TAG>', 1124 a) 1125
1126 - def test_delitem(self):
1127 Element = self.etree.Element 1128 SubElement = self.etree.SubElement 1129 1130 a = Element('a') 1131 b = SubElement(a, 'b') 1132 c = SubElement(a, 'c') 1133 d = SubElement(a, 'd') 1134 1135 del a[1] 1136 self.assertXML( 1137 '<a><b></b><d></d></a>', 1138 a) 1139 1140 del a[0] 1141 self.assertXML( 1142 '<a><d></d></a>', 1143 a) 1144 1145 del a[0] 1146 self.assertXML( 1147 '<a></a>', 1148 a) 1149 # move deleted element into other tree afterwards 1150 other = Element('other') 1151 other.append(c) 1152 self.assertXML( 1153 '<other><c></c></other>', 1154 other)
1155
1156 - def test_del_insert(self):
1157 Element = self.etree.Element 1158 SubElement = self.etree.SubElement 1159 1160 a = Element('a') 1161 b = SubElement(a, 'b') 1162 bs = SubElement(b, 'bs') 1163 c = SubElement(a, 'c') 1164 cs = SubElement(c, 'cs') 1165 1166 el = a[0] 1167 self.assertXML( 1168 '<a><b><bs></bs></b><c><cs></cs></c></a>', 1169 a) 1170 self.assertXML('<b><bs></bs></b>', b) 1171 self.assertXML('<c><cs></cs></c>', c) 1172 1173 del a[0] 1174 self.assertXML( 1175 '<a><c><cs></cs></c></a>', 1176 a) 1177 self.assertXML('<b><bs></bs></b>', b) 1178 self.assertXML('<c><cs></cs></c>', c) 1179 1180 a.insert(0, el) 1181 self.assertXML( 1182 '<a><b><bs></bs></b><c><cs></cs></c></a>', 1183 a) 1184 self.assertXML('<b><bs></bs></b>', b) 1185 self.assertXML('<c><cs></cs></c>', c)
1186
1187 - def test_del_setitem(self):
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 del a[0] 1199 a[0] = el 1200 self.assertXML( 1201 '<a><b><bs></bs></b></a>', 1202 a) 1203 self.assertXML('<b><bs></bs></b>', b) 1204 self.assertXML('<c><cs></cs></c>', c)
1205
1206 - def test_del_setslice(self):
1207 Element = self.etree.Element 1208 SubElement = self.etree.SubElement 1209 1210 a = Element('a') 1211 b = SubElement(a, 'b') 1212 bs = SubElement(b, 'bs') 1213 c = SubElement(a, 'c') 1214 cs = SubElement(c, 'cs') 1215 1216 el = a[0] 1217 del a[0] 1218 a[0:0] = [el] 1219 self.assertXML( 1220 '<a><b><bs></bs></b><c><cs></cs></c></a>', 1221 a) 1222 self.assertXML('<b><bs></bs></b>', b) 1223 self.assertXML('<c><cs></cs></c>', c)
1224
1225 - def test_delslice_tail(self):
1226 XML = self.etree.XML 1227 a = XML('<a><b></b>B2<c></c>C2</a>') 1228 b, c = a 1229 1230 del a[:] 1231 1232 self.assertEquals("B2", b.tail) 1233 self.assertEquals("C2", c.tail)
1234
1235 - def test_replace_slice_tail(self):
1236 XML = self.etree.XML 1237 a = XML('<a><b></b>B2<c></c>C2</a>') 1238 b, c = a 1239 1240 a[:] = [] 1241 1242 self.assertEquals("B2", b.tail) 1243 self.assertEquals("C2", c.tail)
1244
1245 - def test_delitem_tail(self):
1246 ElementTree = self.etree.ElementTree 1247 f = StringIO('<a><b></b>B2<c></c>C2</a>') 1248 doc = ElementTree(file=f) 1249 a = doc.getroot() 1250 del a[0] 1251 self.assertXML( 1252 '<a><c></c>C2</a>', 1253 a)
1254
1255 - def test_clear(self):
1256 Element = self.etree.Element 1257 1258 a = Element('a') 1259 a.text = 'foo' 1260 a.tail = 'bar' 1261 a.set('hoi', 'dag') 1262 a.clear() 1263 self.assertEquals(None, a.text) 1264 self.assertEquals(None, a.tail) 1265 self.assertEquals(None, a.get('hoi')) 1266 self.assertEquals('a', a.tag)
1267
1268 - def test_clear_sub(self):
1269 Element = self.etree.Element 1270 SubElement = self.etree.SubElement 1271 1272 a = Element('a') 1273 a.text = 'foo' 1274 a.tail = 'bar' 1275 a.set('hoi', 'dag') 1276 b = SubElement(a, 'b') 1277 c = SubElement(b, 'c') 1278 a.clear() 1279 self.assertEquals(None, a.text) 1280 self.assertEquals(None, a.tail) 1281 self.assertEquals(None, a.get('hoi')) 1282 self.assertEquals('a', a.tag) 1283 self.assertEquals(0, len(a)) 1284 self.assertXML('<a></a>', 1285 a) 1286 self.assertXML('<b><c></c></b>', 1287 b)
1288
1289 - def test_clear_tail(self):
1290 ElementTree = self.etree.ElementTree 1291 f = StringIO('<a><b></b>B2<c></c>C2</a>') 1292 doc = ElementTree(file=f) 1293 a = doc.getroot() 1294 a.clear() 1295 self.assertXML( 1296 '<a></a>', 1297 a)
1298
1299 - def test_insert(self):
1300 Element = self.etree.Element 1301 SubElement = self.etree.SubElement 1302 1303 a = Element('a') 1304 b = SubElement(a, 'b') 1305 c = SubElement(a, 'c') 1306 d = Element('d') 1307 a.insert(0, d) 1308 1309 self.assertEquals( 1310 d, 1311 a[0]) 1312 1313 self.assertXML( 1314 '<a><d></d><b></b><c></c></a>', 1315 a) 1316 1317 e = Element('e') 1318 a.insert(2, e) 1319 self.assertEquals( 1320 e, 1321 a[2]) 1322 self.assertXML( 1323 '<a><d></d><b></b><e></e><c></c></a>', 1324 a)
1325
1326 - def test_insert_beyond_index(self):
1327 Element = self.etree.Element 1328 SubElement = self.etree.SubElement 1329 1330 a = Element('a') 1331 b = SubElement(a, 'b') 1332 c = Element('c') 1333 1334 a.insert(2, c) 1335 self.assertEquals( 1336 c, 1337 a[1]) 1338 self.assertXML( 1339 '<a><b></b><c></c></a>', 1340 a)
1341
1342 - def test_insert_negative(self):
1343 Element = self.etree.Element 1344 SubElement = self.etree.SubElement 1345 1346 a = Element('a') 1347 b = SubElement(a, 'b') 1348 c = SubElement(a, 'c') 1349 1350 d = Element('d') 1351 a.insert(-1, d) 1352 self.assertEquals( 1353 d, 1354 a[-2]) 1355 self.assertXML( 1356 '<a><b></b><d></d><c></c></a>', 1357 a)
1358
1359 - def test_insert_tail(self):
1360 Element = self.etree.Element 1361 SubElement = self.etree.SubElement 1362 1363 a = Element('a') 1364 b = SubElement(a, 'b') 1365 1366 c = Element('c') 1367 c.tail = 'C2' 1368 1369 a.insert(0, c) 1370 self.assertXML( 1371 '<a><c></c>C2<b></b></a>', 1372 a)
1373
1374 - def test_remove(self):
1375 Element = self.etree.Element 1376 SubElement = self.etree.SubElement 1377 1378 a = Element('a') 1379 b = SubElement(a, 'b') 1380 c = SubElement(a, 'c') 1381 1382 a.remove(b) 1383 self.assertEquals( 1384 c, 1385 a[0]) 1386 self.assertXML( 1387 '<a><c></c></a>', 1388 a)
1389
1390 - def test_remove_ns(self):
1391 Element = self.etree.Element 1392 SubElement = self.etree.SubElement 1393 1394 a = Element('{http://test}a') 1395 b = SubElement(a, '{http://test}b') 1396 c = SubElement(a, '{http://test}c') 1397 1398 a.remove(b) 1399 self.assertXML( 1400 '<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>', 1401 a) 1402 self.assertXML( 1403 '<ns0:b xmlns:ns0="http://test"></ns0:b>', 1404 b)
1405
1406 - def test_remove_nonexisting(self):
1407 Element = self.etree.Element 1408 SubElement = self.etree.SubElement 1409 1410 a = Element('a') 1411 b = SubElement(a, 'b') 1412 c = SubElement(a, 'c') 1413 d = Element('d') 1414 self.assertRaises( 1415 ValueError, a.remove, d)
1416
1417 - def test_remove_tail(self):
1418 Element = self.etree.Element 1419 SubElement = self.etree.SubElement 1420 1421 a = Element('a') 1422 b = SubElement(a, 'b') 1423 b.tail = 'b2' 1424 a.remove(b) 1425 self.assertXML( 1426 '<a></a>', 1427 a) 1428 self.assertEquals('b2', b.tail)
1429
1430 - def _test_getchildren(self):
1431 Element = self.etree.Element 1432 SubElement = self.etree.SubElement 1433 1434 a = Element('a') 1435 b = SubElement(a, 'b') 1436 c = SubElement(a, 'c') 1437 d = SubElement(b, 'd') 1438 e = SubElement(c, 'e') 1439 self.assertXML( 1440 '<a><b><d></d></b><c><e></e></c></a>', 1441 a) 1442 self.assertEquals( 1443 [b, c], 1444 a.getchildren()) 1445 self.assertEquals( 1446 [d], 1447 b.getchildren()) 1448 self.assertEquals( 1449 [], 1450 d.getchildren())
1451
1452 - def test_makeelement(self):
1453 Element = self.etree.Element 1454 1455 a = Element('a') 1456 b = a.makeelement('c', {'hoi':'dag'}) 1457 self.assertXML( 1458 '<c hoi="dag"></c>', 1459 b)
1460
1461 - def test_getiterator(self):
1462 Element = self.etree.Element 1463 SubElement = self.etree.SubElement 1464 1465 a = Element('a') 1466 b = SubElement(a, 'b') 1467 c = SubElement(a, 'c') 1468 d = SubElement(b, 'd') 1469 e = SubElement(c, 'e') 1470 1471 self.assertEquals( 1472 [a, b, d, c, e], 1473 list(a.getiterator())) 1474 self.assertEquals( 1475 [d], 1476 list(d.getiterator()))
1477
1478 - def test_getiterator_empty(self):
1479 Element = self.etree.Element 1480 SubElement = self.etree.SubElement 1481 1482 a = Element('a') 1483 b = SubElement(a, 'b') 1484 c = SubElement(a, 'c') 1485 d = SubElement(b, 'd') 1486 e = SubElement(c, 'e') 1487 1488 self.assertEquals( 1489 [], 1490 list(a.getiterator('none'))) 1491 self.assertEquals( 1492 [], 1493 list(e.getiterator('none'))) 1494 self.assertEquals( 1495 [e], 1496 list(e.getiterator()))
1497
1498 - def test_getiterator_filter(self):
1499 Element = self.etree.Element 1500 SubElement = self.etree.SubElement 1501 1502 a = Element('a') 1503 b = SubElement(a, 'b') 1504 c = SubElement(a, 'c') 1505 d = SubElement(b, 'd') 1506 e = SubElement(c, 'e') 1507 1508 self.assertEquals( 1509 [a], 1510 list(a.getiterator('a'))) 1511 a2 = SubElement(e, 'a') 1512 self.assertEquals( 1513 [a, a2], 1514 list(a.getiterator('a'))) 1515 self.assertEquals( 1516 [a2], 1517 list(c.getiterator('a')))
1518
1519 - def test_getiterator_filter_all(self):
1520 Element = self.etree.Element 1521 SubElement = self.etree.SubElement 1522 1523 a = Element('a') 1524 b = SubElement(a, 'b') 1525 c = SubElement(a, 'c') 1526 d = SubElement(b, 'd') 1527 e = SubElement(c, 'e') 1528 1529 self.assertEquals( 1530 [a, b, d, c, e], 1531 list(a.getiterator('*')))
1532
1533 - def test_getiterator_filter_comment(self):
1534 Element = self.etree.Element 1535 Comment = self.etree.Comment 1536 SubElement = self.etree.SubElement 1537 1538 a = Element('a') 1539 b = SubElement(a, 'b') 1540 comment_b = Comment("TEST-b") 1541 b.append(comment_b) 1542 1543 self.assertEquals( 1544 [comment_b], 1545 list(a.getiterator(Comment))) 1546 1547 comment_a = Comment("TEST-a") 1548 a.append(comment_a) 1549 1550 self.assertEquals( 1551 [comment_b, comment_a], 1552 list(a.getiterator(Comment))) 1553 1554 self.assertEquals( 1555 [comment_b], 1556 list(b.getiterator(Comment)))
1557
1558 - def test_getiterator_filter_pi(self):
1559 Element = self.etree.Element 1560 PI = self.etree.ProcessingInstruction 1561 SubElement = self.etree.SubElement 1562 1563 a = Element('a') 1564 b = SubElement(a, 'b') 1565 pi_b = PI("TEST-b") 1566 b.append(pi_b) 1567 1568 self.assertEquals( 1569 [pi_b], 1570 list(a.getiterator(PI))) 1571 1572 pi_a = PI("TEST-a") 1573 a.append(pi_a) 1574 1575 self.assertEquals( 1576 [pi_b, pi_a], 1577 list(a.getiterator(PI))) 1578 1579 self.assertEquals( 1580 [pi_b], 1581 list(b.getiterator(PI)))
1582
1583 - def test_getiterator_with_text(self):
1584 Element = self.etree.Element 1585 SubElement = self.etree.SubElement 1586 1587 a = Element('a') 1588 a.text = 'a' 1589 b = SubElement(a, 'b') 1590 b.text = 'b' 1591 b.tail = 'b1' 1592 c = SubElement(a, 'c') 1593 c.text = 'c' 1594 c.tail = 'c1' 1595 d = SubElement(b, 'd') 1596 c.text = 'd' 1597 c.tail = 'd1' 1598 e = SubElement(c, 'e') 1599 e.text = 'e' 1600 e.tail = 'e1' 1601 1602 self.assertEquals( 1603 [a, b, d, c, e], 1604 list(a.getiterator()))
1605 #self.assertEquals( 1606 # [d], 1607 # list(d.getiterator())) 1608
1609 - def test_getiterator_filter_with_text(self):
1610 Element = self.etree.Element 1611 SubElement = self.etree.SubElement 1612 1613 a = Element('a') 1614 a.text = 'a' 1615 b = SubElement(a, 'b') 1616 b.text = 'b' 1617 b.tail = 'b1' 1618 c = SubElement(a, 'c') 1619 c.text = 'c' 1620 c.tail = 'c1' 1621 d = SubElement(b, 'd') 1622 c.text = 'd' 1623 c.tail = 'd1' 1624 e = SubElement(c, 'e') 1625 e.text = 'e' 1626 e.tail = 'e1' 1627 1628 self.assertEquals( 1629 [a], 1630 list(a.getiterator('a'))) 1631 a2 = SubElement(e, 'a') 1632 self.assertEquals( 1633 [a, a2], 1634 list(a.getiterator('a'))) 1635 self.assertEquals( 1636 [a2], 1637 list(e.getiterator('a')))
1638
1639 - def test_attribute_manipulation(self):
1640 Element = self.etree.Element 1641 1642 a = Element('a') 1643 a.attrib['foo'] = 'Foo' 1644 a.attrib['bar'] = 'Bar' 1645 self.assertEquals('Foo', a.attrib['foo']) 1646 del a.attrib['foo'] 1647 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
1648
1649 - def test_getslice(self):
1650 Element = self.etree.Element 1651 SubElement = self.etree.SubElement 1652 1653 a = Element('a') 1654 b = SubElement(a, 'b') 1655 c = SubElement(a, 'c') 1656 d = SubElement(a, 'd') 1657 1658 self.assertEquals( 1659 [b, c], 1660 a[0:2]) 1661 self.assertEquals( 1662 [b, c, d], 1663 a[:]) 1664 self.assertEquals( 1665 [b, c, d], 1666 a[:10]) 1667 self.assertEquals( 1668 [b], 1669 a[0:1]) 1670 self.assertEquals( 1671 [], 1672 a[10:12])
1673
1674 - def test_getslice_negative(self):
1675 Element = self.etree.Element 1676 SubElement = self.etree.SubElement 1677 1678 a = Element('a') 1679 b = SubElement(a, 'b') 1680 c = SubElement(a, 'c') 1681 d = SubElement(a, 'd') 1682 1683 self.assertEquals( 1684 [d], 1685 a[-1:]) 1686 self.assertEquals( 1687 [c, d], 1688 a[-2:]) 1689 self.assertEquals( 1690 [c], 1691 a[-2:-1]) 1692 self.assertEquals( 1693 [b, c], 1694 a[-3:-1]) 1695 self.assertEquals( 1696 [b, c], 1697 a[-3:2])
1698
1699 - def test_getslice_text(self):
1700 ElementTree = self.etree.ElementTree 1701 1702 f = StringIO('<a><b>B</b>B1<c>C</c>C1</a>') 1703 doc = ElementTree(file=f) 1704 a = doc.getroot() 1705 b = a[0] 1706 c = a[1] 1707 self.assertEquals( 1708 [b, c], 1709 a[:]) 1710 self.assertEquals( 1711 [b], 1712 a[0:1]) 1713 self.assertEquals( 1714 [c], 1715 a[1:])
1716
1717 - def test_comment_getitem_getslice(self):
1718 Element = self.etree.Element 1719 Comment = self.etree.Comment 1720 SubElement = self.etree.SubElement 1721 1722 a = Element('a') 1723 b = SubElement(a, 'b') 1724 foo = Comment('foo') 1725 a.append(foo) 1726 c = SubElement(a, 'c') 1727 self.assertEquals( 1728 [b, foo, c], 1729 a[:]) 1730 self.assertEquals( 1731 foo, 1732 a[1]) 1733 a[1] = new = Element('new') 1734 self.assertEquals( 1735 new, 1736 a[1]) 1737 self.assertXML( 1738 '<a><b></b><new></new><c></c></a>', 1739 a)
1740
1741 - def test_delslice(self):
1742 Element = self.etree.Element 1743 SubElement = self.etree.SubElement 1744 1745 a = Element('a') 1746 b = SubElement(a, 'b') 1747 c = SubElement(a, 'c') 1748 d = SubElement(a, 'd') 1749 e = SubElement(a, 'e') 1750 1751 del a[1:3] 1752 self.assertEquals( 1753 [b, e], 1754 list(a))
1755
1756 - def test_delslice_negative1(self):
1757 Element = self.etree.Element 1758 SubElement = self.etree.SubElement 1759 1760 a = Element('a') 1761 b = SubElement(a, 'b') 1762 c = SubElement(a, 'c') 1763 d = SubElement(a, 'd') 1764 e = SubElement(a, 'e') 1765 1766 del a[1:-1] 1767 self.assertEquals( 1768 [b, e], 1769 list(a))
1770
1771 - def test_delslice_negative2(self):
1772 Element = self.etree.Element 1773 SubElement = self.etree.SubElement 1774 1775 a = Element('a') 1776 b = SubElement(a, 'b') 1777 c = SubElement(a, 'c') 1778 d = SubElement(a, 'd') 1779 e = SubElement(a, 'e') 1780 1781 del a[-3:-1] 1782 self.assertEquals( 1783 [b, e], 1784 list(a))
1785
1786 - def test_delslice_tail(self):
1787 ElementTree = self.etree.ElementTree 1788 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1789 doc = ElementTree(file=f) 1790 a = doc.getroot() 1791 del a[1:3] 1792 self.assertXML( 1793 '<a><b></b>B2<e></e>E2</a>', 1794 a)
1795
1796 - def test_delslice_memory(self):
1797 # this could trigger a crash 1798 Element = self.etree.Element 1799 SubElement = self.etree.SubElement 1800 a = Element('a') 1801 b = SubElement(a, 'b') 1802 c = SubElement(b, 'c') 1803 del b # no more reference to b 1804 del a[:] 1805 self.assertEquals('c', c.tag)
1806
1807 - def test_setslice(self):
1808 Element = self.etree.Element 1809 SubElement = self.etree.SubElement 1810 1811 a = Element('a') 1812 b = SubElement(a, 'b') 1813 c = SubElement(a, 'c') 1814 d = SubElement(a, 'd') 1815 1816 e = Element('e') 1817 f = Element('f') 1818 g = Element('g') 1819 1820 s = [e, f, g] 1821 a[1:2] = s 1822 self.assertEquals( 1823 [b, e, f, g, d], 1824 list(a))
1825
1826 - def test_setslice_tail(self):
1827 ElementTree = self.etree.ElementTree 1828 Element = self.etree.Element 1829 f = StringIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1830 doc = ElementTree(file=f) 1831 a = doc.getroot() 1832 x = Element('x') 1833 y = Element('y') 1834 z = Element('z') 1835 x.tail = 'X2' 1836 y.tail = 'Y2' 1837 z.tail = 'Z2' 1838 a[1:3] = [x, y, z] 1839 self.assertXML( 1840 '<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>', 1841 a)
1842
1843 - def test_setslice_negative(self):
1844 Element = self.etree.Element 1845 SubElement = self.etree.SubElement 1846 1847 a = Element('a') 1848 b = SubElement(a, 'b') 1849 c = SubElement(a, 'c') 1850 d = SubElement(a, 'd') 1851 1852 x = Element('x') 1853 y = Element('y') 1854 1855 a[1:-1] = [x, y] 1856 self.assertEquals( 1857 [b, x, y, d], 1858 list(a))
1859
1860 - def test_setslice_end(self):
1861 Element = self.etree.Element 1862 SubElement = self.etree.SubElement 1863 1864 a = Element('a') 1865 b = SubElement(a, 'b') 1866 c = SubElement(a, 'c') 1867 d = SubElement(a, 'd') 1868 1869 e = Element('e') 1870 f = Element('f') 1871 g = Element('g') 1872 1873 s = [e, f, g] 1874 a[3:] = s 1875 self.assertEquals( 1876 [b, c, d, e, f, g], 1877 list(a))
1878
1879 - def test_setslice_empty(self):
1880 Element = self.etree.Element 1881 1882 a = Element('a') 1883 1884 b = Element('b') 1885 c = Element('c') 1886 1887 a[:] = [b, c] 1888 self.assertEquals( 1889 [b, c], 1890 list(a))
1891
1892 - def test_tail_elementtree_root(self):
1893 Element = self.etree.Element 1894 ElementTree = self.etree.ElementTree 1895 1896 a = Element('a') 1897 a.tail = 'A2' 1898 t = ElementTree(element=a) 1899 self.assertEquals('A2', 1900 a.tail)
1901
1902 - def test_elementtree_getiterator(self):
1903 Element = self.etree.Element 1904 SubElement = self.etree.SubElement 1905 ElementTree = self.etree.ElementTree 1906 1907 a = Element('a') 1908 b = SubElement(a, 'b') 1909 c = SubElement(a, 'c') 1910 d = SubElement(b, 'd') 1911 e = SubElement(c, 'e') 1912 t = ElementTree(element=a) 1913 1914 self.assertEquals( 1915 [a, b, d, c, e], 1916 list(t.getiterator()))
1917
1918 - def test_elementtree_getiterator_filter(self):
1919 Element = self.etree.Element 1920 SubElement = self.etree.SubElement 1921 ElementTree = self.etree.ElementTree 1922 a = Element('a') 1923 b = SubElement(a, 'b') 1924 c = SubElement(a, 'c') 1925 d = SubElement(b, 'd') 1926 e = SubElement(c, 'e') 1927 t = ElementTree(element=a) 1928 1929 self.assertEquals( 1930 [a], 1931 list(t.getiterator('a'))) 1932 a2 = SubElement(e, 'a') 1933 self.assertEquals( 1934 [a, a2], 1935 list(t.getiterator('a')))
1936
1937 - def test_ns_access(self):
1938 ElementTree = self.etree.ElementTree 1939 ns = 'http://xml.infrae.com/1' 1940 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 1941 t = ElementTree(file=f) 1942 a = t.getroot() 1943 self.assertEquals('{%s}a' % ns, 1944 a.tag) 1945 self.assertEquals('{%s}b' % ns, 1946 a[0].tag)
1947
1948 - def test_ns_access2(self):
1949 ElementTree = self.etree.ElementTree 1950 ns = 'http://xml.infrae.com/1' 1951 ns2 = 'http://xml.infrae.com/2' 1952 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 1953 t = ElementTree(file=f) 1954 a = t.getroot() 1955 self.assertEquals('{%s}a' % ns, 1956 a.tag) 1957 self.assertEquals('{%s}b' % ns, 1958 a[0].tag) 1959 self.assertEquals('{%s}b' % ns2, 1960 a[1].tag)
1961
1962 - def test_ns_setting(self):
1963 Element = self.etree.Element 1964 SubElement = self.etree.SubElement 1965 ns = 'http://xml.infrae.com/1' 1966 ns2 = 'http://xml.infrae.com/2' 1967 a = Element('{%s}a' % ns) 1968 b = SubElement(a, '{%s}b' % ns2) 1969 c = SubElement(a, '{%s}c' % ns) 1970 self.assertEquals('{%s}a' % ns, 1971 a.tag) 1972 self.assertEquals('{%s}b' % ns2, 1973 b.tag) 1974 self.assertEquals('{%s}c' % ns, 1975 c.tag) 1976 self.assertEquals('{%s}a' % ns, 1977 a.tag) 1978 self.assertEquals('{%s}b' % ns2, 1979 b.tag) 1980 self.assertEquals('{%s}c' % ns, 1981 c.tag)
1982
1983 - def test_ns_tag_parse(self):
1984 Element = self.etree.Element 1985 SubElement = self.etree.SubElement 1986 ElementTree = self.etree.ElementTree 1987 1988 ns = 'http://xml.infrae.com/1' 1989 ns2 = 'http://xml.infrae.com/2' 1990 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2)) 1991 t = ElementTree(file=f) 1992 1993 a = t.getroot() 1994 self.assertEquals('{%s}a' % ns, 1995 a.tag) 1996 self.assertEquals('{%s}b' % ns2, 1997 a[0].tag) 1998 self.assertEquals('{%s}b' % ns, 1999 a[1].tag)
2000
2001 - def test_ns_attr(self):
2002 Element = self.etree.Element 2003 ns = 'http://xml.infrae.com/1' 2004 ns2 = 'http://xml.infrae.com/2' 2005 a = Element('a') 2006 a.set('{%s}foo' % ns, 'Foo') 2007 a.set('{%s}bar' % ns2, 'Bar') 2008 self.assertEquals( 2009 'Foo', 2010 a.get('{%s}foo' % ns)) 2011 self.assertEquals( 2012 'Bar', 2013 a.get('{%s}bar' % ns2)) 2014 try: 2015 self.assertXML( 2016 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2), 2017 a) 2018 except AssertionError: 2019 self.assertXML( 2020 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns), 2021 a)
2022
2023 - def test_ns_move(self):
2024 Element = self.etree.Element 2025 ElementTree = self.etree.ElementTree 2026 2027 one = self.etree.parse( 2028 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2029 baz = one.getroot()[0][0] 2030 2031 two = ElementTree(Element('root')) 2032 two.getroot().append(baz) 2033 # removing the originating document could cause a crash/error before 2034 # as namespace is not moved along with it 2035 del one 2036 self.assertEquals('{http://a.b.c}baz', baz.tag)
2037
2038 - def test_ns_decl_tostring(self):
2039 tostring = self.etree.tostring 2040 root = self.etree.XML( 2041 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>') 2042 baz = root[0][0] 2043 2044 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2045 tostring(baz)) 2046 self.assertEquals(["http://a.b.c"], nsdecl)
2047
2048 - def test_ns_decl_tostring_default(self):
2049 tostring = self.etree.tostring 2050 root = self.etree.XML( 2051 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>') 2052 baz = root[0][0] 2053 2054 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2055 tostring(baz)) 2056 self.assertEquals(["http://a.b.c"], nsdecl)
2057
2058 - def test_ns_decl_tostring_root(self):
2059 tostring = self.etree.tostring 2060 root = self.etree.XML( 2061 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>') 2062 baz = root[0][0] 2063 2064 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2065 tostring(baz)) 2066 2067 self.assertEquals(["http://a.b.c"], nsdecl)
2068
2069 - def test_ns_decl_tostring_element(self):
2070 Element = self.etree.Element 2071 SubElement = self.etree.SubElement 2072 2073 root = Element("foo") 2074 bar = SubElement(root, "{http://a.b.c}bar") 2075 baz = SubElement(bar, "{http://a.b.c}baz") 2076 2077 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2078 self.etree.tostring(baz)) 2079 2080 self.assertEquals(["http://a.b.c"], nsdecl)
2081
2082 - def test_attribute_xmlns_move(self):
2083 Element = self.etree.Element 2084 2085 root = Element('element') 2086 2087 subelement = Element('subelement', 2088 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2089 self.assertEquals(1, len(subelement.attrib)) 2090 self.assertEquals( 2091 "foo", 2092 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2093 2094 root.append(subelement) 2095 self.assertEquals(1, len(subelement.attrib)) 2096 self.assertEquals( 2097 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(), 2098 subelement.attrib.items()) 2099 self.assertEquals( 2100 "foo", 2101 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2102
2103 - def test_tostring(self):
2104 tostring = self.etree.tostring 2105 Element = self.etree.Element 2106 SubElement = self.etree.SubElement 2107 2108 a = Element('a') 2109 b = SubElement(a, 'b') 2110 c = SubElement(a, 'c') 2111 2112 self.assertEquals('<a><b></b><c></c></a>', 2113 canonicalize(tostring(a)))
2114
2115 - def test_tostring_element(self):
2116 tostring = self.etree.tostring 2117 Element = self.etree.Element 2118 SubElement = self.etree.SubElement 2119 2120 a = Element('a') 2121 b = SubElement(a, 'b') 2122 c = SubElement(a, 'c') 2123 d = SubElement(c, 'd') 2124 self.assertEquals('<b></b>', 2125 canonicalize(tostring(b))) 2126 self.assertEquals('<c><d></d></c>', 2127 canonicalize(tostring(c)))
2128
2129 - def test_tostring_element_tail(self):
2130 tostring = self.etree.tostring 2131 Element = self.etree.Element 2132 SubElement = self.etree.SubElement 2133 2134 a = Element('a') 2135 b = SubElement(a, 'b') 2136 c = SubElement(a, 'c') 2137 d = SubElement(c, 'd') 2138 b.tail = 'Foo' 2139 2140 self.assert_(tostring(b) == '<b/>Foo' or 2141 tostring(b) == '<b />Foo')
2142
2143 - def test_tostring_method_html(self):
2144 tostring = self.etree.tostring 2145 Element = self.etree.Element 2146 SubElement = self.etree.SubElement 2147 2148 html = Element('html') 2149 body = SubElement(html, 'body') 2150 p = SubElement(body, 'p') 2151 p.text = "html" 2152 SubElement(p, 'br').tail = "test" 2153 2154 self.assertEquals('<html><body><p>html<br>test</p></body></html>', 2155 tostring(html, method="html"))
2156
2157 - def test_tostring_method_text(self):
2158 tostring = self.etree.tostring 2159 Element = self.etree.Element 2160 SubElement = self.etree.SubElement 2161 2162 a = Element('a') 2163 a.text = "A" 2164 a.tail = "tail" 2165 b = SubElement(a, 'b') 2166 b.text = "B" 2167 b.tail = "TAIL" 2168 c = SubElement(a, 'c') 2169 c.text = "C" 2170 2171 self.assertEquals('ABTAILCtail', 2172 tostring(a, method="text"))
2173
2174 - def test_iterparse(self):
2175 iterparse = self.etree.iterparse 2176 f = StringIO('<a><b></b><c/></a>') 2177 2178 iterator = iterparse(f) 2179 self.assertEquals(None, 2180 iterator.root) 2181 events = list(iterator) 2182 root = iterator.root 2183 self.assertEquals( 2184 [('end', root[0]), ('end', root[1]), ('end', root)], 2185 events)
2186
2187 - def test_iterparse_file(self):
2188 iterparse = self.etree.iterparse 2189 iterator = iterparse(fileInTestDir("test.xml")) 2190 self.assertEquals(None, 2191 iterator.root) 2192 events = list(iterator) 2193 root = iterator.root 2194 self.assertEquals( 2195 [('end', root[0]), ('end', root)], 2196 events)
2197
2198 - def test_iterparse_start(self):
2199 iterparse = self.etree.iterparse 2200 f = StringIO('<a><b></b><c/></a>') 2201 2202 iterator = iterparse(f, events=('start',)) 2203 events = list(iterator) 2204 root = iterator.root 2205 self.assertEquals( 2206 [('start', root), ('start', root[0]), ('start', root[1])], 2207 events)
2208
2209 - def test_iterparse_start_end(self):
2210 iterparse = self.etree.iterparse 2211 f = StringIO('<a><b></b><c/></a>') 2212 2213 iterator = iterparse(f, events=('start','end')) 2214 events = list(iterator) 2215 root = iterator.root 2216 self.assertEquals( 2217 [('start', root), ('start', root[0]), ('end', root[0]), 2218 ('start', root[1]), ('end', root[1]), ('end', root)], 2219 events)
2220
2221 - def test_iterparse_clear(self):
2222 iterparse = self.etree.iterparse 2223 f = StringIO('<a><b></b><c/></a>') 2224 2225 iterator = iterparse(f) 2226 for event, elem in iterator: 2227 elem.clear() 2228 2229 root = iterator.root 2230 self.assertEquals(0, 2231 len(root))
2232
2233 - def test_iterparse_large(self):
2234 iterparse = self.etree.iterparse 2235 CHILD_COUNT = 12345 2236 f = StringIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT)) 2237 2238 i = 0 2239 for key in iterparse(f): 2240 event, element = key 2241 i += 1 2242 self.assertEquals(i, CHILD_COUNT + 1)
2243
2244 - def test_iterparse_attrib_ns(self):
2245 iterparse = self.etree.iterparse 2246 f = StringIO('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>') 2247 2248 attr_name = '{testns}bla' 2249 events = [] 2250 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2251 for event, elem in iterator: 2252 events.append(event) 2253 if event == 'start': 2254 if elem.tag != '{ns1}a': 2255 elem.set(attr_name, 'value') 2256 2257 self.assertEquals( 2258 ['start-ns', 'start', 'start', 'start-ns', 'start', 2259 'end', 'end-ns', 'end', 'end', 'end-ns'], 2260 events) 2261 2262 root = iterator.root 2263 self.assertEquals( 2264 None, 2265 root.get(attr_name)) 2266 self.assertEquals( 2267 'value', 2268 root[0].get(attr_name))
2269
2270 - def test_iterparse_getiterator(self):
2271 iterparse = self.etree.iterparse 2272 f = StringIO('<a><b><d/></b><c/></a>') 2273 2274 counts = [] 2275 for event, elem in iterparse(f): 2276 counts.append(len(list(elem.getiterator()))) 2277 self.assertEquals( 2278 [1,2,1,4], 2279 counts)
2280
2281 - def test_parse_file(self):
2282 parse = self.etree.parse 2283 # from file 2284 tree = parse(fileInTestDir('test.xml')) 2285 self.assertXML( 2286 '<a><b></b></a>', 2287 tree.getroot())
2288
2289 - def test_parse_file_nonexistent(self):
2290 parse = self.etree.parse 2291 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))
2292
2293 - def test_parse_file_object(self):
2294 parse = self.etree.parse 2295 # from file object 2296 f = open(fileInTestDir('test.xml'), 'r') 2297 tree = parse(f) 2298 f.close() 2299 self.assertXML( 2300 '<a><b></b></a>', 2301 tree.getroot())
2302
2303 - def test_parse_stringio(self):
2304 parse = self.etree.parse 2305 # from StringIO 2306 f = StringIO('<a><b></b></a>') 2307 tree = parse(f) 2308 f.close() 2309 self.assertXML( 2310 '<a><b></b></a>', 2311 tree.getroot() 2312 )
2313
2314 - def test_parse_with_encoding(self):
2315 # this can fail in libxml2 <= 2.6.22 2316 parse = self.etree.parse 2317 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2318 self.assertXML('<html></html>', 2319 tree.getroot())
2320
2321 - def test_encoding(self):
2322 Element = self.etree.Element 2323 2324 a = Element('a') 2325 a.text = u'Søk på nettet' 2326 self.assertXML( 2327 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2328 a, 'utf-8')
2329
2330 - def test_encoding_exact(self):
2331 ElementTree = self.etree.ElementTree 2332 Element = self.etree.Element 2333 2334 a = Element('a') 2335 a.text = u'Søk på nettet' 2336 2337 f = StringIO() 2338 tree = ElementTree(element=a) 2339 tree.write(f, 'utf-8') 2340 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2341 f.getvalue())
2342
2343 - def test_parse_file_encoding(self):
2344 parse = self.etree.parse 2345 # from file 2346 tree = parse(fileInTestDir('test-string.xml')) 2347 self.assertXML( 2348 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2349 tree.getroot(), 'UTF-8')
2350
2351 - def test_parse_file_object_encoding(self):
2352 parse = self.etree.parse 2353 # from file object 2354 f = open(fileInTestDir('test-string.xml'), 'r') 2355 tree = parse(f) 2356 f.close() 2357 self.assertXML( 2358 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2359 tree.getroot(), 'UTF-8')
2360
2361 - def test_encoding_8bit_latin1(self):
2362 ElementTree = self.etree.ElementTree 2363 Element = self.etree.Element 2364 2365 a = Element('a') 2366 a.text = u'Søk på nettet' 2367 2368 f = StringIO() 2369 tree = ElementTree(element=a) 2370 tree.write(f, 'iso-8859-1') 2371 result = f.getvalue() 2372 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2373 self.assertEncodingDeclaration(result,'iso-8859-1') 2374 result = result.split('?>', 1)[-1] 2375 if result[0] == '\n': 2376 result = result[1:] 2377 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2378 result)
2379 2380 # raise error on wrong (left-over?) encoding declaration in unicode strings
2381 - def _test_wrong_unicode_encoding(self):
2382 XML = self.etree.XML 2383 test_utf = u'<?xml version=\'1.0\' encoding=\'iso-8859-1\'?><a>Søk på nettet</a>' 2384 self.assertRaises(SyntaxError, XML, test_utf)
2385
2386 - def test_encoding_write_default_encoding(self):
2387 ElementTree = self.etree.ElementTree 2388 Element = self.etree.Element 2389 2390 a = Element('a') 2391 a.text = u'Søk på nettet' 2392 2393 f = StringIO() 2394 tree = ElementTree(element=a) 2395 tree.write(f) 2396 data = f.getvalue() 2397 self.assertEquals( 2398 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2399 data)
2400
2401 - def test_encoding_tostring(self):
2402 Element = self.etree.Element 2403 tostring = self.etree.tostring 2404 2405 a = Element('a') 2406 a.text = u'Søk på nettet' 2407 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2408 tostring(a, 'utf-8'))
2409
2410 - def test_encoding_tostring_unknown(self):
2411 Element = self.etree.Element 2412 tostring = self.etree.tostring 2413 2414 a = Element('a') 2415 a.text = u'Søk på nettet' 2416 self.assertRaises(LookupError, tostring, a, 'Invalid Encoding')
2417
2418 - def test_encoding_tostring_sub(self):
2419 Element = self.etree.Element 2420 SubElement = self.etree.SubElement 2421 tostring = self.etree.tostring 2422 2423 a = Element('a') 2424 b = SubElement(a, 'b') 2425 b.text = u'Søk på nettet' 2426 self.assertEquals(u'<b>Søk på nettet</b>'.encode('UTF-8'), 2427 tostring(b, 'utf-8'))
2428
2429 - def test_encoding_tostring_sub_tail(self):
2430 Element = self.etree.Element 2431 SubElement = self.etree.SubElement 2432 tostring = self.etree.tostring 2433 2434 a = Element('a') 2435 b = SubElement(a, 'b') 2436 b.text = u'Søk på nettet' 2437 b.tail = u'Søk' 2438 self.assertEquals(u'<b>Søk på nettet</b>Søk'.encode('UTF-8'), 2439 tostring(b, 'utf-8'))
2440
2441 - def test_encoding_tostring_default_encoding(self):
2442 Element = self.etree.Element 2443 SubElement = self.etree.SubElement 2444 tostring = self.etree.tostring 2445 2446 a = Element('a') 2447 a.text = u'Søk på nettet' 2448 2449 expected = '<a>S&#248;k p&#229; nettet</a>' 2450 self.assertEquals( 2451 expected, 2452 tostring(a))
2453
2454 - def test_encoding_sub_tostring_default_encoding(self):
2455 Element = self.etree.Element 2456 SubElement = self.etree.SubElement 2457 tostring = self.etree.tostring 2458 2459 a = Element('a') 2460 b = SubElement(a, 'b') 2461 b.text = u'Søk på nettet' 2462 2463 expected = '<b>S&#248;k p&#229; nettet</b>' 2464 self.assertEquals( 2465 expected, 2466 tostring(b))
2467
2468 - def test_encoding_8bit_xml(self):
2469 utext = u'Søk på nettet' 2470 uxml = u'<p>%s</p>' % utext 2471 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2472 isoxml = prologue + uxml.encode('iso-8859-1') 2473 tree = self.etree.XML(isoxml) 2474 self.assertEquals(utext, tree.text)
2475
2476 - def test_encoding_8bit_parse_stringio(self):
2477 utext = u'Søk på nettet' 2478 uxml = u'<p>%s</p>' % utext 2479 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2480 isoxml = prologue + uxml.encode('iso-8859-1') 2481 el = self.etree.parse(StringIO(isoxml)).getroot() 2482 self.assertEquals(utext, el.text)
2483
2484 - def test_deepcopy_elementtree(self):
2485 Element = self.etree.Element 2486 ElementTree = self.etree.ElementTree 2487 2488 a = Element('a') 2489 a.text = "Foo" 2490 atree = ElementTree(a) 2491 2492 btree = copy.deepcopy(atree) 2493 self.assertEqual("Foo", atree.getroot().text) 2494 self.assertEqual("Foo", btree.getroot().text) 2495 self.assertFalse(btree is atree) 2496 self.assertFalse(btree.getroot() is atree.getroot())
2497
2498 - def test_deepcopy(self):
2499 Element = self.etree.Element 2500 2501 a = Element('a') 2502 a.text = 'Foo' 2503 2504 b = copy.deepcopy(a) 2505 self.assertEquals('Foo', b.text) 2506 2507 b.text = 'Bar' 2508 self.assertEquals('Bar', b.text) 2509 self.assertEquals('Foo', a.text) 2510 2511 del a 2512 self.assertEquals('Bar', b.text)
2513
2514 - def test_deepcopy_tail(self):
2515 Element = self.etree.Element 2516 2517 a = Element('a') 2518 a.tail = 'Foo' 2519 2520 b = copy.deepcopy(a) 2521 self.assertEquals('Foo', b.tail) 2522 2523 b.tail = 'Bar' 2524 self.assertEquals('Bar', b.tail) 2525 self.assertEquals('Foo', a.tail) 2526 2527 del a 2528 self.assertEquals('Bar', b.tail)
2529
2530 - def test_deepcopy_subelement(self):
2531 Element = self.etree.Element 2532 SubElement = self.etree.SubElement 2533 2534 root = Element('root') 2535 a = SubElement(root, 'a') 2536 a.text = 'FooText' 2537 a.tail = 'FooTail' 2538 2539 b = copy.deepcopy(a) 2540 self.assertEquals('FooText', b.text) 2541 self.assertEquals('FooTail', b.tail) 2542 2543 b.text = 'BarText' 2544 b.tail = 'BarTail' 2545 self.assertEquals('BarTail', b.tail) 2546 self.assertEquals('FooTail', a.tail) 2547 self.assertEquals('BarText', b.text) 2548 self.assertEquals('FooText', a.text) 2549 2550 del a 2551 self.assertEquals('BarTail', b.tail) 2552 self.assertEquals('BarText', b.text)
2553
2554 - def test_deepcopy_namespaces(self):
2555 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 2556 <parent><node t:foo="bar" /></parent> 2557 </doc>''') 2558 self.assertEquals( 2559 root[0][0].get('{tns}foo'), 2560 copy.deepcopy(root[0])[0].get('{tns}foo') ) 2561 self.assertEquals( 2562 root[0][0].get('{tns}foo'), 2563 copy.deepcopy(root[0][0]).get('{tns}foo') )
2564
2565 - def test_deepcopy_append(self):
2566 # previously caused a crash 2567 Element = self.etree.Element 2568 tostring = self.etree.tostring 2569 2570 a = Element('a') 2571 b = copy.deepcopy(a) 2572 a.append( Element('C') ) 2573 b.append( Element('X') ) 2574 2575 self.assertEquals('<a><C/></a>', 2576 tostring(a).replace(' ', '')) 2577 self.assertEquals('<a><X/></a>', 2578 tostring(b).replace(' ', ''))
2579
2580 - def test_shallowcopy(self):
2581 Element = self.etree.Element 2582 2583 a = Element('a') 2584 a.text = 'Foo' 2585 2586 b = copy.copy(a) 2587 self.assertEquals('Foo', b.text) 2588 2589 b.text = 'Bar' 2590 self.assertEquals('Bar', b.text) 2591 self.assertEquals('Foo', a.text)
2592 # XXX ElementTree will share nodes, but lxml.etree won't.. 2593
2594 - def test_shallowcopy_elementtree(self):
2595 Element = self.etree.Element 2596 ElementTree = self.etree.ElementTree 2597 2598 a = Element('a') 2599 a.text = 'Foo' 2600 atree = ElementTree(a) 2601 2602 btree = copy.copy(atree) 2603 self.assertFalse(btree is atree) 2604 self.assert_(btree.getroot() is atree.getroot()) 2605 self.assertEquals('Foo', atree.getroot().text)
2606
2607 - def _test_element_boolean(self):
2608 # deprecated as of ET 1.3/lxml 2.0 2609 etree = self.etree 2610 e = etree.Element('foo') 2611 self.assertEquals(False, bool(e)) 2612 etree.SubElement(e, 'bar') 2613 self.assertEquals(True, bool(e)) 2614 e = etree.Element('foo') 2615 e.text = 'hey' 2616 self.assertEquals(False, bool(e)) 2617 e = etree.Element('foo') 2618 e.tail = 'bar' 2619 self.assertEquals(False, bool(e)) 2620 e = etree.Element('foo') 2621 e.set('bar', 'Bar') 2622 self.assertEquals(False, bool(e))
2623
2624 - def test_multiple_elementrees(self):
2625 etree = self.etree 2626 2627 a = etree.Element('a') 2628 b = etree.SubElement(a, 'b') 2629 2630 t = etree.ElementTree(a) 2631 self.assertEquals(self._rootstring(t), '<a><b/></a>') 2632 2633 t1 = etree.ElementTree(a) 2634 self.assertEquals(self._rootstring(t1), '<a><b/></a>') 2635 self.assertEquals(self._rootstring(t), '<a><b/></a>') 2636 2637 t2 = etree.ElementTree(b) 2638 self.assertEquals(self._rootstring(t2), '<b/>') 2639 self.assertEquals(self._rootstring(t1), '<a><b/></a>') 2640 self.assertEquals(self._rootstring(t), '<a><b/></a>')
2641
2642 - def test_qname(self):
2643 etree = self.etree 2644 qname = etree.QName('myns', 'a') 2645 a1 = etree.Element(qname) 2646 a2 = etree.SubElement(a1, qname) 2647 self.assertEquals(a1.tag, "{myns}a") 2648 self.assertEquals(a2.tag, "{myns}a")
2649
2650 - def test_qname_cmp(self):
2651 etree = self.etree 2652 qname1 = etree.QName('myns', 'a') 2653 qname2 = etree.QName('myns', 'a') 2654 self.assertEquals(qname1, "{myns}a") 2655 self.assertEquals("{myns}a", qname2) 2656 self.assertEquals(qname1, qname1) 2657 self.assertEquals(qname1, qname2)
2658
2659 - def test_qname_attribute_getset(self):
2660 etree = self.etree 2661 qname = etree.QName('myns', 'a') 2662 2663 a = etree.Element(qname) 2664 a.set(qname, "value") 2665 2666 self.assertEquals(a.get(qname), "value") 2667 self.assertEquals(a.get("{myns}a"), "value")
2668
2669 - def test_qname_attrib(self):
2670 etree = self.etree 2671 qname = etree.QName('myns', 'a') 2672 2673 a = etree.Element(qname) 2674 a.attrib[qname] = "value" 2675 2676 self.assertEquals(a.attrib[qname], "value") 2677 self.assertEquals(a.attrib.get(qname), "value") 2678 2679 self.assertEquals(a.attrib["{myns}a"], "value") 2680 self.assertEquals(a.attrib.get("{myns}a"), "value")
2681
2682 - def test_qname_attribute_resolve(self):
2683 etree = self.etree 2684 qname = etree.QName('http://myns', 'a') 2685 a = etree.Element(qname) 2686 a.set(qname, qname) 2687 2688 self.assertXML( 2689 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2690 a)
2691
2692 - def test_qname_attribute_resolve_new(self):
2693 etree = self.etree 2694 qname = etree.QName('http://myns', 'a') 2695 a = etree.Element('a') 2696 a.set('a', qname) 2697 2698 self.assertXML( 2699 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 2700 a)
2701
2702 - def test_qname_attrib_resolve(self):
2703 etree = self.etree 2704 qname = etree.QName('http://myns', 'a') 2705 a = etree.Element(qname) 2706 a.attrib[qname] = qname 2707 2708 self.assertXML( 2709 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2710 a)
2711
2712 - def test_parser_version(self):
2713 etree = self.etree 2714 parser = etree.XMLParser() 2715 if hasattr(parser, "version"): 2716 # ElementTree 1.3+, cET 2717 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))
2718 2719 # feed parser interface 2720
2721 - def test_feed_parser(self):
2722 parser = self.etree.XMLParser() 2723 2724 parser.feed('<?xml version=') 2725 parser.feed('"1.0"?><ro') 2726 parser.feed('ot><') 2727 parser.feed('a test="works"/') 2728 parser.feed('></root') 2729 parser.feed('>') 2730 2731 root = parser.close() 2732 2733 self.assertEquals(root.tag, "root") 2734 self.assertEquals(root[0].tag, "a") 2735 self.assertEquals(root[0].get("test"), "works")
2736
2737 - def test_feed_parser_error_close_empty(self):
2738 parser = self.etree.XMLParser() 2739 self.assertRaises(Exception, parser.close)
2740
2741 - def test_feed_parser_error_close_incomplete(self):
2742 parser = self.etree.XMLParser() 2743 2744 parser.feed('<?xml version=') 2745 parser.feed('"1.0"?><ro') 2746 2747 self.assertRaises(Exception, parser.close)
2748
2749 - def test_feed_parser_error_broken(self):
2750 parser = self.etree.XMLParser() 2751 2752 parser.feed('<?xml version=') 2753 parser.feed('"1.0"?><ro') 2754 try: 2755 parser.feed('<ro<ro<ro<ro') 2756 except: 2757 # can raise, but not required before close() 2758 pass 2759 2760 self.assertRaises(Exception, parser.close)
2761 2762 # parser target interface 2763
2764 - def test_parser_target_tag(self):
2765 assertEquals = self.assertEquals 2766 assertFalse = self.assertFalse 2767 2768 events = [] 2769 class Target(object): 2770 def start(self, tag, attrib): 2771 events.append("start") 2772 assertFalse(attrib) 2773 assertEquals("TAG", tag)
2774 def end(self, tag): 2775 events.append("end") 2776 assertEquals("TAG", tag) 2777 def close(self): 2778 return "DONE" 2779 2780 parser = self.etree.XMLParser(target=Target()) 2781 2782 parser.feed("<TAG/>") 2783 done = parser.close() 2784 2785 self.assertEquals("DONE", done) 2786 self.assertEquals(["start", "end"], events) 2787
2788 - def test_parser_target_attrib(self):
2789 assertEquals = self.assertEquals 2790 assertFalse = self.assertFalse 2791 2792 events = [] 2793 class Target(object): 2794 def start(self, tag, attrib): 2795 events.append("start-" + tag) 2796 for name, value in attrib.iteritems(): 2797 assertEquals(tag + name, value)
2798 def end(self, tag): 2799 events.append("end-" + tag) 2800 def close(self): 2801 return "DONE" 2802 2803 parser = self.etree.XMLParser(target=Target()) 2804 2805 parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>') 2806 done = parser.close() 2807 2808 self.assertEquals("DONE", done) 2809 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 2810 events) 2811
2812 - def test_parser_target_data(self):
2813 assertEquals = self.assertEquals 2814 assertFalse = self.assertFalse 2815 2816 events = [] 2817 class Target(object): 2818 def start(self, tag, attrib): 2819 events.append("start-" + tag)
2820 def end(self, tag): 2821 events.append("end-" + tag) 2822 def data(self, data): 2823 events.append("data-" + data) 2824 def close(self): 2825 return "DONE" 2826 2827 parser = self.etree.XMLParser(target=Target()) 2828 2829 parser.feed('<root>A<sub/>B</root>') 2830 done = parser.close() 2831 2832 self.assertEquals("DONE", done) 2833 self.assertEquals(["start-root", "data-A", "start-sub", 2834 "end-sub", "data-B", "end-root"], 2835 events) 2836 2837 # helper methods 2838
2839 - def _writeElement(self, element, encoding='us-ascii'):
2840 """Write out element for comparison. 2841 """ 2842 ElementTree = self.etree.ElementTree 2843 f = StringIO() 2844 tree = ElementTree(element=element) 2845 tree.write(f, encoding) 2846 data = unicode(f.getvalue(), encoding) 2847 return canonicalize(data)
2848
2849 - def _writeElementFile(self, element, encoding='us-ascii'):
2850 """Write out element for comparison, using real file. 2851 """ 2852 ElementTree = self.etree.ElementTree 2853 handle, filename = tempfile.mkstemp() 2854 try: 2855 f = open(filename, 'wb') 2856 tree = ElementTree(element=element) 2857 tree.write(f, encoding) 2858 f.close() 2859 f = open(filename, 'rb') 2860 data = unicode(f.read(), encoding) 2861 f.close() 2862 finally: 2863 os.close(handle) 2864 os.remove(filename) 2865 return canonicalize(data)
2866
2867 - def assertXML(self, expected, element, encoding='us-ascii'):
2868 """Writes element out and checks whether it is expected. 2869 2870 Does this two ways; once using StringIO, once using a real file. 2871 """ 2872 self.assertEquals(expected, self._writeElement(element, encoding)) 2873 self.assertEquals(expected, self._writeElementFile(element, encoding))
2874
2875 - def assertEncodingDeclaration(self, result, encoding):
2876 "Checks if the result XML byte string specifies the encoding." 2877 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 2878 self.assert_(has_encoding(result)) 2879 result_encoding = has_encoding(result).group(1) 2880 self.assertEquals(result_encoding.upper(), encoding.upper())
2881
2882 - def _rootstring(self, tree):
2883 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')
2884
2885 - def _check_element_tree(self, tree):
2886 self._check_element(tree.getroot())
2887
2888 - def _check_element(self, element):
2889 self.assert_(hasattr(element, 'tag')) 2890 self.assert_(hasattr(element, 'attrib')) 2891 self.assert_(hasattr(element, 'text')) 2892 self.assert_(hasattr(element, 'tail')) 2893 self._check_string(element.tag) 2894 self._check_mapping(element.attrib) 2895 if element.text != None: 2896 self._check_string(element.text) 2897 if element.tail != None: 2898 self._check_string(element.tail)
2899
2900 - def _check_string(self, string):
2901 len(string) 2902 for char in string: 2903 self.assertEquals(1, len(char)) 2904 new_string = string + "" 2905 new_string = string + " " 2906 string[:0]
2907
2908 - def _check_mapping(self, mapping):
2909 len(mapping) 2910 keys = mapping.keys() 2911 items = mapping.items() 2912 for key in keys: 2913 item = mapping[key] 2914 mapping["key"] = "value" 2915 self.assertEquals("value", mapping["key"])
2916 2917 # assertFalse doesn't exist in Python 2.3 2918 try: 2919 unittest.TestCase.assertFalse 2920 except AttributeError: 2921 assertFalse = unittest.TestCase.failIf 2922 2923 2924 if etree:
2925 - class ETreeTestCase(ETreeTestCaseBase):
2926 etree = etree
2927 2928 if ElementTree:
2929 - class ElementTreeTestCase(ETreeTestCaseBase):
2930 etree = ElementTree
2931 2932 if cElementTree:
2933 - class CElementTreeTestCase(ETreeTestCaseBase):
2934 etree = cElementTree
2935
2936 -def test_suite():
2937 suite = unittest.TestSuite() 2938 if etree: 2939 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 2940 if ElementTree: 2941 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 2942 if cElementTree: 2943 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 2944 return suite
2945 2946 if __name__ == '__main__': 2947 print 'to test use test.py %s' % __file__ 2948