lxml.tests.test_elementtree

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 # test weird dictionary interaction leading to segfault previously

54 - def test_weird_dict_interaction(self):

55 root = self.etree.Element('root') 56 self.assertEquals(root.tag, "root") 57 add = self.etree.ElementTree(file=StringIO('<foo>Foo</foo>')) 58 self.assertEquals(add.getroot().tag, "foo") 59 self.assertEquals(add.getroot().text, "Foo") 60 root.append(self.etree.Element('baz')) 61 self.assertEquals(root.tag, "root") 62 self.assertEquals(root[0].tag, "baz")

63

64 - def test_subelement(self):

65 Element = self.etree.Element 66 SubElement = self.etree.SubElement 67 68 root = Element('root') 69 SubElement(root, 'one') 70 SubElement(root, 'two') 71 SubElement(root, 'three') 72 self.assertEquals(3, len(root)) 73 self.assertEquals('one', root[0].tag) 74 self.assertEquals('two', root[1].tag) 75 self.assertEquals('three', root[2].tag)

76

77 - def test_element_contains(self):

78 Element = self.etree.Element 79 SubElement = self.etree.SubElement 80 81 root1 = Element('root') 82 SubElement(root1, 'one') 83 self.assert_(root1[0] in root1) 84 85 root2 = Element('root') 86 SubElement(root2, 'two') 87 SubElement(root2, 'three') 88 self.assert_(root2[0] in root2) 89 self.assert_(root2[1] in root2) 90 91 self.assertFalse(root1[0] in root2) 92 self.assertFalse(root2[0] in root1) 93 self.assertFalse(None in root2)

94

95 - def test_element_indexing_with_text(self):

96 ElementTree = self.etree.ElementTree 97 98 f = StringIO('<doc>Test<one>One</one></doc>') 99 doc = ElementTree(file=f) 100 root = doc.getroot() 101 self.assertEquals(1, len(root)) 102 self.assertEquals('one', root[0].tag) 103 self.assertRaises(IndexError, operator.getitem, root, 1)

104

105 - def test_element_indexing_with_text2(self):

106 ElementTree = self.etree.ElementTree 107 108 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 109 doc = ElementTree(file=f) 110 root = doc.getroot() 111 self.assertEquals(3, len(root)) 112 self.assertEquals('one', root[0].tag) 113 self.assertEquals('two', root[1].tag) 114 self.assertEquals('three', root[2].tag)

115

116 - def test_element_indexing_only_text(self):

117 ElementTree = self.etree.ElementTree 118 119 f = StringIO('<doc>Test</doc>') 120 doc = ElementTree(file=f) 121 root = doc.getroot() 122 self.assertEquals(0, len(root))

123

124 - def test_element_indexing_negative(self):

125 Element = self.etree.Element 126 SubElement = self.etree.SubElement 127 a = Element('a') 128 b = SubElement(a, 'b') 129 c = SubElement(a, 'c') 130 d = SubElement(a, 'd') 131 self.assertEquals(d, a[-1]) 132 self.assertEquals(c, a[-2]) 133 self.assertEquals(b, a[-3]) 134 self.assertRaises(IndexError, operator.getitem, a, -4) 135 a[-1] = e = Element('e') 136 self.assertEquals(e, a[-1]) 137 del a[-1] 138 self.assertEquals(2, len(a))

139

140 - def test_elementtree(self):

141 ElementTree = self.etree.ElementTree 142 143 f = StringIO('<doc><one>One</one><two>Two</two></doc>') 144 doc = ElementTree(file=f) 145 root = doc.getroot() 146 self.assertEquals(2, len(root)) 147 self.assertEquals('one', root[0].tag) 148 self.assertEquals('two', root[1].tag)

149

150 - def test_text(self):

151 ElementTree = self.etree.ElementTree 152 153 f = StringIO('<doc>This is a text</doc>') 154 doc = ElementTree(file=f) 155 root = doc.getroot() 156 self.assertEquals('This is a text', root.text)

157

158 - def test_text_empty(self):

159 ElementTree = self.etree.ElementTree 160 161 f = StringIO('<doc></doc>') 162 doc = ElementTree(file=f) 163 root = doc.getroot() 164 self.assertEquals(None, root.text)

165

166 - def test_text_other(self):

167 ElementTree = self.etree.ElementTree 168 169 f = StringIO('<doc><one>One</one></doc>') 170 doc = ElementTree(file=f) 171 root = doc.getroot() 172 self.assertEquals(None, root.text) 173 self.assertEquals('One', root[0].text)

174

175 - def test_text_escape_in(self):

176 ElementTree = self.etree.ElementTree 177 178 f = StringIO('<doc>This is > than a text</doc>') 179 doc = ElementTree(file=f) 180 root = doc.getroot() 181 self.assertEquals('This is > than a text', root.text)

182

183 - def test_text_escape_out(self):

184 Element = self.etree.Element 185 186 a = Element("a") 187 a.text = "<>&" 188 self.assertXML('<a><>&</a>', 189 a)

190

191 - def test_text_escape_tostring(self):

192 tostring = self.etree.tostring 193 Element = self.etree.Element 194 195 a = Element("a") 196 a.text = "<>&" 197 self.assertEquals('<a><>&</a>', 198 tostring(a))

199

200 - def test_text_str_subclass(self):

201 Element = self.etree.Element 202 203 class strTest(str): 204 pass

205 206 a = Element("a") 207 a.text = strTest("text") 208 self.assertXML('<a>text</a>', 209 a)

210

211 - def test_tail(self):

212 ElementTree = self.etree.ElementTree 213 214 f = StringIO('<doc>This is mixed content.</doc>') 215 doc = ElementTree(file=f) 216 root = doc.getroot() 217 self.assertEquals(1, len(root)) 218 self.assertEquals('This is ', root.text) 219 self.assertEquals(None, root.tail) 220 self.assertEquals('mixed', root[0].text) 221 self.assertEquals(' content.', root[0].tail)

222

223 - def test_tail_str_subclass(self):

224 Element = self.etree.Element 225 SubElement = self.etree.SubElement 226 227 class strTest(str): 228 pass

229 230 a = Element("a") 231 SubElement(a, "t").tail = strTest("tail") 232 self.assertXML('<a><t></t>tail</a>', 233 a) 234

235 - def _test_del_tail(self):

236 # this is discouraged for ET compat, should not be tested... 237 XML = self.etree.XML 238 239 root = XML('<doc>This is mixed content.</doc>') 240 self.assertEquals(1, len(root)) 241 self.assertEquals('This is ', root.text) 242 self.assertEquals(None, root.tail) 243 self.assertEquals('mixed', root[0].text) 244 self.assertEquals(' content.', root[0].tail) 245 246 del root[0].tail 247 248 self.assertEquals(1, len(root)) 249 self.assertEquals('This is ', root.text) 250 self.assertEquals(None, root.tail) 251 self.assertEquals('mixed', root[0].text) 252 self.assertEquals(None, root[0].tail) 253 254 root[0].tail = "TAIL" 255 256 self.assertEquals(1, len(root)) 257 self.assertEquals('This is ', root.text) 258 self.assertEquals(None, root.tail) 259 self.assertEquals('mixed', root[0].text) 260 self.assertEquals('TAIL', root[0].tail)

261

262 - def test_ElementTree(self):

263 Element = self.etree.Element 264 ElementTree = self.etree.ElementTree 265 266 el = Element('hoi') 267 doc = ElementTree(el) 268 root = doc.getroot() 269 self.assertEquals(None, root.text) 270 self.assertEquals('hoi', root.tag)

271

272 - def test_attributes(self):

273 ElementTree = self.etree.ElementTree 274 275 f = StringIO('<doc one="One" two="Two"/>') 276 doc = ElementTree(file=f) 277 root = doc.getroot() 278 self.assertEquals('One', root.attrib['one']) 279 self.assertEquals('Two', root.attrib['two']) 280 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

281

282 - def test_attributes2(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.attrib.get('one')) 289 self.assertEquals('Two', root.attrib.get('two')) 290 self.assertEquals(None, root.attrib.get('three')) 291 self.assertEquals('foo', root.attrib.get('three', 'foo'))

292

293 - def test_attributes3(self):

294 ElementTree = self.etree.ElementTree 295 296 f = StringIO('<doc one="One" two="Two"/>') 297 doc = ElementTree(file=f) 298 root = doc.getroot() 299 self.assertEquals('One', root.get('one')) 300 self.assertEquals('Two', root.get('two')) 301 self.assertEquals(None, root.get('three')) 302 self.assertEquals('foo', root.get('three', 'foo'))

303

304 - def test_attrib_clear(self):

305 XML = self.etree.XML 306 307 root = XML('<doc one="One" 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_set_clear(self):

315 Element = self.etree.Element 316 317 root = Element("root", one="One") 318 root.set("two", "Two") 319 self.assertEquals('One', root.get('one')) 320 self.assertEquals('Two', root.get('two')) 321 root.attrib.clear() 322 self.assertEquals(None, root.get('one')) 323 self.assertEquals(None, root.get('two'))

324

325 - def test_attrib_ns_clear(self):

326 Element = self.etree.Element 327 SubElement = self.etree.SubElement 328 329 attribNS = '{http://foo/bar}x' 330 331 parent = Element('parent') 332 parent.set(attribNS, 'a') 333 child = SubElement(parent, 'child') 334 child.set(attribNS, 'b') 335 336 self.assertEquals('a', parent.get(attribNS)) 337 self.assertEquals('b', child.get(attribNS)) 338 339 parent.clear() 340 self.assertEquals(None, parent.get(attribNS)) 341 self.assertEquals('b', child.get(attribNS))

342

343 - def test_attrib_pop(self):

344 ElementTree = self.etree.ElementTree 345 346 f = StringIO('<doc one="One" two="Two"/>') 347 doc = ElementTree(file=f) 348 root = doc.getroot() 349 self.assertEquals('One', root.attrib['one']) 350 self.assertEquals('Two', root.attrib['two']) 351 352 self.assertEquals('One', root.attrib.pop('one')) 353 354 self.assertEquals(None, root.attrib.get('one')) 355 self.assertEquals('Two', root.attrib['two'])

356

357 - def test_attrib_pop_unknown(self):

358 root = self.etree.XML('<doc one="One" two="Two"/>') 359 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 360 361 self.assertEquals('One', root.attrib['one']) 362 self.assertEquals('Two', root.attrib['two'])

363

364 - def test_attrib_pop_default(self):

365 root = self.etree.XML('<doc one="One" two="Two"/>') 366 self.assertEquals('Three', root.attrib.pop('three', 'Three'))

367

368 - def test_attrib_pop_empty_default(self):

369 root = self.etree.XML('<doc/>') 370 self.assertEquals('Three', root.attrib.pop('three', 'Three'))

371

372 - def test_attrib_pop_invalid_args(self):

373 root = self.etree.XML('<doc one="One" two="Two"/>') 374 self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)

375

376 - def test_attribute_update_dict(self):

377 XML = self.etree.XML 378 379 root = XML('<doc alpha="Alpha" beta="Beta"/>') 380 items = root.attrib.items() 381 items.sort() 382 self.assertEquals( 383 [('alpha', 'Alpha'), ('beta', 'Beta')], 384 items) 385 386 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 387 388 items = root.attrib.items() 389 items.sort() 390 self.assertEquals( 391 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 392 items)

393

394 - def test_attribute_update_sequence(self):

395 XML = self.etree.XML 396 397 root = XML('<doc alpha="Alpha" beta="Beta"/>') 398 items = root.attrib.items() 399 items.sort() 400 self.assertEquals( 401 [('alpha', 'Alpha'), ('beta', 'Beta')], 402 items) 403 404 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 405 406 items = root.attrib.items() 407 items.sort() 408 self.assertEquals( 409 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 410 items)

411

412 - def test_attribute_update_iter(self):

413 XML = self.etree.XML 414 415 root = XML('<doc alpha="Alpha" beta="Beta"/>') 416 items = root.attrib.items() 417 items.sort() 418 self.assertEquals( 419 [('alpha', 'Alpha'), ('beta', 'Beta')], 420 items) 421 422 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems()) 423 424 items = root.attrib.items() 425 items.sort() 426 self.assertEquals( 427 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 428 items)

429

430 - def test_attribute_keys(self):

431 XML = self.etree.XML 432 433 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 434 keys = root.attrib.keys() 435 keys.sort() 436 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

437

438 - def test_attribute_keys2(self):

439 XML = self.etree.XML 440 441 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 442 keys = root.keys() 443 keys.sort() 444 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

445

446 - def test_attribute_items2(self):

447 XML = self.etree.XML 448 449 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 450 items = root.items() 451 items.sort() 452 self.assertEquals( 453 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 454 items)

455

456 - def test_attribute_keys_ns(self):

457 XML = self.etree.XML 458 459 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 460 keys = root.keys() 461 keys.sort() 462 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 463 keys)

464

465 - def test_attribute_values(self):

466 XML = self.etree.XML 467 468 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 469 values = root.attrib.values() 470 values.sort() 471 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)

472

473 - def test_attribute_values_ns(self):

474 XML = self.etree.XML 475 476 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 477 values = root.attrib.values() 478 values.sort() 479 self.assertEquals( 480 ['Bar', 'Baz'], values)

481

482 - def test_attribute_items(self):

483 XML = self.etree.XML 484 485 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 486 items = root.attrib.items() 487 items.sort() 488 self.assertEquals([ 489 ('alpha', 'Alpha'), 490 ('beta', 'Beta'), 491 ('gamma', 'Gamma'), 492 ], 493 items)

494

495 - def test_attribute_items_ns(self):

496 XML = self.etree.XML 497 498 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 499 items = root.attrib.items() 500 items.sort() 501 self.assertEquals( 502 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 503 items)

504

505 - def test_attribute_str(self):

506 XML = self.etree.XML 507 508 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 509 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 510 511 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 512 try: 513 self.assertEquals(expected, str(root.attrib)) 514 except AssertionError: 515 self.assertEquals(alternative, str(root.attrib))

516

517 - def test_attribute_has_key(self):

518 XML = self.etree.XML 519 520 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 521 self.assertEquals( 522 True, root.attrib.has_key('bar')) 523 self.assertEquals( 524 False, root.attrib.has_key('baz')) 525 self.assertEquals( 526 False, root.attrib.has_key('hah')) 527 self.assertEquals( 528 True, 529 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))

530

531 - def test_attribute_contains(self):

532 XML = self.etree.XML 533 534 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 535 self.assertEquals( 536 True, 'bar' in root.attrib) 537 self.assertEquals( 538 False, 'baz' in root.attrib) 539 self.assertEquals( 540 False, 'hah' in root.attrib) 541 self.assertEquals( 542 True, 543 '{http://ns.codespeak.net/test}baz' in root.attrib)

544

545 - def test_attribute_set(self):

546 Element = self.etree.Element 547 548 root = Element("root") 549 root.set("attr", "TEST") 550 self.assertEquals("TEST", root.get("attr"))

551

552 - def test_XML(self):

553 XML = self.etree.XML 554 555 root = XML('<doc>This is a text.</doc>') 556 self.assertEquals(0, len(root)) 557 self.assertEquals('This is a text.', root.text)

558

559 - def test_XMLID(self):

560 XMLID = self.etree.XMLID 561 XML = self.etree.XML 562 xml_text = ''' 563 <document> 564 <h1 id="chapter1">...</h1> 565 ... 566 Regular paragraph. 567 XML:ID paragraph. 568 ... 569 </document> 570 ''' 571 572 root, dic = XMLID(xml_text) 573 root2 = XML(xml_text) 574 self.assertEquals(self._writeElement(root), 575 self._writeElement(root2)) 576 expected = { 577 "chapter1" : root[0], 578 "note1" : root[1], 579 "warn1" : root[4] 580 } 581 self.assertEquals(dic, expected)

582

583 - def test_fromstring(self):

584 fromstring = self.etree.fromstring 585 586 root = fromstring('<doc>This is a text.</doc>') 587 self.assertEquals(0, len(root)) 588 self.assertEquals('This is a text.', root.text)

589

590 - def test_fromstringlist(self):

591 fromstringlist = self.etree.fromstringlist 592 593 root = fromstringlist(["<do", "c>T", "hi", "s is", 594 " a text.<", "/doc", ">"]) 595 self.assertEquals(0, len(root)) 596 self.assertEquals('This is a text.', root.text)

597

598 - def test_fromstringlist_characters(self):

599 fromstringlist = self.etree.fromstringlist 600 601 root = fromstringlist(list('<doc>This is a text.</doc>')) 602 self.assertEquals(0, len(root)) 603 self.assertEquals('This is a text.', root.text)

604

605 - def test_fromstringlist_single(self):

606 fromstringlist = self.etree.fromstringlist 607 608 root = fromstringlist(['<doc>This is a text.</doc>']) 609 self.assertEquals(0, len(root)) 610 self.assertEquals('This is a text.', root.text)

611

612 - def test_iselement(self):

613 iselement = self.etree.iselement 614 Element = self.etree.Element 615 ElementTree = self.etree.ElementTree 616 XML = self.etree.XML 617 Comment = self.etree.Comment 618 ProcessingInstruction = self.etree.ProcessingInstruction 619 620 el = Element('hoi') 621 self.assert_(iselement(el)) 622 623 el2 = XML('<foo/>') 624 self.assert_(iselement(el2)) 625 626 tree = ElementTree(element=Element('dag')) 627 self.assert_(not iselement(tree)) 628 self.assert_(iselement(tree.getroot())) 629 630 c = Comment('test') 631 self.assert_(iselement(c)) 632 633 p = ProcessingInstruction("test", "some text") 634 self.assert_(iselement(p))

635

636 - def test_iteration(self):

637 XML = self.etree.XML 638 639 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 640 result = [] 641 for el in root: 642 result.append(el.tag) 643 self.assertEquals(['one', 'two', 'three'], result)

644

645 - def test_iteration_empty(self):

646 XML = self.etree.XML 647 648 root = XML('<doc></doc>') 649 result = [] 650 for el in root: 651 result.append(el.tag) 652 self.assertEquals([], result)

653

654 - def test_iteration_text_only(self):

655 XML = self.etree.XML 656 657 root = XML('<doc>Text</doc>') 658 result = [] 659 for el in root: 660 result.append(el.tag) 661 self.assertEquals([], result)

662

663 - def test_iteration_crash(self):

664 # this would cause a crash in the past 665 fromstring = self.etree.fromstring 666 root = etree.fromstring('<html>x</html>') 667 for elem in root: 668 elem.tail = ''

669

670 - def test_iteration_reversed(self):

671 XML = self.etree.XML 672 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 673 result = [] 674 for el in reversed(root): 675 result.append(el.tag) 676 self.assertEquals(['three', 'two', 'one'], result)

677

678 - def test_iteration_subelement(self):

679 XML = self.etree.XML 680 681 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 682 result = [] 683 add = True 684 for el in root: 685 result.append(el.tag) 686 if add: 687 self.etree.SubElement(root, 'four') 688 add = False 689 self.assertEquals(['one', 'two', 'three', 'four'], result)

690

691 - def test_iteration_del_child(self):

692 XML = self.etree.XML 693 694 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 695 result = [] 696 for el in root: 697 result.append(el.tag) 698 del root[-1] 699 self.assertEquals(['one', 'two'], result)

700

701 - def test_iteration_double(self):

702 XML = self.etree.XML 703 704 root = XML('<doc><one/><two/></doc>') 705 result = [] 706 for el0 in root: 707 result.append(el0.tag) 708 for el1 in root: 709 result.append(el1.tag) 710 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

711

712 - def test_attribute_iterator(self):

713 XML = self.etree.XML 714 715 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />') 716 result = [] 717 for key in root.attrib: 718 result.append(key) 719 result.sort() 720 self.assertEquals(['alpha', 'beta', 'gamma'], result)

721

722 - def test_itertext(self):

723 # ET 1.3+ 724 XML = self.etree.XML 725 root = XML("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>") 726 727 text = list(root.itertext()) 728 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 729 text)

730

731 - def test_itertext_child(self):

732 # ET 1.3+ 733 XML = self.etree.XML 734 root = XML("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>") 735 736 text = list(root[2].itertext()) 737 self.assertEquals(["CTEXT"], 738 text)

739

740 - def test_findall(self):

741 XML = self.etree.XML 742 root = XML('<a><c/><c></c></a>') 743 self.assertEquals(len(list(root.findall("c"))), 1) 744 self.assertEquals(len(list(root.findall(".//c"))), 2) 745 self.assertEquals(len(list(root.findall(".//b"))), 3) 746 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 747 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 748 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

749

750 - def test_findall_ns(self):

751 XML = self.etree.XML 752 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 753 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 754 self.assertEquals(len(list(root.findall(".//b"))), 3) 755 self.assertEquals(len(list(root.findall("b"))), 2)

756

757 - def test_element_with_attributes_keywords(self):

758 Element = self.etree.Element 759 760 el = Element('tag', foo='Foo', bar='Bar') 761 self.assertEquals('Foo', el.attrib['foo']) 762 self.assertEquals('Bar', el.attrib['bar'])

763

764 - def test_element_with_attributes(self):

765 Element = self.etree.Element 766 767 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 768 self.assertEquals('Foo', el.attrib['foo']) 769 self.assertEquals('Bar', el.attrib['bar'])

770

771 - def test_element_with_attributes_ns(self):

772 Element = self.etree.Element 773 774 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 775 self.assertEquals('Foo', el.attrib['{ns1}foo']) 776 self.assertEquals('Bar', el.attrib['{ns2}bar'])

777

778 - def test_subelement_with_attributes(self):

779 Element = self.etree.Element 780 SubElement = self.etree.SubElement 781 782 el = Element('tag') 783 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 784 self.assertEquals("Baz", el[0].attrib['baz']) 785 self.assertEquals('Foo', el[0].attrib['foo'])

786

787 - def test_subelement_with_attributes_ns(self):

788 Element = self.etree.Element 789 SubElement = self.etree.SubElement 790 791 el = Element('tag') 792 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 793 self.assertEquals('Foo', el[0].attrib['{ns1}foo']) 794 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])

795

796 - def test_write(self):

797 ElementTree = self.etree.ElementTree 798 XML = self.etree.XML 799 800 for i in range(10): 801 f = StringIO() 802 root = XML('<doc%s>This is a test.</doc%s>' % (i, i)) 803 tree = ElementTree(element=root) 804 tree.write(f) 805 data = f.getvalue() 806 self.assertEquals( 807 '<doc%s>This is a test.</doc%s>' % (i, i), 808 canonicalize(data))

809

810 - def test_write_method_html(self):

811 ElementTree = self.etree.ElementTree 812 Element = self.etree.Element 813 SubElement = self.etree.SubElement 814 815 html = Element('html') 816 body = SubElement(html, 'body') 817 p = SubElement(body, 'p') 818 p.text = "html" 819 SubElement(p, 'br').tail = "test" 820 821 tree = ElementTree(element=html) 822 f = StringIO() 823 tree.write(f, method="html") 824 data = f.getvalue().replace('\n','') 825 826 self.assertEquals('<html><body>html test</body></html>', 827 data)

828

829 - def test_write_method_text(self):

830 ElementTree = self.etree.ElementTree 831 Element = self.etree.Element 832 SubElement = self.etree.SubElement 833 834 a = Element('a') 835 a.text = "A" 836 a.tail = "tail" 837 b = SubElement(a, 'b') 838 b.text = "B" 839 b.tail = "TAIL" 840 c = SubElement(a, 'c') 841 c.text = "C" 842 843 tree = ElementTree(element=a) 844 f = StringIO() 845 tree.write(f, method="text") 846 data = f.getvalue() 847 848 self.assertEquals('ABTAILCtail', 849 data)

850

851 - def test_write_fail(self):

852 ElementTree = self.etree.ElementTree 853 XML = self.etree.XML 854 855 tree = ElementTree( XML('<doc>This is a test.</doc>') ) 856 self.assertRaises(IOError, tree.write, 857 "definitely////\\-\\nonexisting\\-\\////FILE")

858 859 # this could trigger a crash, apparently because the document 860 # reference was prematurely garbage collected

861 - def test_crash(self):

862 Element = self.etree.Element 863 864 element = Element('tag') 865 for i in range(10): 866 element.attrib['key'] = 'value' 867 value = element.attrib['key'] 868 self.assertEquals(value, 'value')

869 870 # from doctest; for some reason this caused crashes too

871 - def test_write_ElementTreeDoctest(self):

872 Element = self.etree.Element 873 ElementTree = self.etree.ElementTree 874 875 f = StringIO() 876 for i in range(10): 877 element = Element('tag%s' % i) 878 self._check_element(element) 879 tree = ElementTree(element) 880 tree.write(f) 881 self._check_element_tree(tree)

882

883 - def test_subelement_reference(self):

884 Element = self.etree.Element 885 SubElement = self.etree.SubElement 886 887 el = Element('foo') 888 el2 = SubElement(el, 'bar') 889 el3 = SubElement(el2, 'baz') 890 891 al = Element('foo2') 892 al2 = SubElement(al, 'bar2') 893 al3 = SubElement(al2, 'baz2') 894 895 # now move al2 into el 896 el.append(al2) 897 898 # now change al3 directly 899 al3.text = 'baz2-modified' 900 901 # it should have changed through this route too 902 self.assertEquals( 903 'baz2-modified', 904 el[1][0].text)

905

906 - def test_set_text(self):

907 Element = self.etree.Element 908 SubElement = self.etree.SubElement 909 910 a = Element('a') 911 b = SubElement(a, 'b') 912 a.text = 'hoi' 913 self.assertEquals( 914 'hoi', 915 a.text) 916 self.assertEquals( 917 'b', 918 a[0].tag)

919

920 - def test_set_text2(self):

921 Element = self.etree.Element 922 SubElement = self.etree.SubElement 923 924 a = Element('a') 925 a.text = 'hoi' 926 b = SubElement(a ,'b') 927 self.assertEquals( 928 'hoi', 929 a.text) 930 self.assertEquals( 931 'b', 932 a[0].tag)

933

934 - def test_set_text_none(self):

935 Element = self.etree.Element 936 937 a = Element('a') 938 939 a.text = 'foo' 940 a.text = None 941 942 self.assertEquals( 943 None, 944 a.text) 945 self.assertXML('<a></a>', a)

946

947 - def test_set_text_empty(self):

948 Element = self.etree.Element 949 950 a = Element('a') 951 self.assertEquals(None, a.text) 952 953 a.text = '' 954 self.assertEquals('', a.text) 955 self.assertXML('<a></a>', a)

956

957 - def test_tail1(self):

958 Element = self.etree.Element 959 SubElement = self.etree.SubElement 960 961 a = Element('a') 962 a.tail = 'dag' 963 self.assertEquals('dag', 964 a.tail) 965 b = SubElement(a, 'b') 966 b.tail = 'hoi' 967 self.assertEquals('hoi', 968 b.tail) 969 self.assertEquals('dag', 970 a.tail)

971

972 - def test_tail_append(self):

973 Element = self.etree.Element 974 975 a = Element('a') 976 b = Element('b') 977 b.tail = 'b_tail' 978 a.append(b) 979 self.assertEquals('b_tail', 980 b.tail)

981

982 - def test_tail_set_twice(self):

983 Element = self.etree.Element 984 SubElement = self.etree.SubElement 985 986 a = Element('a') 987 b = SubElement(a, 'b') 988 b.tail = 'foo' 989 b.tail = 'bar' 990 self.assertEquals('bar', 991 b.tail) 992 self.assertXML('<a>bar</a>', a)

993

994 - def test_tail_set_none(self):

995 Element = self.etree.Element 996 a = Element('a') 997 a.tail = 'foo' 998 a.tail = None 999 self.assertEquals( 1000 None, 1001 a.tail) 1002 self.assertXML('<a></a>', a)

1003

1004 - def test_extend(self):

1005 root = self.etree.Element('foo') 1006 for i in range(3): 1007 element = self.etree.SubElement(root, 'a%s' % i) 1008 element.text = "text%d" % i 1009 element.tail = "tail%d" % i 1010 1011 elements = [] 1012 for i in range(3): 1013 new_element = self.etree.Element("test%s" % i) 1014 new_element.text = "TEXT%s" % i 1015 new_element.tail = "TAIL%s" % i 1016 elements.append(new_element) 1017 1018 root.extend(elements) 1019 1020 self.assertEquals( 1021 ["a0", "a1", "a2", "test0", "test1", "test2"], 1022 [ el.tag for el in root ]) 1023 self.assertEquals( 1024 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1025 [ el.text for el in root ]) 1026 self.assertEquals( 1027 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1028 [ el.tail for el in root ])

1029

1030 - def test_comment(self):

1031 Element = self.etree.Element 1032 SubElement = self.etree.SubElement 1033 Comment = self.etree.Comment 1034 1035 a = Element('a') 1036 a.append(Comment('foo')) 1037 self.assertEquals(a[0].tag, Comment) 1038 self.assertEquals(a[0].text, 'foo')

1039

1040 - def test_comment_text(self):

1041 Element = self.etree.Element 1042 SubElement = self.etree.SubElement 1043 Comment = self.etree.Comment 1044 1045 a = Element('a') 1046 a.append(Comment('foo')) 1047 self.assertEquals(a[0].text, 'foo') 1048 1049 a[0].text = "TEST" 1050 self.assertEquals(a[0].text, 'TEST')

1051

1052 - def test_comment_whitespace(self):

1053 Element = self.etree.Element 1054 SubElement = self.etree.SubElement 1055 Comment = self.etree.Comment 1056 1057 a = Element('a') 1058 a.append(Comment(' foo ')) 1059 self.assertEquals(a[0].text, ' foo ')

1060

1061 - def test_comment_nonsense(self):

1062 Comment = self.etree.Comment 1063 c = Comment('foo') 1064 self.assertEquals({}, c.attrib) 1065 self.assertEquals([], c.keys()) 1066 self.assertEquals([], c.items()) 1067 self.assertEquals(None, c.get('hoi')) 1068 self.assertEquals(0, len(c)) 1069 # should not iterate 1070 for i in c: 1071 pass

1072 1073 # ElementTree < 1.3 adds whitespace around comments

1074 - def test_comment_text(self):

1075 Element = self.etree.Element 1076 Comment = self.etree.Comment 1077 tostring = self.etree.tostring 1078 1079 a = Element('a') 1080 a.append(Comment('foo')) 1081 self.assertEquals( 1082 '<a></a>', 1083 tostring(a)) 1084 1085 a[0].text = "TEST" 1086 self.assertEquals( 1087 '<a></a>', 1088 tostring(a))

1089 1090 # ElementTree < 1.3 adds whitespace around comments

1091 - def test_comment_whitespace(self):

1092 Element = self.etree.Element 1093 Comment = self.etree.Comment 1094 tostring = self.etree.tostring 1095 1096 a = Element('a') 1097 a.append(Comment(' foo ')) 1098 self.assertEquals( 1099 '<a></a>', 1100 tostring(a))

1101

1102 - def test_pi(self):

1103 # lxml.etree separates target and text 1104 Element = self.etree.Element 1105 SubElement = self.etree.SubElement 1106 ProcessingInstruction = self.etree.ProcessingInstruction 1107 1108 a = Element('a') 1109 a.append(ProcessingInstruction('foo', 'some more text')) 1110 self.assertEquals(a[0].tag, ProcessingInstruction) 1111 self.assertXML("<a><?foo some more text?></a>", 1112 a)

1113

1114 - def test_processinginstruction(self):

1115 # lxml.etree separates target and text 1116 Element = self.etree.Element 1117 SubElement = self.etree.SubElement 1118 ProcessingInstruction = self.etree.PI 1119 1120 a = Element('a') 1121 a.append(ProcessingInstruction('foo', 'some more text')) 1122 self.assertEquals(a[0].tag, ProcessingInstruction) 1123 self.assertXML("<a><?foo some more text?></a>", 1124 a)

1125

1126 - def test_pi_nonsense(self):

1127 ProcessingInstruction = self.etree.ProcessingInstruction 1128 pi = ProcessingInstruction('foo') 1129 self.assertEquals({}, pi.attrib) 1130 self.assertEquals([], pi.keys()) 1131 self.assertEquals([], pi.items()) 1132 self.assertEquals(None, pi.get('hoi')) 1133 self.assertEquals(0, len(pi)) 1134 # should not iterate 1135 for i in pi: 1136 pass

1137

1138 - def test_setitem(self):

1139 Element = self.etree.Element 1140 SubElement = self.etree.SubElement 1141 1142 a = Element('a') 1143 b = SubElement(a, 'b') 1144 c = Element('c') 1145 a[0] = c 1146 self.assertEquals( 1147 c, 1148 a[0]) 1149 self.assertXML('<a><c></c></a>', 1150 a) 1151 self.assertXML('', 1152 b)

1153

1154 - def test_setitem2(self):

1155 Element = self.etree.Element 1156 SubElement = self.etree.SubElement 1157 1158 a = Element('a') 1159 for i in range(5): 1160 b = SubElement(a, 'b%s' % i) 1161 c = SubElement(b, 'c') 1162 for i in range(5): 1163 d = Element('d') 1164 e = SubElement(d, 'e') 1165 a[i] = d 1166 self.assertXML( 1167 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>', 1168 a) 1169 self.assertXML('<c></c>', 1170 c)

1171

1172 - def test_setitem_replace(self):

1173 Element = self.etree.Element 1174 SubElement = self.etree.SubElement 1175 1176 a = Element('a') 1177 SubElement(a, 'b') 1178 d = Element('d') 1179 a[0] = d 1180 self.assertXML('<a><d></d></a>', a)

1181

1182 - def test_setitem_indexerror(self):

1183 Element = self.etree.Element 1184 SubElement = self.etree.SubElement 1185 1186 a = Element('a') 1187 b = SubElement(a, 'b') 1188 1189 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1190

1191 - def test_setitem_tail(self):

1192 Element = self.etree.Element 1193 SubElement = self.etree.SubElement 1194 1195 a = Element('a') 1196 b = SubElement(a, 'b') 1197 b.tail = 'B2' 1198 c = Element('c') 1199 c.tail = 'C2' 1200 1201 a[0] = c 1202 self.assertXML( 1203 '<a><c></c>C2</a>', 1204 a)

1205

1206 - def test_tag_write(self):

1207 Element = self.etree.Element 1208 SubElement = self.etree.SubElement 1209 1210 a = Element('a') 1211 b = SubElement(a, 'b') 1212 1213 a.tag = 'c' 1214 1215 self.assertEquals( 1216 'c', 1217 a.tag) 1218 1219 self.assertXML( 1220 '<c></c>', 1221 a)

1222

1223 - def test_tag_reset_ns(self):

1224 Element = self.etree.Element 1225 SubElement = self.etree.SubElement 1226 tostring = self.etree.tostring 1227 1228 a = Element('{a}a') 1229 b1 = SubElement(a, '{a}b') 1230 b2 = SubElement(a, '{b}b') 1231 1232 self.assertEquals('{a}b', b1.tag) 1233 1234 b1.tag = 'c' 1235 1236 # can't use C14N here! 1237 self.assertEquals('c', b1.tag) 1238 self.assertEquals('<c', tostring(b1)[:2]) 1239 self.assert_('<c' in tostring(a))

1240

1241 - def test_tag_reset_root_ns(self):

1242 Element = self.etree.Element 1243 SubElement = self.etree.SubElement 1244 tostring = self.etree.tostring 1245 1246 a = Element('{a}a') 1247 b1 = SubElement(a, '{a}b') 1248 b2 = SubElement(a, '{b}b') 1249 1250 a.tag = 'c' 1251 1252 self.assertEquals( 1253 'c', 1254 a.tag) 1255 1256 # can't use C14N here! 1257 self.assertEquals('c', a.tag) 1258 self.assertEquals('<c', tostring(a)[:2])

1259

1260 - def test_tag_str_subclass(self):

1261 Element = self.etree.Element 1262 1263 class strTest(str): 1264 pass

1265 1266 a = Element("a") 1267 a.tag = strTest("TAG") 1268 self.assertXML('<TAG></TAG>', 1269 a) 1270

1271 - def test_delitem(self):

1272 Element = self.etree.Element 1273 SubElement = self.etree.SubElement 1274 1275 a = Element('a') 1276 b = SubElement(a, 'b') 1277 c = SubElement(a, 'c') 1278 d = SubElement(a, 'd') 1279 1280 del a[1] 1281 self.assertXML( 1282 '<a><d></d></a>', 1283 a) 1284 1285 del a[0] 1286 self.assertXML( 1287 '<a><d></d></a>', 1288 a) 1289 1290 del a[0] 1291 self.assertXML( 1292 '<a></a>', 1293 a) 1294 # move deleted element into other tree afterwards 1295 other = Element('other') 1296 other.append(c) 1297 self.assertXML( 1298 '<other><c></c></other>', 1299 other)

1300

1301 - def test_del_insert(self):

1302 Element = self.etree.Element 1303 SubElement = self.etree.SubElement 1304 1305 a = Element('a') 1306 b = SubElement(a, 'b') 1307 bs = SubElement(b, 'bs') 1308 c = SubElement(a, 'c') 1309 cs = SubElement(c, 'cs') 1310 1311 el = a[0] 1312 self.assertXML( 1313 '<a><bs></bs><c><cs></cs></c></a>', 1314 a) 1315 self.assertXML('<bs></bs>', b) 1316 self.assertXML('<c><cs></cs></c>', c) 1317 1318 del a[0] 1319 self.assertXML( 1320 '<a><c><cs></cs></c></a>', 1321 a) 1322 self.assertXML('<bs></bs>', b) 1323 self.assertXML('<c><cs></cs></c>', c) 1324 1325 a.insert(0, el) 1326 self.assertXML( 1327 '<a><bs></bs><c><cs></cs></c></a>', 1328 a) 1329 self.assertXML('<bs></bs>', b) 1330 self.assertXML('<c><cs></cs></c>', c)

1331

1332 - def test_del_setitem(self):

1333 Element = self.etree.Element 1334 SubElement = self.etree.SubElement 1335 1336 a = Element('a') 1337 b = SubElement(a, 'b') 1338 bs = SubElement(b, 'bs') 1339 c = SubElement(a, 'c') 1340 cs = SubElement(c, 'cs') 1341 1342 el = a[0] 1343 del a[0] 1344 a[0] = el 1345 self.assertXML( 1346 '<a><bs></bs></a>', 1347 a) 1348 self.assertXML('<bs></bs>', b) 1349 self.assertXML('<c><cs></cs></c>', c)

1350

1351 - def test_del_setslice(self):

1352 Element = self.etree.Element 1353 SubElement = self.etree.SubElement 1354 1355 a = Element('a') 1356 b = SubElement(a, 'b') 1357 bs = SubElement(b, 'bs') 1358 c = SubElement(a, 'c') 1359 cs = SubElement(c, 'cs') 1360 1361 el = a[0] 1362 del a[0] 1363 a[0:0] = [el] 1364 self.assertXML( 1365 '<a><bs></bs><c><cs></cs></c></a>', 1366 a) 1367 self.assertXML('<bs></bs>', b) 1368 self.assertXML('<c><cs></cs></c>', c)

1369

1370 - def test_replace_slice_tail(self):

1371 XML = self.etree.XML 1372 a = XML('<a>B2<c></c>C2</a>') 1373 b, c = a 1374 1375 a[:] = [] 1376 1377 self.assertEquals("B2", b.tail) 1378 self.assertEquals("C2", c.tail)

1379

1380 - def test_delitem_tail(self):

1381 ElementTree = self.etree.ElementTree 1382 f = StringIO('<a>B2<c></c>C2</a>') 1383 doc = ElementTree(file=f) 1384 a = doc.getroot() 1385 del a[0] 1386 self.assertXML( 1387 '<a><c></c>C2</a>', 1388 a)

1389

1390 - def test_clear(self):

1391 Element = self.etree.Element 1392 1393 a = Element('a') 1394 a.text = 'foo' 1395 a.tail = 'bar' 1396 a.set('hoi', 'dag') 1397 a.clear() 1398 self.assertEquals(None, a.text) 1399 self.assertEquals(None, a.tail) 1400 self.assertEquals(None, a.get('hoi')) 1401 self.assertEquals('a', a.tag)

1402

1403 - def test_clear_sub(self):

1404 Element = self.etree.Element 1405 SubElement = self.etree.SubElement 1406 1407 a = Element('a') 1408 a.text = 'foo' 1409 a.tail = 'bar' 1410 a.set('hoi', 'dag') 1411 b = SubElement(a, 'b') 1412 c = SubElement(b, 'c') 1413 a.clear() 1414 self.assertEquals(None, a.text) 1415 self.assertEquals(None, a.tail) 1416 self.assertEquals(None, a.get('hoi')) 1417 self.assertEquals('a', a.tag) 1418 self.assertEquals(0, len(a)) 1419 self.assertXML('<a></a>', 1420 a) 1421 self.assertXML('<c></c>', 1422 b)

1423

1424 - def test_clear_tail(self):

1425 ElementTree = self.etree.ElementTree 1426 f = StringIO('<a>B2<c></c>C2</a>') 1427 doc = ElementTree(file=f) 1428 a = doc.getroot() 1429 a.clear() 1430 self.assertXML( 1431 '<a></a>', 1432 a)

1433

1434 - def test_insert(self):

1435 Element = self.etree.Element 1436 SubElement = self.etree.SubElement 1437 1438 a = Element('a') 1439 b = SubElement(a, 'b') 1440 c = SubElement(a, 'c') 1441 d = Element('d') 1442 a.insert(0, d) 1443 1444 self.assertEquals( 1445 d, 1446 a[0]) 1447 1448 self.assertXML( 1449 '<a><d></d><c></c></a>', 1450 a) 1451 1452 e = Element('e') 1453 a.insert(2, e) 1454 self.assertEquals( 1455 e, 1456 a[2]) 1457 self.assertXML( 1458 '<a><d></d><e></e><c></c></a>', 1459 a)

1460

1461 - def test_insert_beyond_index(self):

1462 Element = self.etree.Element 1463 SubElement = self.etree.SubElement 1464 1465 a = Element('a') 1466 b = SubElement(a, 'b') 1467 c = Element('c') 1468 1469 a.insert(2, c) 1470 self.assertEquals( 1471 c, 1472 a[1]) 1473 self.assertXML( 1474 '<a><c></c></a>', 1475 a)

1476

1477 - def test_insert_negative(self):

1478 Element = self.etree.Element 1479 SubElement = self.etree.SubElement 1480 1481 a = Element('a') 1482 b = SubElement(a, 'b') 1483 c = SubElement(a, 'c') 1484 1485 d = Element('d') 1486 a.insert(-1, d) 1487 self.assertEquals( 1488 d, 1489 a[-2]) 1490 self.assertXML( 1491 '<a><d></d><c></c></a>', 1492 a)

1493

1494 - def test_insert_tail(self):

1495 Element = self.etree.Element 1496 SubElement = self.etree.SubElement 1497 1498 a = Element('a') 1499 b = SubElement(a, 'b') 1500 1501 c = Element('c') 1502 c.tail = 'C2' 1503 1504 a.insert(0, c) 1505 self.assertXML( 1506 '<a><c></c>C2</a>', 1507 a)

1508

1509 - def test_remove(self):

1510 Element = self.etree.Element 1511 SubElement = self.etree.SubElement 1512 1513 a = Element('a') 1514 b = SubElement(a, 'b') 1515 c = SubElement(a, 'c') 1516 1517 a.remove(b) 1518 self.assertEquals( 1519 c, 1520 a[0]) 1521 self.assertXML( 1522 '<a><c></c></a>', 1523 a)

1524

1525 - def test_remove_ns(self):

1526 Element = self.etree.Element 1527 SubElement = self.etree.SubElement 1528 1529 a = Element('{http://test}a') 1530 b = SubElement(a, '{http://test}b') 1531 c = SubElement(a, '{http://test}c') 1532 1533 a.remove(b) 1534 self.assertXML( 1535 '<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>', 1536 a) 1537 self.assertXML( 1538 '<ns0:b xmlns:ns0="http://test"></ns0:b>', 1539 b)

1540

1541 - def test_remove_nonexisting(self):

1542 Element = self.etree.Element 1543 SubElement = self.etree.SubElement 1544 1545 a = Element('a') 1546 b = SubElement(a, 'b') 1547 c = SubElement(a, 'c') 1548 d = Element('d') 1549 self.assertRaises( 1550 ValueError, a.remove, d)

1551

1552 - def test_remove_tail(self):

1553 Element = self.etree.Element 1554 SubElement = self.etree.SubElement 1555 1556 a = Element('a') 1557 b = SubElement(a, 'b') 1558 b.tail = 'b2' 1559 a.remove(b) 1560 self.assertXML( 1561 '<a></a>', 1562 a) 1563 self.assertEquals('b2', b.tail)

1564

1565 - def _test_getchildren(self):

1566 Element = self.etree.Element 1567 SubElement = self.etree.SubElement 1568 1569 a = Element('a') 1570 b = SubElement(a, 'b') 1571 c = SubElement(a, 'c') 1572 d = SubElement(b, 'd') 1573 e = SubElement(c, 'e') 1574 self.assertXML( 1575 '<a><d></d><c><e></e></c></a>', 1576 a) 1577 self.assertEquals( 1578 [b, c], 1579 a.getchildren()) 1580 self.assertEquals( 1581 [d], 1582 b.getchildren()) 1583 self.assertEquals( 1584 [], 1585 d.getchildren())

1586

1587 - def test_makeelement(self):

1588 Element = self.etree.Element 1589 1590 a = Element('a') 1591 b = a.makeelement('c', {'hoi':'dag'}) 1592 self.assertXML( 1593 '<c hoi="dag"></c>', 1594 b)

1595

1596 - def test_iter(self):

1597 Element = self.etree.Element 1598 SubElement = self.etree.SubElement 1599 1600 a = Element('a') 1601 b = SubElement(a, 'b') 1602 c = SubElement(a, 'c') 1603 d = SubElement(b, 'd') 1604 e = SubElement(c, 'e') 1605 1606 self.assertEquals( 1607 [a, b, d, c, e], 1608 list(a.iter())) 1609 self.assertEquals( 1610 [d], 1611 list(d.iter()))

1612

1613 - def test_getiterator(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(b, 'd') 1621 e = SubElement(c, 'e') 1622 1623 self.assertEquals( 1624 [a, b, d, c, e], 1625 list(a.getiterator())) 1626 self.assertEquals( 1627 [d], 1628 list(d.getiterator()))

1629

1630 - def test_getiterator_empty(self):

1631 Element = self.etree.Element 1632 SubElement = self.etree.SubElement 1633 1634 a = Element('a') 1635 b = SubElement(a, 'b') 1636 c = SubElement(a, 'c') 1637 d = SubElement(b, 'd') 1638 e = SubElement(c, 'e') 1639 1640 self.assertEquals( 1641 [], 1642 list(a.getiterator('none'))) 1643 self.assertEquals( 1644 [], 1645 list(e.getiterator('none'))) 1646 self.assertEquals( 1647 [e], 1648 list(e.getiterator()))

1649

1650 - def test_getiterator_filter(self):

1651 Element = self.etree.Element 1652 SubElement = self.etree.SubElement 1653 1654 a = Element('a') 1655 b = SubElement(a, 'b') 1656 c = SubElement(a, 'c') 1657 d = SubElement(b, 'd') 1658 e = SubElement(c, 'e') 1659 1660 self.assertEquals( 1661 [a], 1662 list(a.getiterator('a'))) 1663 a2 = SubElement(e, 'a') 1664 self.assertEquals( 1665 [a, a2], 1666 list(a.getiterator('a'))) 1667 self.assertEquals( 1668 [a2], 1669 list(c.getiterator('a')))

1670

1671 - def test_getiterator_filter_all(self):

1672 Element = self.etree.Element 1673 SubElement = self.etree.SubElement 1674 1675 a = Element('a') 1676 b = SubElement(a, 'b') 1677 c = SubElement(a, 'c') 1678 d = SubElement(b, 'd') 1679 e = SubElement(c, 'e') 1680 1681 self.assertEquals( 1682 [a, b, d, c, e], 1683 list(a.getiterator('*')))

1684

1685 - def test_getiterator_filter_comment(self):

1686 Element = self.etree.Element 1687 Comment = self.etree.Comment 1688 SubElement = self.etree.SubElement 1689 1690 a = Element('a') 1691 b = SubElement(a, 'b') 1692 comment_b = Comment("TEST-b") 1693 b.append(comment_b) 1694 1695 self.assertEquals( 1696 [comment_b], 1697 list(a.getiterator(Comment))) 1698 1699 comment_a = Comment("TEST-a") 1700 a.append(comment_a) 1701 1702 self.assertEquals( 1703 [comment_b, comment_a], 1704 list(a.getiterator(Comment))) 1705 1706 self.assertEquals( 1707 [comment_b], 1708 list(b.getiterator(Comment)))

1709

1710 - def test_getiterator_filter_pi(self):

1711 Element = self.etree.Element 1712 PI = self.etree.ProcessingInstruction 1713 SubElement = self.etree.SubElement 1714 1715 a = Element('a') 1716 b = SubElement(a, 'b') 1717 pi_b = PI("TEST-b") 1718 b.append(pi_b) 1719 1720 self.assertEquals( 1721 [pi_b], 1722 list(a.getiterator(PI))) 1723 1724 pi_a = PI("TEST-a") 1725 a.append(pi_a) 1726 1727 self.assertEquals( 1728 [pi_b, pi_a], 1729 list(a.getiterator(PI))) 1730 1731 self.assertEquals( 1732 [pi_b], 1733 list(b.getiterator(PI)))

1734

1735 - def test_getiterator_with_text(self):

1736 Element = self.etree.Element 1737 SubElement = self.etree.SubElement 1738 1739 a = Element('a') 1740 a.text = 'a' 1741 b = SubElement(a, 'b') 1742 b.text = 'b' 1743 b.tail = 'b1' 1744 c = SubElement(a, 'c') 1745 c.text = 'c' 1746 c.tail = 'c1' 1747 d = SubElement(b, 'd') 1748 c.text = 'd' 1749 c.tail = 'd1' 1750 e = SubElement(c, 'e') 1751 e.text = 'e' 1752 e.tail = 'e1' 1753 1754 self.assertEquals( 1755 [a, b, d, c, e], 1756 list(a.getiterator()))

1757 #self.assertEquals( 1758 # [d], 1759 # list(d.getiterator())) 1760

1761 - def test_getiterator_filter_with_text(self):

1762 Element = self.etree.Element 1763 SubElement = self.etree.SubElement 1764 1765 a = Element('a') 1766 a.text = 'a' 1767 b = SubElement(a, 'b') 1768 b.text = 'b' 1769 b.tail = 'b1' 1770 c = SubElement(a, 'c') 1771 c.text = 'c' 1772 c.tail = 'c1' 1773 d = SubElement(b, 'd') 1774 c.text = 'd' 1775 c.tail = 'd1' 1776 e = SubElement(c, 'e') 1777 e.text = 'e' 1778 e.tail = 'e1' 1779 1780 self.assertEquals( 1781 [a], 1782 list(a.getiterator('a'))) 1783 a2 = SubElement(e, 'a') 1784 self.assertEquals( 1785 [a, a2], 1786 list(a.getiterator('a'))) 1787 self.assertEquals( 1788 [a2], 1789 list(e.getiterator('a')))

1790

1791 - def test_attribute_manipulation(self):

1792 Element = self.etree.Element 1793 1794 a = Element('a') 1795 a.attrib['foo'] = 'Foo' 1796 a.attrib['bar'] = 'Bar' 1797 self.assertEquals('Foo', a.attrib['foo']) 1798 del a.attrib['foo'] 1799 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

1800

1801 - def test_getslice(self):

1802 Element = self.etree.Element 1803 SubElement = self.etree.SubElement 1804 1805 a = Element('a') 1806 b = SubElement(a, 'b') 1807 c = SubElement(a, 'c') 1808 d = SubElement(a, 'd') 1809 1810 self.assertEquals( 1811 [b, c], 1812 a[0:2]) 1813 self.assertEquals( 1814 [b, c, d], 1815 a[:]) 1816 self.assertEquals( 1817 [b, c, d], 1818 a[:10]) 1819 self.assertEquals( 1820 [b], 1821 a[0:1]) 1822 self.assertEquals( 1823 [], 1824 a[10:12])

1825

1826 - def test_getslice_negative(self):

1827 Element = self.etree.Element 1828 SubElement = self.etree.SubElement 1829 1830 a = Element('a') 1831 b = SubElement(a, 'b') 1832 c = SubElement(a, 'c') 1833 d = SubElement(a, 'd') 1834 1835 self.assertEquals( 1836 [d], 1837 a[-1:]) 1838 self.assertEquals( 1839 [c, d], 1840 a[-2:]) 1841 self.assertEquals( 1842 [c], 1843 a[-2:-1]) 1844 self.assertEquals( 1845 [b, c], 1846 a[-3:-1]) 1847 self.assertEquals( 1848 [b, c], 1849 a[-3:2])

1850

1851 - def test_getslice_step(self):

1852 Element = self.etree.Element 1853 SubElement = self.etree.SubElement 1854 1855 a = Element('a') 1856 b = SubElement(a, 'b') 1857 c = SubElement(a, 'c') 1858 d = SubElement(a, 'd') 1859 e = SubElement(a, 'e') 1860 1861 self.assertEquals( 1862 [e,d,c,b], 1863 a[::-1]) 1864 self.assertEquals( 1865 [b,d], 1866 a[::2]) 1867 self.assertEquals( 1868 [e,c], 1869 a[::-2]) 1870 self.assertEquals( 1871 [d,c], 1872 a[-2:0:-1]) 1873 self.assertEquals( 1874 [e], 1875 a[:1:-2])

1876

1877 - def test_getslice_text(self):

1878 ElementTree = self.etree.ElementTree 1879 1880 f = StringIO('<a>BB1<c>C</c>C1</a>') 1881 doc = ElementTree(file=f) 1882 a = doc.getroot() 1883 b = a[0] 1884 c = a[1] 1885 self.assertEquals( 1886 [b, c], 1887 a[:]) 1888 self.assertEquals( 1889 [b], 1890 a[0:1]) 1891 self.assertEquals( 1892 [c], 1893 a[1:])

1894

1895 - def test_comment_getitem_getslice(self):

1896 Element = self.etree.Element 1897 Comment = self.etree.Comment 1898 SubElement = self.etree.SubElement 1899 1900 a = Element('a') 1901 b = SubElement(a, 'b') 1902 foo = Comment('foo') 1903 a.append(foo) 1904 c = SubElement(a, 'c') 1905 self.assertEquals( 1906 [b, foo, c], 1907 a[:]) 1908 self.assertEquals( 1909 foo, 1910 a[1]) 1911 a[1] = new = Element('new') 1912 self.assertEquals( 1913 new, 1914 a[1]) 1915 self.assertXML( 1916 '<a><new></new><c></c></a>', 1917 a)

1918

1919 - def test_delslice(self):

1920 Element = self.etree.Element 1921 SubElement = self.etree.SubElement 1922 1923 a = Element('a') 1924 b = SubElement(a, 'b') 1925 c = SubElement(a, 'c') 1926 d = SubElement(a, 'd') 1927 e = SubElement(a, 'e') 1928 1929 del a[1:3] 1930 self.assertEquals( 1931 [b, e], 1932 list(a))

1933

1934 - def test_delslice_negative1(self):

1935 Element = self.etree.Element 1936 SubElement = self.etree.SubElement 1937 1938 a = Element('a') 1939 b = SubElement(a, 'b') 1940 c = SubElement(a, 'c') 1941 d = SubElement(a, 'd') 1942 e = SubElement(a, 'e') 1943 1944 del a[1:-1] 1945 self.assertEquals( 1946 [b, e], 1947 list(a))

1948

1949 - def test_delslice_negative2(self):

1950 Element = self.etree.Element 1951 SubElement = self.etree.SubElement 1952 1953 a = Element('a') 1954 b = SubElement(a, 'b') 1955 c = SubElement(a, 'c') 1956 d = SubElement(a, 'd') 1957 e = SubElement(a, 'e') 1958 1959 del a[-3:-1] 1960 self.assertEquals( 1961 [b, e], 1962 list(a))

1963

1964 - def test_delslice_step(self):

1965 Element = self.etree.Element 1966 SubElement = self.etree.SubElement 1967 1968 a = Element('a') 1969 b = SubElement(a, 'b') 1970 c = SubElement(a, 'c') 1971 d = SubElement(a, 'd') 1972 e = SubElement(a, 'e') 1973 1974 del a[1::2] 1975 self.assertEquals( 1976 [b, d], 1977 list(a))

1978

1979 - def test_delslice_step_negative(self):

1980 Element = self.etree.Element 1981 SubElement = self.etree.SubElement 1982 1983 a = Element('a') 1984 b = SubElement(a, 'b') 1985 c = SubElement(a, 'c') 1986 d = SubElement(a, 'd') 1987 e = SubElement(a, 'e') 1988 1989 del a[::-1] 1990 self.assertEquals( 1991 [], 1992 list(a))

1993

1994 - def test_delslice_step_negative2(self):

1995 Element = self.etree.Element 1996 SubElement = self.etree.SubElement 1997 1998 a = Element('a') 1999 b = SubElement(a, 'b') 2000 c = SubElement(a, 'c') 2001 d = SubElement(a, 'd') 2002 e = SubElement(a, 'e') 2003 2004 del a[::-2] 2005 self.assertEquals( 2006 [b, d], 2007 list(a))

2008

2009 - def test_delslice_child_tail(self):

2010 ElementTree = self.etree.ElementTree 2011 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2012 doc = ElementTree(file=f) 2013 a = doc.getroot() 2014 del a[1:3] 2015 self.assertXML( 2016 '<a>B2<e></e>E2</a>', 2017 a)

2018

2019 - def test_delslice_tail(self):

2020 XML = self.etree.XML 2021 a = XML('<a>B2<c></c>C2</a>') 2022 b, c = a 2023 2024 del a[:] 2025 2026 self.assertEquals("B2", b.tail) 2027 self.assertEquals("C2", c.tail)

2028

2029 - def test_delslice_memory(self):

2030 # this could trigger a crash 2031 Element = self.etree.Element 2032 SubElement = self.etree.SubElement 2033 a = Element('a') 2034 b = SubElement(a, 'b') 2035 c = SubElement(b, 'c') 2036 del b # no more reference to b 2037 del a[:] 2038 self.assertEquals('c', c.tag)

2039

2040 - def test_setslice(self):

2041 Element = self.etree.Element 2042 SubElement = self.etree.SubElement 2043 2044 a = Element('a') 2045 b = SubElement(a, 'b') 2046 c = SubElement(a, 'c') 2047 d = SubElement(a, 'd') 2048 2049 e = Element('e') 2050 f = Element('f') 2051 g = Element('g') 2052 2053 s = [e, f, g] 2054 a[1:2] = s 2055 self.assertEquals( 2056 [b, e, f, g, d], 2057 list(a))

2058

2059 - def test_setslice_all(self):

2060 Element = self.etree.Element 2061 SubElement = self.etree.SubElement 2062 2063 a = Element('a') 2064 b = SubElement(a, 'b') 2065 c = SubElement(a, 'c') 2066 2067 e = Element('e') 2068 f = Element('f') 2069 g = Element('g') 2070 2071 s = [e, f, g] 2072 a[:] = s 2073 self.assertEquals( 2074 [e, f, g], 2075 list(a))

2076

2077 - def test_setslice_all_empty(self):

2078 Element = self.etree.Element 2079 SubElement = self.etree.SubElement 2080 2081 a = Element('a') 2082 2083 e = Element('e') 2084 f = Element('f') 2085 g = Element('g') 2086 2087 s = [e, f, g] 2088 a[:] = s 2089 self.assertEquals( 2090 [e, f, g], 2091 list(a))

2092

2093 - def test_setslice_all_replace(self):

2094 Element = self.etree.Element 2095 SubElement = self.etree.SubElement 2096 2097 a = Element('a') 2098 b = SubElement(a, 'b') 2099 c = SubElement(a, 'c') 2100 d = SubElement(a, 'd') 2101 2102 s = [b, c, d] 2103 a[:] = s 2104 self.assertEquals( 2105 [b, c, d], 2106 list(a))

2107

2108 - def test_setslice_all_replace_reversed(self):

2109 Element = self.etree.Element 2110 SubElement = self.etree.SubElement 2111 2112 a = Element('a') 2113 b = SubElement(a, 'b') 2114 c = SubElement(a, 'c') 2115 d = SubElement(a, 'd') 2116 2117 s = [d, c, b] 2118 a[:] = s 2119 self.assertEquals( 2120 [d, c, b], 2121 list(a))

2122

2123 - def test_setslice_all_replace_reversed_ns1(self):

2124 Element = self.etree.Element 2125 SubElement = self.etree.SubElement 2126 2127 a = Element('{ns}a') 2128 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2129 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2130 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2131 2132 s = [d, c, b] 2133 a[:] = s 2134 self.assertEquals( 2135 [d, c, b], 2136 list(a)) 2137 self.assertEquals( 2138 ['{ns}d', '{ns}c', '{ns}b'], 2139 [ child.tag for child in a ]) 2140 2141 self.assertEquals( 2142 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2143 [ child.attrib.keys() for child in a ])

2144

2145 - def test_setslice_all_replace_reversed_ns2(self):

2146 Element = self.etree.Element 2147 SubElement = self.etree.SubElement 2148 2149 a = Element('{ns}a') 2150 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 2151 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 2152 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 2153 2154 s = [d, c, b] 2155 a[:] = s 2156 self.assertEquals( 2157 [d, c, b], 2158 list(a)) 2159 self.assertEquals( 2160 ['{ns3}d', '{ns2}c', '{ns1}b'], 2161 [ child.tag for child in a ]) 2162 2163 self.assertEquals( 2164 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 2165 [ child.attrib.keys() for child in a ])

2166

2167 - def test_setslice_end(self):

2168 Element = self.etree.Element 2169 SubElement = self.etree.SubElement 2170 2171 a = Element('a') 2172 b = SubElement(a, 'b') 2173 c = SubElement(a, 'c') 2174 2175 e = Element('e') 2176 f = Element('f') 2177 g = Element('g') 2178 h = Element('h') 2179 2180 s = [e, f] 2181 a[99:] = s 2182 self.assertEquals( 2183 [a, b, e, f], 2184 list(a)) 2185 2186 s = [g, h] 2187 a[:0] = s 2188 self.assertEquals( 2189 [g, h, a, b, e, f], 2190 list(a))

2191

2192 - def test_setslice_single(self):

2193 Element = self.etree.Element 2194 SubElement = self.etree.SubElement 2195 2196 a = Element('a') 2197 b = SubElement(a, 'b') 2198 c = SubElement(a, 'c') 2199 2200 e = Element('e') 2201 f = Element('f') 2202 2203 s = [e] 2204 a[0:1] = s 2205 self.assertEquals( 2206 [e, c], 2207 list(a)) 2208 2209 s = [f] 2210 a[1:2] = s 2211 self.assertEquals( 2212 [e, f], 2213 list(a))

2214

2215 - def test_setslice_tail(self):

2216 ElementTree = self.etree.ElementTree 2217 Element = self.etree.Element 2218 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2219 doc = ElementTree(file=f) 2220 a = doc.getroot() 2221 x = Element('x') 2222 y = Element('y') 2223 z = Element('z') 2224 x.tail = 'X2' 2225 y.tail = 'Y2' 2226 z.tail = 'Z2' 2227 a[1:3] = [x, y, z] 2228 self.assertXML( 2229 '<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>', 2230 a)

2231

2232 - def test_setslice_negative(self):

2233 Element = self.etree.Element 2234 SubElement = self.etree.SubElement 2235 2236 a = Element('a') 2237 b = SubElement(a, 'b') 2238 c = SubElement(a, 'c') 2239 d = SubElement(a, 'd') 2240 2241 x = Element('x') 2242 y = Element('y') 2243 2244 a[1:-1] = [x, y] 2245 self.assertEquals( 2246 [b, x, y, d], 2247 list(a))

2248

2249 - def test_setslice_negative2(self):

2250 Element = self.etree.Element 2251 SubElement = self.etree.SubElement 2252 2253 a = Element('a') 2254 b = SubElement(a, 'b') 2255 c = SubElement(a, 'c') 2256 d = SubElement(a, 'd') 2257 2258 x = Element('x') 2259 y = Element('y') 2260 2261 a[1:-2] = [x, y] 2262 self.assertEquals( 2263 [b, x, y, c, d], 2264 list(a))

2265

2266 - def test_setslice_end(self):

2267 Element = self.etree.Element 2268 SubElement = self.etree.SubElement 2269 2270 a = Element('a') 2271 b = SubElement(a, 'b') 2272 c = SubElement(a, 'c') 2273 d = SubElement(a, 'd') 2274 2275 e = Element('e') 2276 f = Element('f') 2277 g = Element('g') 2278 2279 s = [e, f, g] 2280 a[3:] = s 2281 self.assertEquals( 2282 [b, c, d, e, f, g], 2283 list(a))

2284

2285 - def test_setslice_empty(self):

2286 Element = self.etree.Element 2287 2288 a = Element('a') 2289 2290 b = Element('b') 2291 c = Element('c') 2292 2293 a[:] = [b, c] 2294 self.assertEquals( 2295 [b, c], 2296 list(a))

2297

2298 - def test_tail_elementtree_root(self):

2299 Element = self.etree.Element 2300 ElementTree = self.etree.ElementTree 2301 2302 a = Element('a') 2303 a.tail = 'A2' 2304 t = ElementTree(element=a) 2305 self.assertEquals('A2', 2306 a.tail)

2307

2308 - def test_elementtree_getiterator(self):

2309 Element = self.etree.Element 2310 SubElement = self.etree.SubElement 2311 ElementTree = self.etree.ElementTree 2312 2313 a = Element('a') 2314 b = SubElement(a, 'b') 2315 c = SubElement(a, 'c') 2316 d = SubElement(b, 'd') 2317 e = SubElement(c, 'e') 2318 t = ElementTree(element=a) 2319 2320 self.assertEquals( 2321 [a, b, d, c, e], 2322 list(t.getiterator()))

2323

2324 - def test_elementtree_getiterator_filter(self):

2325 Element = self.etree.Element 2326 SubElement = self.etree.SubElement 2327 ElementTree = self.etree.ElementTree 2328 a = Element('a') 2329 b = SubElement(a, 'b') 2330 c = SubElement(a, 'c') 2331 d = SubElement(b, 'd') 2332 e = SubElement(c, 'e') 2333 t = ElementTree(element=a) 2334 2335 self.assertEquals( 2336 [a], 2337 list(t.getiterator('a'))) 2338 a2 = SubElement(e, 'a') 2339 self.assertEquals( 2340 [a, a2], 2341 list(t.getiterator('a')))

2342

2343 - def test_ns_access(self):

2344 ElementTree = self.etree.ElementTree 2345 ns = 'http://xml.infrae.com/1' 2346 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2347 t = ElementTree(file=f) 2348 a = t.getroot() 2349 self.assertEquals('{%s}a' % ns, 2350 a.tag) 2351 self.assertEquals('{%s}b' % ns, 2352 a[0].tag)

2353

2354 - def test_ns_access2(self):

2355 ElementTree = self.etree.ElementTree 2356 ns = 'http://xml.infrae.com/1' 2357 ns2 = 'http://xml.infrae.com/2' 2358 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2359 t = ElementTree(file=f) 2360 a = t.getroot() 2361 self.assertEquals('{%s}a' % ns, 2362 a.tag) 2363 self.assertEquals('{%s}b' % ns, 2364 a[0].tag) 2365 self.assertEquals('{%s}b' % ns2, 2366 a[1].tag)

2367

2368 - def test_ns_setting(self):

2369 Element = self.etree.Element 2370 SubElement = self.etree.SubElement 2371 ns = 'http://xml.infrae.com/1' 2372 ns2 = 'http://xml.infrae.com/2' 2373 a = Element('{%s}a' % ns) 2374 b = SubElement(a, '{%s}b' % ns2) 2375 c = SubElement(a, '{%s}c' % ns) 2376 self.assertEquals('{%s}a' % ns, 2377 a.tag) 2378 self.assertEquals('{%s}b' % ns2, 2379 b.tag) 2380 self.assertEquals('{%s}c' % ns, 2381 c.tag) 2382 self.assertEquals('{%s}a' % ns, 2383 a.tag) 2384 self.assertEquals('{%s}b' % ns2, 2385 b.tag) 2386 self.assertEquals('{%s}c' % ns, 2387 c.tag)

2388

2389 - def test_ns_tag_parse(self):

2390 Element = self.etree.Element 2391 SubElement = self.etree.SubElement 2392 ElementTree = self.etree.ElementTree 2393 2394 ns = 'http://xml.infrae.com/1' 2395 ns2 = 'http://xml.infrae.com/2' 2396 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2397 t = ElementTree(file=f) 2398 2399 a = t.getroot() 2400 self.assertEquals('{%s}a' % ns, 2401 a.tag) 2402 self.assertEquals('{%s}b' % ns2, 2403 a[0].tag) 2404 self.assertEquals('{%s}b' % ns, 2405 a[1].tag)

2406

2407 - def test_ns_attr(self):

2408 Element = self.etree.Element 2409 ns = 'http://xml.infrae.com/1' 2410 ns2 = 'http://xml.infrae.com/2' 2411 a = Element('a') 2412 a.set('{%s}foo' % ns, 'Foo') 2413 a.set('{%s}bar' % ns2, 'Bar') 2414 self.assertEquals( 2415 'Foo', 2416 a.get('{%s}foo' % ns)) 2417 self.assertEquals( 2418 'Bar', 2419 a.get('{%s}bar' % ns2)) 2420 try: 2421 self.assertXML( 2422 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2), 2423 a) 2424 except AssertionError: 2425 self.assertXML( 2426 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns), 2427 a)

2428

2429 - def test_ns_move(self):

2430 Element = self.etree.Element 2431 ElementTree = self.etree.ElementTree 2432 2433 one = self.etree.parse( 2434 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2435 baz = one.getroot()[0][0] 2436 2437 two = ElementTree(Element('root')) 2438 two.getroot().append(baz) 2439 # removing the originating document could cause a crash/error before 2440 # as namespace is not moved along with it 2441 del one 2442 self.assertEquals('{http://a.b.c}baz', baz.tag)

2443

2444 - def test_ns_decl_tostring(self):

2445 tostring = self.etree.tostring 2446 root = self.etree.XML( 2447 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>') 2448 baz = root[0][0] 2449 2450 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2451 tostring(baz)) 2452 self.assertEquals(["http://a.b.c"], nsdecl)

2453

2454 - def test_ns_decl_tostring_default(self):

2455 tostring = self.etree.tostring 2456 root = self.etree.XML( 2457 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>') 2458 baz = root[0][0] 2459 2460 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2461 tostring(baz)) 2462 self.assertEquals(["http://a.b.c"], nsdecl)

2463

2464 - def test_ns_decl_tostring_root(self):

2465 tostring = self.etree.tostring 2466 root = self.etree.XML( 2467 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>') 2468 baz = root[0][0] 2469 2470 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2471 tostring(baz)) 2472 2473 self.assertEquals(["http://a.b.c"], nsdecl)

2474

2475 - def test_ns_decl_tostring_element(self):

2476 Element = self.etree.Element 2477 SubElement = self.etree.SubElement 2478 2479 root = Element("foo") 2480 bar = SubElement(root, "{http://a.b.c}bar") 2481 baz = SubElement(bar, "{http://a.b.c}baz") 2482 2483 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2484 self.etree.tostring(baz)) 2485 2486 self.assertEquals(["http://a.b.c"], nsdecl)

2487

2488 - def test_attribute_xmlns_move(self):

2489 Element = self.etree.Element 2490 2491 root = Element('element') 2492 2493 subelement = Element('subelement', 2494 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2495 self.assertEquals(1, len(subelement.attrib)) 2496 self.assertEquals( 2497 "foo", 2498 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2499 2500 root.append(subelement) 2501 self.assertEquals(1, len(subelement.attrib)) 2502 self.assertEquals( 2503 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(), 2504 subelement.attrib.items()) 2505 self.assertEquals( 2506 "foo", 2507 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2508

2509 - def test_namespaces_after_serialize(self):

2510 parse = self.etree.parse 2511 tostring = self.etree.tostring 2512 2513 ns_href = "http://a.b.c" 2514 one = parse( 2515 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2516 baz = one.getroot()[0][0] 2517 2518 parsed = parse(StringIO( tostring(baz) )).getroot() 2519 self.assertEquals('{%s}baz' % ns_href, parsed.tag)

2520

2521 - def test_tostring(self):

2522 tostring = self.etree.tostring 2523 Element = self.etree.Element 2524 SubElement = self.etree.SubElement 2525 2526 a = Element('a') 2527 b = SubElement(a, 'b') 2528 c = SubElement(a, 'c') 2529 2530 self.assertEquals('<a><c></c></a>', 2531 canonicalize(tostring(a)))

2532

2533 - def test_tostring_element(self):

2534 tostring = self.etree.tostring 2535 Element = self.etree.Element 2536 SubElement = self.etree.SubElement 2537 2538 a = Element('a') 2539 b = SubElement(a, 'b') 2540 c = SubElement(a, 'c') 2541 d = SubElement(c, 'd') 2542 self.assertEquals('', 2543 canonicalize(tostring(b))) 2544 self.assertEquals('<c><d></d></c>', 2545 canonicalize(tostring(c)))

2546

2547 - def test_tostring_element_tail(self):

2548 tostring = self.etree.tostring 2549 Element = self.etree.Element 2550 SubElement = self.etree.SubElement 2551 2552 a = Element('a') 2553 b = SubElement(a, 'b') 2554 c = SubElement(a, 'c') 2555 d = SubElement(c, 'd') 2556 b.tail = 'Foo' 2557 2558 self.assert_(tostring(b) == 'Foo' or 2559 tostring(b) == 'Foo')

2560

2561 - def test_tostring_method_html(self):

2562 tostring = self.etree.tostring 2563 Element = self.etree.Element 2564 SubElement = self.etree.SubElement 2565 2566 html = Element('html') 2567 body = SubElement(html, 'body') 2568 p = SubElement(body, 'p') 2569 p.text = "html" 2570 SubElement(p, 'br').tail = "test" 2571 2572 self.assertEquals('<html><body>html test</body></html>', 2573 tostring(html, method="html"))

2574

2575 - def test_tostring_method_text(self):

2576 tostring = self.etree.tostring 2577 Element = self.etree.Element 2578 SubElement = self.etree.SubElement 2579 2580 a = Element('a') 2581 a.text = "A" 2582 a.tail = "tail" 2583 b = SubElement(a, 'b') 2584 b.text = "B" 2585 b.tail = "TAIL" 2586 c = SubElement(a, 'c') 2587 c.text = "C" 2588 2589 self.assertEquals('ABTAILCtail', 2590 tostring(a, method="text"))

2591

2592 - def test_iterparse(self):

2593 iterparse = self.etree.iterparse 2594 f = StringIO('<a><c/></a>') 2595 2596 iterator = iterparse(f) 2597 self.assertEquals(None, 2598 iterator.root) 2599 events = list(iterator) 2600 root = iterator.root 2601 self.assertEquals( 2602 [('end', root[0]), ('end', root[1]), ('end', root)], 2603 events)

2604

2605 - def test_iterparse_file(self):

2606 iterparse = self.etree.iterparse 2607 iterator = iterparse(fileInTestDir("test.xml")) 2608 self.assertEquals(None, 2609 iterator.root) 2610 events = list(iterator) 2611 root = iterator.root 2612 self.assertEquals( 2613 [('end', root[0]), ('end', root)], 2614 events)

2615

2616 - def test_iterparse_start(self):

2617 iterparse = self.etree.iterparse 2618 f = StringIO('<a><c/></a>') 2619 2620 iterator = iterparse(f, events=('start',)) 2621 events = list(iterator) 2622 root = iterator.root 2623 self.assertEquals( 2624 [('start', root), ('start', root[0]), ('start', root[1])], 2625 events)

2626

2627 - def test_iterparse_start_end(self):

2628 iterparse = self.etree.iterparse 2629 f = StringIO('<a><c/></a>') 2630 2631 iterator = iterparse(f, events=('start','end')) 2632 events = list(iterator) 2633 root = iterator.root 2634 self.assertEquals( 2635 [('start', root), ('start', root[0]), ('end', root[0]), 2636 ('start', root[1]), ('end', root[1]), ('end', root)], 2637 events)

2638

2639 - def test_iterparse_clear(self):

2640 iterparse = self.etree.iterparse 2641 f = StringIO('<a><c/></a>') 2642 2643 iterator = iterparse(f) 2644 for event, elem in iterator: 2645 elem.clear() 2646 2647 root = iterator.root 2648 self.assertEquals(0, 2649 len(root))

2650

2651 - def test_iterparse_large(self):

2652 iterparse = self.etree.iterparse 2653 CHILD_COUNT = 12345 2654 f = StringIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2655 2656 i = 0 2657 for key in iterparse(f): 2658 event, element = key 2659 i += 1 2660 self.assertEquals(i, CHILD_COUNT + 1)

2661

2662 - def test_iterparse_attrib_ns(self):

2663 iterparse = self.etree.iterparse 2664 f = StringIO('<a xmlns="ns1"><c xmlns="ns2"/></a>') 2665 2666 attr_name = '{testns}bla' 2667 events = [] 2668 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2669 for event, elem in iterator: 2670 events.append(event) 2671 if event == 'start': 2672 if elem.tag != '{ns1}a': 2673 elem.set(attr_name, 'value') 2674 2675 self.assertEquals( 2676 ['start-ns', 'start', 'start', 'start-ns', 'start', 2677 'end', 'end-ns', 'end', 'end', 'end-ns'], 2678 events) 2679 2680 root = iterator.root 2681 self.assertEquals( 2682 None, 2683 root.get(attr_name)) 2684 self.assertEquals( 2685 'value', 2686 root[0].get(attr_name))

2687

2688 - def test_iterparse_getiterator(self):

2689 iterparse = self.etree.iterparse 2690 f = StringIO('<a><d/><c/></a>') 2691 2692 counts = [] 2693 for event, elem in iterparse(f): 2694 counts.append(len(list(elem.getiterator()))) 2695 self.assertEquals( 2696 [1,2,1,4], 2697 counts)

2698

2699 - def test_parse_file(self):

2700 parse = self.etree.parse 2701 # from file 2702 tree = parse(fileInTestDir('test.xml')) 2703 self.assertXML( 2704 '<a></a>', 2705 tree.getroot())

2706

2707 - def test_parse_file_nonexistent(self):

2708 parse = self.etree.parse 2709 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2710

2711 - def test_parse_error_none(self):

2712 parse = self.etree.parse 2713 self.assertRaises(TypeError, parse, None)

2714

2715 - def test_parse_error(self):

2716 # ET < 1.3 raises ExpatError 2717 parse = self.etree.parse 2718 f = StringIO('<a></c></a>') 2719 self.assertRaises(SyntaxError, parse, f) 2720 f.close()

2721

2722 - def test_parse_error_from_file(self):

2723 parse = self.etree.parse 2724 # from file 2725 f = open(fileInTestDir('test_broken.xml'), 'r') 2726 self.assertRaises(SyntaxError, parse, f) 2727 f.close()

2728

2729 - def test_parse_file_object(self):

2730 parse = self.etree.parse 2731 # from file object 2732 f = open(fileInTestDir('test.xml'), 'r') 2733 tree = parse(f) 2734 f.close() 2735 self.assertXML( 2736 '<a></a>', 2737 tree.getroot())

2738

2739 - def test_parse_stringio(self):

2740 parse = self.etree.parse 2741 # from StringIO 2742 f = StringIO('<a></a>') 2743 tree = parse(f) 2744 f.close() 2745 self.assertXML( 2746 '<a></a>', 2747 tree.getroot() 2748 )

2749

2750 - def test_parse_with_encoding(self):

2751 # this can fail in libxml2 <= 2.6.22 2752 parse = self.etree.parse 2753 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2754 self.assertXML('<html></html>', 2755 tree.getroot())

2756

2757 - def test_encoding(self):

2758 Element = self.etree.Element 2759 2760 a = Element('a') 2761 a.text = u'Søk på nettet' 2762 self.assertXML( 2763 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2764 a, 'utf-8')

2765

2766 - def test_encoding_exact(self):

2767 ElementTree = self.etree.ElementTree 2768 Element = self.etree.Element 2769 2770 a = Element('a') 2771 a.text = u'Søk på nettet' 2772 2773 f = StringIO() 2774 tree = ElementTree(element=a) 2775 tree.write(f, encoding='utf-8') 2776 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2777 f.getvalue().replace('\n',''))

2778

2779 - def test_parse_file_encoding(self):

2780 parse = self.etree.parse 2781 # from file 2782 tree = parse(fileInTestDir('test-string.xml')) 2783 self.assertXML( 2784 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2785 tree.getroot(), 'UTF-8')

2786

2787 - def test_parse_file_object_encoding(self):

2788 parse = self.etree.parse 2789 # from file object 2790 f = open(fileInTestDir('test-string.xml'), 'r') 2791 tree = parse(f) 2792 f.close() 2793 self.assertXML( 2794 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2795 tree.getroot(), 'UTF-8')

2796

2797 - def test_encoding_8bit_latin1(self):

2798 ElementTree = self.etree.ElementTree 2799 Element = self.etree.Element 2800 2801 a = Element('a') 2802 a.text = u'Søk på nettet' 2803 2804 f = StringIO() 2805 tree = ElementTree(element=a) 2806 tree.write(f, encoding='iso-8859-1') 2807 result = f.getvalue() 2808 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2809 self.assertEncodingDeclaration(result,'iso-8859-1') 2810 result = result.split('?>', 1)[-1].replace('\n','') 2811 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2812 result)

2813

2814 - def test_parse_encoding_8bit_explicit(self):

2815 XMLParser = self.etree.XMLParser 2816 2817 text = u'Søk på nettet' 2818 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1') 2819 2820 self.assertRaises(self.etree.ParseError, 2821 self.etree.parse, 2822 StringIO(xml_latin1)) 2823 2824 tree = self.etree.parse(StringIO(xml_latin1), 2825 XMLParser(encoding="iso-8859-1")) 2826 a = tree.getroot() 2827 self.assertEquals(a.text, text)

2828

2829 - def test_parse_encoding_8bit_override(self):

2830 XMLParser = self.etree.XMLParser 2831 2832 text = u'Søk på nettet' 2833 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 2834 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 2835 ).encode('iso-8859-1') 2836 2837 self.assertRaises(self.etree.ParseError, 2838 self.etree.parse, 2839 StringIO(xml_latin1)) 2840 2841 tree = self.etree.parse(StringIO(xml_latin1), 2842 XMLParser(encoding="iso-8859-1")) 2843 a = tree.getroot() 2844 self.assertEquals(a.text, text)

2845

2846 - def _test_wrong_unicode_encoding(self):

2847 # raise error on wrong encoding declaration in unicode strings 2848 XML = self.etree.XML 2849 test_utf = (u'<?xml version="1.0" encoding="iso-8859-1"?>' + \ 2850 u'<a>Søk på nettet</a>') 2851 self.assertRaises(SyntaxError, XML, test_utf)

2852

2853 - def test_encoding_write_default_encoding(self):

2854 ElementTree = self.etree.ElementTree 2855 Element = self.etree.Element 2856 2857 a = Element('a') 2858 a.text = u'Søk på nettet' 2859 2860 f = StringIO() 2861 tree = ElementTree(element=a) 2862 tree.write(f) 2863 data = f.getvalue().replace('\n','') 2864 self.assertEquals( 2865 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2866 data)

2867

2868 - def test_encoding_tostring(self):

2869 Element = self.etree.Element 2870 tostring = self.etree.tostring 2871 2872 a = Element('a') 2873 a.text = u'Søk på nettet' 2874 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2875 tostring(a, encoding='utf-8'))

2876

2877 - def test_encoding_tostring_unknown(self):

2878 Element = self.etree.Element 2879 tostring = self.etree.tostring 2880 2881 a = Element('a') 2882 a.text = u'Søk på nettet' 2883 self.assertRaises(LookupError, tostring, a, 2884 encoding='Invalid Encoding')

2885

2886 - def test_encoding_tostring_sub(self):

2887 Element = self.etree.Element 2888 SubElement = self.etree.SubElement 2889 tostring = self.etree.tostring 2890 2891 a = Element('a') 2892 b = SubElement(a, 'b') 2893 b.text = u'Søk på nettet' 2894 self.assertEquals(u'Søk på nettet'.encode('UTF-8'), 2895 tostring(b, encoding='utf-8'))

2896

2897 - def test_encoding_tostring_sub_tail(self):

2898 Element = self.etree.Element 2899 SubElement = self.etree.SubElement 2900 tostring = self.etree.tostring 2901 2902 a = Element('a') 2903 b = SubElement(a, 'b') 2904 b.text = u'Søk på nettet' 2905 b.tail = u'Søk' 2906 self.assertEquals(u'Søk på nettetSøk'.encode('UTF-8'), 2907 tostring(b, encoding='utf-8'))

2908

2909 - def test_encoding_tostring_default_encoding(self):

2910 Element = self.etree.Element 2911 SubElement = self.etree.SubElement 2912 tostring = self.etree.tostring 2913 2914 a = Element('a') 2915 a.text = u'Søk på nettet' 2916 2917 expected = '<a>Søk på nettet</a>' 2918 self.assertEquals( 2919 expected, 2920 tostring(a))

2921

2922 - def test_encoding_sub_tostring_default_encoding(self):

2923 Element = self.etree.Element 2924 SubElement = self.etree.SubElement 2925 tostring = self.etree.tostring 2926 2927 a = Element('a') 2928 b = SubElement(a, 'b') 2929 b.text = u'Søk på nettet' 2930 2931 expected = 'Søk på nettet' 2932 self.assertEquals( 2933 expected, 2934 tostring(b))

2935

2936 - def test_encoding_8bit_xml(self):

2937 utext = u'Søk på nettet' 2938 uxml = u'%s' % utext 2939 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2940 isoxml = prologue + uxml.encode('iso-8859-1') 2941 tree = self.etree.XML(isoxml) 2942 self.assertEquals(utext, tree.text)

2943

2944 - def test_encoding_utf8_bom(self):

2945 utext = u'Søk på nettet' 2946 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \ 2947 u'%s' % utext 2948 bom = '\xEF\xBB\xBF' 2949 xml = bom + uxml.encode("utf-8") 2950 tree = etree.XML(xml) 2951 self.assertEquals(utext, tree.text)

2952

2953 - def test_encoding_8bit_parse_stringio(self):

2954 utext = u'Søk på nettet' 2955 uxml = u'%s' % utext 2956 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2957 isoxml = prologue + uxml.encode('iso-8859-1') 2958 el = self.etree.parse(StringIO(isoxml)).getroot() 2959 self.assertEquals(utext, el.text)

2960

2961 - def test_deepcopy_elementtree(self):

2962 Element = self.etree.Element 2963 ElementTree = self.etree.ElementTree 2964 2965 a = Element('a') 2966 a.text = "Foo" 2967 atree = ElementTree(a) 2968 2969 btree = copy.deepcopy(atree) 2970 self.assertEqual("Foo", atree.getroot().text) 2971 self.assertEqual("Foo", btree.getroot().text) 2972 self.assertFalse(btree is atree) 2973 self.assertFalse(btree.getroot() is atree.getroot())

2974

2975 - def test_deepcopy(self):

2976 Element = self.etree.Element 2977 2978 a = Element('a') 2979 a.text = 'Foo' 2980 2981 b = copy.deepcopy(a) 2982 self.assertEquals('Foo', b.text) 2983 2984 b.text = 'Bar' 2985 self.assertEquals('Bar', b.text) 2986 self.assertEquals('Foo', a.text) 2987 2988 del a 2989 self.assertEquals('Bar', b.text)

2990

2991 - def test_deepcopy_tail(self):

2992 Element = self.etree.Element 2993 2994 a = Element('a') 2995 a.tail = 'Foo' 2996 2997 b = copy.deepcopy(a) 2998 self.assertEquals('Foo', b.tail) 2999 3000 b.tail = 'Bar' 3001 self.assertEquals('Bar', b.tail) 3002 self.assertEquals('Foo', a.tail) 3003 3004 del a 3005 self.assertEquals('Bar', b.tail)

3006

3007 - def test_deepcopy_subelement(self):

3008 Element = self.etree.Element 3009 SubElement = self.etree.SubElement 3010 3011 root = Element('root') 3012 a = SubElement(root, 'a') 3013 a.text = 'FooText' 3014 a.tail = 'FooTail' 3015 3016 b = copy.deepcopy(a) 3017 self.assertEquals('FooText', b.text) 3018 self.assertEquals('FooTail', b.tail) 3019 3020 b.text = 'BarText' 3021 b.tail = 'BarTail' 3022 self.assertEquals('BarTail', b.tail) 3023 self.assertEquals('FooTail', a.tail) 3024 self.assertEquals('BarText', b.text) 3025 self.assertEquals('FooText', a.text) 3026 3027 del a 3028 self.assertEquals('BarTail', b.tail) 3029 self.assertEquals('BarText', b.text)

3030

3031 - def test_deepcopy_namespaces(self):

3032 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 3033 <parent><node t:foo="bar" /></parent> 3034 </doc>''') 3035 self.assertEquals( 3036 root[0][0].get('{tns}foo'), 3037 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3038 self.assertEquals( 3039 root[0][0].get('{tns}foo'), 3040 copy.deepcopy(root[0][0]).get('{tns}foo') )

3041

3042 - def test_deepcopy_append(self):

3043 # previously caused a crash 3044 Element = self.etree.Element 3045 tostring = self.etree.tostring 3046 3047 a = Element('a') 3048 b = copy.deepcopy(a) 3049 a.append( Element('C') ) 3050 b.append( Element('X') ) 3051 3052 self.assertEquals('<a><C/></a>', 3053 tostring(a).replace(' ', '')) 3054 self.assertEquals('<a><X/></a>', 3055 tostring(b).replace(' ', ''))

3056

3057 - def test_deepcopy_comment(self):

3058 # previously caused a crash 3059 # not supported by ET < 1.3! 3060 Comment = self.etree.Comment 3061 3062 a = Comment("ONE") 3063 b = copy.deepcopy(a) 3064 b.text = "ANOTHER" 3065 3066 self.assertEquals('ONE', a.text) 3067 self.assertEquals('ANOTHER', b.text)

3068

3069 - def test_shallowcopy(self):

3070 Element = self.etree.Element 3071 3072 a = Element('a') 3073 a.text = 'Foo' 3074 3075 b = copy.copy(a) 3076 self.assertEquals('Foo', b.text) 3077 3078 b.text = 'Bar' 3079 self.assertEquals('Bar', b.text) 3080 self.assertEquals('Foo', a.text)

3081 # XXX ElementTree will share nodes, but lxml.etree won't.. 3082

3083 - def test_shallowcopy_elementtree(self):

3084 Element = self.etree.Element 3085 ElementTree = self.etree.ElementTree 3086 3087 a = Element('a') 3088 a.text = 'Foo' 3089 atree = ElementTree(a) 3090 3091 btree = copy.copy(atree) 3092 self.assertFalse(btree is atree) 3093 self.assert_(btree.getroot() is atree.getroot()) 3094 self.assertEquals('Foo', atree.getroot().text)

3095

3096 - def _test_element_boolean(self):

3097 # deprecated as of ET 1.3/lxml 2.0 3098 etree = self.etree 3099 e = etree.Element('foo') 3100 self.assertEquals(False, bool(e)) 3101 etree.SubElement(e, 'bar') 3102 self.assertEquals(True, bool(e)) 3103 e = etree.Element('foo') 3104 e.text = 'hey' 3105 self.assertEquals(False, bool(e)) 3106 e = etree.Element('foo') 3107 e.tail = 'bar' 3108 self.assertEquals(False, bool(e)) 3109 e = etree.Element('foo') 3110 e.set('bar', 'Bar') 3111 self.assertEquals(False, bool(e))

3112

3113 - def test_multiple_elementrees(self):

3114 etree = self.etree 3115 3116 a = etree.Element('a') 3117 b = etree.SubElement(a, 'b') 3118 3119 t = etree.ElementTree(a) 3120 self.assertEquals(self._rootstring(t), '<a></a>') 3121 3122 t1 = etree.ElementTree(a) 3123 self.assertEquals(self._rootstring(t1), '<a></a>') 3124 self.assertEquals(self._rootstring(t), '<a></a>') 3125 3126 t2 = etree.ElementTree(b) 3127 self.assertEquals(self._rootstring(t2), '') 3128 self.assertEquals(self._rootstring(t1), '<a></a>') 3129 self.assertEquals(self._rootstring(t), '<a></a>')

3130

3131 - def test_qname(self):

3132 etree = self.etree 3133 qname = etree.QName('myns', 'a') 3134 a1 = etree.Element(qname) 3135 a2 = etree.SubElement(a1, qname) 3136 self.assertEquals(a1.tag, "{myns}a") 3137 self.assertEquals(a2.tag, "{myns}a")

3138

3139 - def test_qname_cmp(self):

3140 etree = self.etree 3141 qname1 = etree.QName('myns', 'a') 3142 qname2 = etree.QName('myns', 'a') 3143 self.assertEquals(qname1, "{myns}a") 3144 self.assertEquals("{myns}a", qname2) 3145 self.assertEquals(qname1, qname1) 3146 self.assertEquals(qname1, qname2)

3147

3148 - def test_qname_attribute_getset(self):

3149 etree = self.etree 3150 qname = etree.QName('myns', 'a') 3151 3152 a = etree.Element(qname) 3153 a.set(qname, "value") 3154 3155 self.assertEquals(a.get(qname), "value") 3156 self.assertEquals(a.get("{myns}a"), "value")

3157

3158 - def test_qname_attrib(self):

3159 etree = self.etree 3160 qname = etree.QName('myns', 'a') 3161 3162 a = etree.Element(qname) 3163 a.attrib[qname] = "value" 3164 3165 self.assertEquals(a.attrib[qname], "value") 3166 self.assertEquals(a.attrib.get(qname), "value") 3167 3168 self.assertEquals(a.attrib["{myns}a"], "value") 3169 self.assertEquals(a.attrib.get("{myns}a"), "value")

3170

3171 - def test_qname_attribute_resolve(self):

3172 etree = self.etree 3173 qname = etree.QName('http://myns', 'a') 3174 a = etree.Element(qname) 3175 a.set(qname, qname) 3176 3177 self.assertXML( 3178 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3179 a)

3180

3181 - def test_qname_attribute_resolve_new(self):

3182 etree = self.etree 3183 qname = etree.QName('http://myns', 'a') 3184 a = etree.Element('a') 3185 a.set('a', qname) 3186 3187 self.assertXML( 3188 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 3189 a)

3190

3191 - def test_qname_attrib_resolve(self):

3192 etree = self.etree 3193 qname = etree.QName('http://myns', 'a') 3194 a = etree.Element(qname) 3195 a.attrib[qname] = qname 3196 3197 self.assertXML( 3198 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3199 a)

3200

3201 - def test_parser_version(self):

3202 etree = self.etree 3203 parser = etree.XMLParser() 3204 if hasattr(parser, "version"): 3205 # ElementTree 1.3+, cET 3206 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

3207 3208 # feed parser interface 3209

3210 - def test_feed_parser(self):

3211 parser = self.etree.XMLParser() 3212 3213 parser.feed('<?xml version=') 3214 parser.feed('"1.0"?><ro') 3215 parser.feed('ot><') 3216 parser.feed('a test="works"/') 3217 parser.feed('></root') 3218 parser.feed('>') 3219 3220 root = parser.close() 3221 3222 self.assertEquals(root.tag, "root") 3223 self.assertEquals(root[0].tag, "a") 3224 self.assertEquals(root[0].get("test"), "works")

3225

3226 - def test_feed_parser_error_close_empty(self):

3227 ParseError = self.etree.ParseError 3228 parser = self.etree.XMLParser() 3229 self.assertRaises(ParseError, parser.close)

3230

3231 - def test_feed_parser_error_close_incomplete(self):

3232 ParseError = self.etree.ParseError 3233 parser = self.etree.XMLParser() 3234 3235 parser.feed('<?xml version=') 3236 parser.feed('"1.0"?><ro') 3237 3238 self.assertRaises(ParseError, parser.close)

3239

3240 - def test_feed_parser_error_broken(self):

3241 ParseError = self.etree.ParseError 3242 parser = self.etree.XMLParser() 3243 3244 parser.feed('<?xml version=') 3245 parser.feed('"1.0"?><ro') 3246 try: 3247 parser.feed('<><><><><><><') 3248 except ParseError: 3249 # can raise, but not required before close() 3250 pass 3251 3252 self.assertRaises(ParseError, parser.close)

3253

3254 - def test_feed_parser_error_position(self):

3255 ParseError = self.etree.ParseError 3256 parser = self.etree.XMLParser() 3257 try: 3258 parser.close() 3259 except ParseError, e: 3260 self.assertNotEquals(None, e.code) 3261 self.assertNotEquals(0, e.code) 3262 self.assert_(isinstance(e.position, tuple)) 3263 self.assert_(e.position >= (0, 0))

3264 3265 # parser target interface 3266

3267 - def test_parser_target_tag(self):

3268 assertEquals = self.assertEquals 3269 assertFalse = self.assertFalse 3270 3271 events = [] 3272 class Target(object): 3273 def start(self, tag, attrib): 3274 events.append("start") 3275 assertFalse(attrib) 3276 assertEquals("TAG", tag)

3277 def end(self, tag): 3278 events.append("end") 3279 assertEquals("TAG", tag) 3280 def close(self): 3281 return "DONE" 3282 3283 parser = self.etree.XMLParser(target=Target()) 3284 3285 parser.feed("<TAG/>") 3286 done = parser.close() 3287 3288 self.assertEquals("DONE", done) 3289 self.assertEquals(["start", "end"], events) 3290

3291 - def test_parser_target_attrib(self):

3292 assertEquals = self.assertEquals 3293 3294 events = [] 3295 class Target(object): 3296 def start(self, tag, attrib): 3297 events.append("start-" + tag) 3298 for name, value in attrib.iteritems(): 3299 assertEquals(tag + name, value)

3300 def end(self, tag): 3301 events.append("end-" + tag) 3302 def close(self): 3303 return "DONE" 3304 3305 parser = self.etree.XMLParser(target=Target()) 3306 3307 parser.feed('<root a="roota" b="rootb"></root>') 3308 done = parser.close() 3309 3310 self.assertEquals("DONE", done) 3311 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3312 events) 3313

3314 - def test_parser_target_data(self):

3315 events = [] 3316 class Target(object): 3317 def start(self, tag, attrib): 3318 events.append("start-" + tag)

3319 def end(self, tag): 3320 events.append("end-" + tag) 3321 def data(self, data): 3322 events.append("data-" + data) 3323 def close(self): 3324 return "DONE" 3325 3326 parser = self.etree.XMLParser(target=Target()) 3327 3328 parser.feed('<root>AB</root>') 3329 done = parser.close() 3330 3331 self.assertEquals("DONE", done) 3332 self.assertEquals(["start-root", "data-A", "start-sub", 3333 "end-sub", "data-B", "end-root"], 3334 events) 3335

3336 - def test_parser_target_entity(self):

3337 events = [] 3338 class Target(object): 3339 def __init__(self): 3340 self._data = []

3341 def _flush_data(self): 3342 if self._data: 3343 events.append("data-" + ''.join(self._data)) 3344 del self._data[:] 3345 def start(self, tag, attrib): 3346 self._flush_data() 3347 events.append("start-" + tag) 3348 def end(self, tag): 3349 self._flush_data() 3350 events.append("end-" + tag) 3351 def data(self, data): 3352 self._data.append(data) 3353 def close(self): 3354 self._flush_data() 3355 return "DONE" 3356 3357 parser = self.etree.XMLParser(target=Target()) 3358 3359 dtd = ''' 3360 <!DOCTYPE root [ 3361 <!ELEMENT root (sub*)> 3362 <!ELEMENT sub (#PCDATA)> 3363 <!ENTITY ent "an entity"> 3364 ]> 3365 ''' 3366 parser.feed(dtd+'<root>this is &ent;</root>') 3367 done = parser.close() 3368 3369 self.assertEquals("DONE", done) 3370 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub", 3371 "data-this is an entity", 3372 "end-sub", "start-sub", "end-sub", "end-root"], 3373 events) 3374

3375 - def test_parser_target_entity_unknown(self):

3376 events = [] 3377 class Target(object): 3378 def __init__(self): 3379 self._data = []

3380 def _flush_data(self): 3381 if self._data: 3382 events.append("data-" + ''.join(self._data)) 3383 del self._data[:] 3384 def start(self, tag, attrib): 3385 self._flush_data() 3386 events.append("start-" + tag) 3387 def end(self, tag): 3388 self._flush_data() 3389 events.append("end-" + tag) 3390 def data(self, data): 3391 self._data.append(data) 3392 def close(self): 3393 self._flush_data() 3394 return "DONE" 3395 3396 parser = self.etree.XMLParser(target=Target()) 3397 3398 def feed(): 3399 parser.feed('<root>some &ent;</root>') 3400 parser.close() 3401 3402 self.assertRaises(self.etree.ParseError, feed) 3403

3404 - def test_treebuilder(self):

3405 builder = self.etree.TreeBuilder() 3406 el = builder.start("root", {'a':'A', 'b':'B'}) 3407 self.assertEquals("root", el.tag) 3408 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3409 builder.data("ROOTTEXT") 3410 el = builder.start("child", {'x':'X', 'y':'Y'}) 3411 self.assertEquals("child", el.tag) 3412 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3413 builder.data("CHILDTEXT") 3414 el = builder.end("child") 3415 self.assertEquals("child", el.tag) 3416 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3417 self.assertEquals("CHILDTEXT", el.text) 3418 self.assertEquals(None, el.tail) 3419 builder.data("CHILDTAIL") 3420 root = builder.end("root") 3421 3422 self.assertEquals("root", root.tag) 3423 self.assertEquals("ROOTTEXT", root.text) 3424 self.assertEquals("CHILDTEXT", root[0].text) 3425 self.assertEquals("CHILDTAIL", root[0].tail)

3426

3427 - def test_treebuilder_target(self):

3428 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3429 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3430 root = parser.close() 3431 3432 self.assertEquals("root", root.tag) 3433 self.assertEquals("ROOTTEXT", root.text) 3434 self.assertEquals("CHILDTEXT", root[0].text) 3435 self.assertEquals("CHILDTAIL", root[0].tail)

3436 3437 # helper methods 3438

3439 - def _writeElement(self, element, encoding='us-ascii'):

3440 """Write out element for comparison. 3441 """ 3442 data = self.etree.tostring(element, encoding=encoding) 3443 if encoding != 'us-ascii': 3444 data = unicode(data, encoding) 3445 return canonicalize(data)

3446

3447 - def _writeElementFile(self, element, encoding='us-ascii'):

3448 """Write out element for comparison, using real file. 3449 """ 3450 ElementTree = self.etree.ElementTree 3451 handle, filename = tempfile.mkstemp() 3452 try: 3453 f = open(filename, 'wb') 3454 tree = ElementTree(element=element) 3455 tree.write(f, encoding=encoding) 3456 f.close() 3457 f = open(filename, 'rb') 3458 data = f.read() 3459 f.close() 3460 finally: 3461 os.close(handle) 3462 os.remove(filename) 3463 if encoding != 'us-ascii': 3464 data = unicode(data, encoding) 3465 return canonicalize(data)

3466

3467 - def assertXML(self, expected, element, encoding='us-ascii'):

3468 """Writes element out and checks whether it is expected. 3469 3470 Does this two ways; once using StringIO, once using a real file. 3471 """ 3472 self.assertEquals(expected, self._writeElement(element, encoding)) 3473 self.assertEquals(expected, self._writeElementFile(element, encoding))

3474

3475 - def assertEncodingDeclaration(self, result, encoding):

3476 "Checks if the result XML byte string specifies the encoding." 3477 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 3478 self.assert_(has_encoding(result)) 3479 result_encoding = has_encoding(result).group(1) 3480 self.assertEquals(result_encoding.upper(), encoding.upper())

3481

3482 - def _rootstring(self, tree):

3483 return self.etree.tostring(tree.getroot()).replace(' ', '').replace('\n', '')

3484

3485 - def _check_element_tree(self, tree):

3486 self._check_element(tree.getroot())

3487

3488 - def _check_element(self, element):

3489 self.assert_(hasattr(element, 'tag')) 3490 self.assert_(hasattr(element, 'attrib')) 3491 self.assert_(hasattr(element, 'text')) 3492 self.assert_(hasattr(element, 'tail')) 3493 self._check_string(element.tag) 3494 self._check_mapping(element.attrib) 3495 if element.text != None: 3496 self._check_string(element.text) 3497 if element.tail != None: 3498 self._check_string(element.tail)

3499

3500 - def _check_string(self, string):

3501 len(string) 3502 for char in string: 3503 self.assertEquals(1, len(char)) 3504 new_string = string + "" 3505 new_string = string + " " 3506 string[:0]

3507

3508 - def _check_mapping(self, mapping):

3509 len(mapping) 3510 keys = mapping.keys() 3511 items = mapping.items() 3512 for key in keys: 3513 item = mapping[key] 3514 mapping["key"] = "value" 3515 self.assertEquals("value", mapping["key"])

3516 3517 3518 if etree:

3519 - class ETreeTestCase(ETreeTestCaseBase):

3520 etree = etree

3521 3522 if ElementTree:

3523 - class ElementTreeTestCase(ETreeTestCaseBase):

3524 etree = ElementTree

3525 3526 if cElementTree:

3527 - class CElementTreeTestCase(ETreeTestCaseBase):

3528 etree = cElementTree

3529

3530 -def test_suite():

3531 suite = unittest.TestSuite() 3532 if etree: 3533 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3534 if ElementTree: 3535 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3536 if cElementTree: 3537 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3538 return suite

3539 3540 if __name__ == '__main__': 3541 print 'to test use test.py %s' % __file__ 3542