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