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