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

2441

2442 - def test_ns_decl_tostring(self):

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

2451

2452 - def test_ns_decl_tostring_default(self):

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

2461

2462 - def test_ns_decl_tostring_root(self):

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

2472

2473 - def test_ns_decl_tostring_element(self):

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

2485

2486 - def test_attribute_xmlns_move(self):

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

2506

2507 - def test_namespaces_after_serialize(self):

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

2518

2519 - def test_tostring(self):

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

2530

2531 - def test_tostring_element(self):

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

2544

2545 - def test_tostring_element_tail(self):

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

2558

2559 - def test_tostring_method_html(self):

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

2572

2573 - def test_tostring_method_text(self):

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

2589

2590 - def test_iterparse(self):

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

2602

2603 - def test_iterparse_file(self):

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

2613

2614 - def test_iterparse_start(self):

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

2624

2625 - def test_iterparse_start_end(self):

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

2636

2637 - def test_iterparse_clear(self):

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

2648

2649 - def test_iterparse_large(self):

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

2659

2660 - def test_iterparse_attrib_ns(self):

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

2685

2686 - def test_iterparse_getiterator(self):

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

2696

2697 - def test_iterparse_move_elements(self):

2698 iterparse = self.etree.iterparse 2699 f = StringIO('<a><d/><c/></a>') 2700 2701 for event, node in etree.iterparse(f): pass 2702 2703 root = etree.Element('new_root', {}) 2704 root[:] = node[:] 2705 2706 self.assertEquals( 2707 ['b', 'c'], 2708 [ el.tag for el in root ])

2709

2710 - def test_iterparse_cdata(self):

2711 tostring = self.etree.tostring 2712 f = StringIO('<root><![CDATA[test]]></root>') 2713 context = self.etree.iterparse(f) 2714 content = [ el.text for event,el in context ] 2715 2716 self.assertEquals(['test'], content) 2717 self.assertEquals('<root>test</root>', 2718 tostring(context.root))

2719

2720 - def test_parse_file(self):

2721 parse = self.etree.parse 2722 # from file 2723 tree = parse(fileInTestDir('test.xml')) 2724 self.assertXML( 2725 '<a></a>', 2726 tree.getroot())

2727

2728 - def test_parse_file_nonexistent(self):

2729 parse = self.etree.parse 2730 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2731

2732 - def test_parse_error_none(self):

2733 parse = self.etree.parse 2734 self.assertRaises(TypeError, parse, None)

2735

2736 - def test_parse_error(self):

2737 # ET < 1.3 raises ExpatError 2738 parse = self.etree.parse 2739 f = StringIO('<a></c></a>') 2740 self.assertRaises(SyntaxError, parse, f) 2741 f.close()

2742

2743 - def test_parse_error_from_file(self):

2744 parse = self.etree.parse 2745 # from file 2746 f = open(fileInTestDir('test_broken.xml'), 'r') 2747 self.assertRaises(SyntaxError, parse, f) 2748 f.close()

2749

2750 - def test_parse_file_object(self):

2751 parse = self.etree.parse 2752 # from file object 2753 f = open(fileInTestDir('test.xml'), 'r') 2754 tree = parse(f) 2755 f.close() 2756 self.assertXML( 2757 '<a></a>', 2758 tree.getroot())

2759

2760 - def test_parse_stringio(self):

2761 parse = self.etree.parse 2762 # from StringIO 2763 f = StringIO('<a></a>') 2764 tree = parse(f) 2765 f.close() 2766 self.assertXML( 2767 '<a></a>', 2768 tree.getroot() 2769 )

2770

2771 - def test_parse_cdata(self):

2772 tostring = self.etree.tostring 2773 root = self.etree.XML('<root><![CDATA[test]]></root>') 2774 2775 self.assertEquals('test', root.text) 2776 self.assertEquals('<root>test</root>', 2777 tostring(root))

2778

2779 - def test_parse_with_encoding(self):

2780 # this can fail in libxml2 <= 2.6.22 2781 parse = self.etree.parse 2782 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2783 self.assertXML('<html></html>', 2784 tree.getroot())

2785

2786 - def test_encoding(self):

2787 Element = self.etree.Element 2788 2789 a = Element('a') 2790 a.text = u'Søk på nettet' 2791 self.assertXML( 2792 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2793 a, 'utf-8')

2794

2795 - def test_encoding_exact(self):

2796 ElementTree = self.etree.ElementTree 2797 Element = self.etree.Element 2798 2799 a = Element('a') 2800 a.text = u'Søk på nettet' 2801 2802 f = StringIO() 2803 tree = ElementTree(element=a) 2804 tree.write(f, encoding='utf-8') 2805 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2806 f.getvalue().replace('\n',''))

2807

2808 - def test_parse_file_encoding(self):

2809 parse = self.etree.parse 2810 # from file 2811 tree = parse(fileInTestDir('test-string.xml')) 2812 self.assertXML( 2813 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2814 tree.getroot(), 'UTF-8')

2815

2816 - def test_parse_file_object_encoding(self):

2817 parse = self.etree.parse 2818 # from file object 2819 f = open(fileInTestDir('test-string.xml'), 'r') 2820 tree = parse(f) 2821 f.close() 2822 self.assertXML( 2823 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2824 tree.getroot(), 'UTF-8')

2825

2826 - def test_encoding_8bit_latin1(self):

2827 ElementTree = self.etree.ElementTree 2828 Element = self.etree.Element 2829 2830 a = Element('a') 2831 a.text = u'Søk på nettet' 2832 2833 f = StringIO() 2834 tree = ElementTree(element=a) 2835 tree.write(f, encoding='iso-8859-1') 2836 result = f.getvalue() 2837 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2838 self.assertEncodingDeclaration(result,'iso-8859-1') 2839 result = result.split('?>', 1)[-1].replace('\n','') 2840 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2841 result)

2842

2843 - def test_parse_encoding_8bit_explicit(self):

2844 XMLParser = self.etree.XMLParser 2845 2846 text = u'Søk på nettet' 2847 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1') 2848 2849 self.assertRaises(self.etree.ParseError, 2850 self.etree.parse, 2851 StringIO(xml_latin1)) 2852 2853 tree = self.etree.parse(StringIO(xml_latin1), 2854 XMLParser(encoding="iso-8859-1")) 2855 a = tree.getroot() 2856 self.assertEquals(a.text, text)

2857

2858 - def test_parse_encoding_8bit_override(self):

2859 XMLParser = self.etree.XMLParser 2860 2861 text = u'Søk på nettet' 2862 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 2863 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 2864 ).encode('iso-8859-1') 2865 2866 self.assertRaises(self.etree.ParseError, 2867 self.etree.parse, 2868 StringIO(xml_latin1)) 2869 2870 tree = self.etree.parse(StringIO(xml_latin1), 2871 XMLParser(encoding="iso-8859-1")) 2872 a = tree.getroot() 2873 self.assertEquals(a.text, text)

2874

2875 - def _test_wrong_unicode_encoding(self):

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

2881

2882 - def test_encoding_write_default_encoding(self):

2883 ElementTree = self.etree.ElementTree 2884 Element = self.etree.Element 2885 2886 a = Element('a') 2887 a.text = u'Søk på nettet' 2888 2889 f = StringIO() 2890 tree = ElementTree(element=a) 2891 tree.write(f) 2892 data = f.getvalue().replace('\n','') 2893 self.assertEquals( 2894 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2895 data)

2896

2897 - def test_encoding_tostring(self):

2898 Element = self.etree.Element 2899 tostring = self.etree.tostring 2900 2901 a = Element('a') 2902 a.text = u'Søk på nettet' 2903 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2904 tostring(a, encoding='utf-8'))

2905

2906 - def test_encoding_tostring_unknown(self):

2907 Element = self.etree.Element 2908 tostring = self.etree.tostring 2909 2910 a = Element('a') 2911 a.text = u'Søk på nettet' 2912 self.assertRaises(LookupError, tostring, a, 2913 encoding='Invalid Encoding')

2914

2915 - def test_encoding_tostring_sub(self):

2916 Element = self.etree.Element 2917 SubElement = self.etree.SubElement 2918 tostring = self.etree.tostring 2919 2920 a = Element('a') 2921 b = SubElement(a, 'b') 2922 b.text = u'Søk på nettet' 2923 self.assertEquals(u'Søk på nettet'.encode('UTF-8'), 2924 tostring(b, encoding='utf-8'))

2925

2926 - def test_encoding_tostring_sub_tail(self):

2927 Element = self.etree.Element 2928 SubElement = self.etree.SubElement 2929 tostring = self.etree.tostring 2930 2931 a = Element('a') 2932 b = SubElement(a, 'b') 2933 b.text = u'Søk på nettet' 2934 b.tail = u'Søk' 2935 self.assertEquals(u'Søk på nettetSøk'.encode('UTF-8'), 2936 tostring(b, encoding='utf-8'))

2937

2938 - def test_encoding_tostring_default_encoding(self):

2939 Element = self.etree.Element 2940 SubElement = self.etree.SubElement 2941 tostring = self.etree.tostring 2942 2943 a = Element('a') 2944 a.text = u'Søk på nettet' 2945 2946 expected = '<a>Søk på nettet</a>' 2947 self.assertEquals( 2948 expected, 2949 tostring(a))

2950

2951 - def test_encoding_sub_tostring_default_encoding(self):

2952 Element = self.etree.Element 2953 SubElement = self.etree.SubElement 2954 tostring = self.etree.tostring 2955 2956 a = Element('a') 2957 b = SubElement(a, 'b') 2958 b.text = u'Søk på nettet' 2959 2960 expected = 'Søk på nettet' 2961 self.assertEquals( 2962 expected, 2963 tostring(b))

2964

2965 - def test_encoding_8bit_xml(self):

2966 utext = u'Søk på nettet' 2967 uxml = u'%s' % utext 2968 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2969 isoxml = prologue + uxml.encode('iso-8859-1') 2970 tree = self.etree.XML(isoxml) 2971 self.assertEquals(utext, tree.text)

2972

2973 - def test_encoding_utf8_bom(self):

2974 utext = u'Søk på nettet' 2975 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \ 2976 u'%s' % utext 2977 bom = '\xEF\xBB\xBF' 2978 xml = bom + uxml.encode("utf-8") 2979 tree = etree.XML(xml) 2980 self.assertEquals(utext, tree.text)

2981

2982 - def test_encoding_8bit_parse_stringio(self):

2983 utext = u'Søk på nettet' 2984 uxml = u'%s' % utext 2985 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2986 isoxml = prologue + uxml.encode('iso-8859-1') 2987 el = self.etree.parse(StringIO(isoxml)).getroot() 2988 self.assertEquals(utext, el.text)

2989

2990 - def test_deepcopy_elementtree(self):

2991 Element = self.etree.Element 2992 ElementTree = self.etree.ElementTree 2993 2994 a = Element('a') 2995 a.text = "Foo" 2996 atree = ElementTree(a) 2997 2998 btree = copy.deepcopy(atree) 2999 self.assertEqual("Foo", atree.getroot().text) 3000 self.assertEqual("Foo", btree.getroot().text) 3001 self.assertFalse(btree is atree) 3002 self.assertFalse(btree.getroot() is atree.getroot())

3003

3004 - def test_deepcopy(self):

3005 Element = self.etree.Element 3006 3007 a = Element('a') 3008 a.text = 'Foo' 3009 3010 b = copy.deepcopy(a) 3011 self.assertEquals('Foo', b.text) 3012 3013 b.text = 'Bar' 3014 self.assertEquals('Bar', b.text) 3015 self.assertEquals('Foo', a.text) 3016 3017 del a 3018 self.assertEquals('Bar', b.text)

3019

3020 - def test_deepcopy_tail(self):

3021 Element = self.etree.Element 3022 3023 a = Element('a') 3024 a.tail = 'Foo' 3025 3026 b = copy.deepcopy(a) 3027 self.assertEquals('Foo', b.tail) 3028 3029 b.tail = 'Bar' 3030 self.assertEquals('Bar', b.tail) 3031 self.assertEquals('Foo', a.tail) 3032 3033 del a 3034 self.assertEquals('Bar', b.tail)

3035

3036 - def test_deepcopy_subelement(self):

3037 Element = self.etree.Element 3038 SubElement = self.etree.SubElement 3039 3040 root = Element('root') 3041 a = SubElement(root, 'a') 3042 a.text = 'FooText' 3043 a.tail = 'FooTail' 3044 3045 b = copy.deepcopy(a) 3046 self.assertEquals('FooText', b.text) 3047 self.assertEquals('FooTail', b.tail) 3048 3049 b.text = 'BarText' 3050 b.tail = 'BarTail' 3051 self.assertEquals('BarTail', b.tail) 3052 self.assertEquals('FooTail', a.tail) 3053 self.assertEquals('BarText', b.text) 3054 self.assertEquals('FooText', a.text) 3055 3056 del a 3057 self.assertEquals('BarTail', b.tail) 3058 self.assertEquals('BarText', b.text)

3059

3060 - def test_deepcopy_namespaces(self):

3061 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 3062 <parent><node t:foo="bar" /></parent> 3063 </doc>''') 3064 self.assertEquals( 3065 root[0][0].get('{tns}foo'), 3066 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3067 self.assertEquals( 3068 root[0][0].get('{tns}foo'), 3069 copy.deepcopy(root[0][0]).get('{tns}foo') )

3070

3071 - def test_deepcopy_append(self):

3072 # previously caused a crash 3073 Element = self.etree.Element 3074 tostring = self.etree.tostring 3075 3076 a = Element('a') 3077 b = copy.deepcopy(a) 3078 a.append( Element('C') ) 3079 b.append( Element('X') ) 3080 3081 self.assertEquals('<a><C/></a>', 3082 tostring(a).replace(' ', '')) 3083 self.assertEquals('<a><X/></a>', 3084 tostring(b).replace(' ', ''))

3085

3086 - def test_deepcopy_comment(self):

3087 # previously caused a crash 3088 # not supported by ET < 1.3! 3089 Comment = self.etree.Comment 3090 3091 a = Comment("ONE") 3092 b = copy.deepcopy(a) 3093 b.text = "ANOTHER" 3094 3095 self.assertEquals('ONE', a.text) 3096 self.assertEquals('ANOTHER', b.text)

3097

3098 - def test_shallowcopy(self):

3099 Element = self.etree.Element 3100 3101 a = Element('a') 3102 a.text = 'Foo' 3103 3104 b = copy.copy(a) 3105 self.assertEquals('Foo', b.text) 3106 3107 b.text = 'Bar' 3108 self.assertEquals('Bar', b.text) 3109 self.assertEquals('Foo', a.text)

3110 # XXX ElementTree will share nodes, but lxml.etree won't.. 3111

3112 - def test_shallowcopy_elementtree(self):

3113 Element = self.etree.Element 3114 ElementTree = self.etree.ElementTree 3115 3116 a = Element('a') 3117 a.text = 'Foo' 3118 atree = ElementTree(a) 3119 3120 btree = copy.copy(atree) 3121 self.assertFalse(btree is atree) 3122 self.assert_(btree.getroot() is atree.getroot()) 3123 self.assertEquals('Foo', atree.getroot().text)

3124

3125 - def _test_element_boolean(self):

3126 # deprecated as of ET 1.3/lxml 2.0 3127 etree = self.etree 3128 e = etree.Element('foo') 3129 self.assertEquals(False, bool(e)) 3130 etree.SubElement(e, 'bar') 3131 self.assertEquals(True, bool(e)) 3132 e = etree.Element('foo') 3133 e.text = 'hey' 3134 self.assertEquals(False, bool(e)) 3135 e = etree.Element('foo') 3136 e.tail = 'bar' 3137 self.assertEquals(False, bool(e)) 3138 e = etree.Element('foo') 3139 e.set('bar', 'Bar') 3140 self.assertEquals(False, bool(e))

3141

3142 - def test_multiple_elementrees(self):

3143 etree = self.etree 3144 3145 a = etree.Element('a') 3146 b = etree.SubElement(a, 'b') 3147 3148 t = etree.ElementTree(a) 3149 self.assertEquals(self._rootstring(t), '<a></a>') 3150 3151 t1 = etree.ElementTree(a) 3152 self.assertEquals(self._rootstring(t1), '<a></a>') 3153 self.assertEquals(self._rootstring(t), '<a></a>') 3154 3155 t2 = etree.ElementTree(b) 3156 self.assertEquals(self._rootstring(t2), '') 3157 self.assertEquals(self._rootstring(t1), '<a></a>') 3158 self.assertEquals(self._rootstring(t), '<a></a>')

3159

3160 - def test_qname(self):

3161 etree = self.etree 3162 qname = etree.QName('myns', 'a') 3163 a1 = etree.Element(qname) 3164 a2 = etree.SubElement(a1, qname) 3165 self.assertEquals(a1.tag, "{myns}a") 3166 self.assertEquals(a2.tag, "{myns}a")

3167

3168 - def test_qname_cmp(self):

3169 etree = self.etree 3170 qname1 = etree.QName('myns', 'a') 3171 qname2 = etree.QName('myns', 'a') 3172 self.assertEquals(qname1, "{myns}a") 3173 self.assertEquals("{myns}a", qname2) 3174 self.assertEquals(qname1, qname1) 3175 self.assertEquals(qname1, qname2)

3176

3177 - def test_qname_attribute_getset(self):

3178 etree = self.etree 3179 qname = etree.QName('myns', 'a') 3180 3181 a = etree.Element(qname) 3182 a.set(qname, "value") 3183 3184 self.assertEquals(a.get(qname), "value") 3185 self.assertEquals(a.get("{myns}a"), "value")

3186

3187 - def test_qname_attrib(self):

3188 etree = self.etree 3189 qname = etree.QName('myns', 'a') 3190 3191 a = etree.Element(qname) 3192 a.attrib[qname] = "value" 3193 3194 self.assertEquals(a.attrib[qname], "value") 3195 self.assertEquals(a.attrib.get(qname), "value") 3196 3197 self.assertEquals(a.attrib["{myns}a"], "value") 3198 self.assertEquals(a.attrib.get("{myns}a"), "value")

3199

3200 - def test_qname_attribute_resolve(self):

3201 etree = self.etree 3202 qname = etree.QName('http://myns', 'a') 3203 a = etree.Element(qname) 3204 a.set(qname, qname) 3205 3206 self.assertXML( 3207 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3208 a)

3209

3210 - def test_qname_attribute_resolve_new(self):

3211 etree = self.etree 3212 qname = etree.QName('http://myns', 'a') 3213 a = etree.Element('a') 3214 a.set('a', qname) 3215 3216 self.assertXML( 3217 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 3218 a)

3219

3220 - def test_qname_attrib_resolve(self):

3221 etree = self.etree 3222 qname = etree.QName('http://myns', 'a') 3223 a = etree.Element(qname) 3224 a.attrib[qname] = qname 3225 3226 self.assertXML( 3227 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3228 a)

3229

3230 - def test_parser_version(self):

3231 etree = self.etree 3232 parser = etree.XMLParser() 3233 if hasattr(parser, "version"): 3234 # ElementTree 1.3+, cET 3235 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

3236 3237 # feed parser interface 3238

3239 - def test_feed_parser(self):

3240 parser = self.etree.XMLParser() 3241 3242 parser.feed('<?xml version=') 3243 parser.feed('"1.0"?><ro') 3244 parser.feed('ot><') 3245 parser.feed('a test="works"/') 3246 parser.feed('></root') 3247 parser.feed('>') 3248 3249 root = parser.close() 3250 3251 self.assertEquals(root.tag, "root") 3252 self.assertEquals(root[0].tag, "a") 3253 self.assertEquals(root[0].get("test"), "works")

3254

3255 - def test_feed_parser_error_close_empty(self):

3256 ParseError = self.etree.ParseError 3257 parser = self.etree.XMLParser() 3258 self.assertRaises(ParseError, parser.close)

3259

3260 - def test_feed_parser_error_close_incomplete(self):

3261 ParseError = self.etree.ParseError 3262 parser = self.etree.XMLParser() 3263 3264 parser.feed('<?xml version=') 3265 parser.feed('"1.0"?><ro') 3266 3267 self.assertRaises(ParseError, parser.close)

3268

3269 - def test_feed_parser_error_broken(self):

3270 ParseError = self.etree.ParseError 3271 parser = self.etree.XMLParser() 3272 3273 parser.feed('<?xml version=') 3274 parser.feed('"1.0"?><ro') 3275 try: 3276 parser.feed('<><><><><><><') 3277 except ParseError: 3278 # can raise, but not required before close() 3279 pass 3280 3281 self.assertRaises(ParseError, parser.close)

3282

3283 - def test_feed_parser_error_position(self):

3284 ParseError = self.etree.ParseError 3285 parser = self.etree.XMLParser() 3286 try: 3287 parser.close() 3288 except ParseError, e: 3289 self.assertNotEquals(None, e.code) 3290 self.assertNotEquals(0, e.code) 3291 self.assert_(isinstance(e.position, tuple)) 3292 self.assert_(e.position >= (0, 0))

3293 3294 # parser target interface 3295

3296 - def test_parser_target_tag(self):

3297 assertEquals = self.assertEquals 3298 assertFalse = self.assertFalse 3299 3300 events = [] 3301 class Target(object): 3302 def start(self, tag, attrib): 3303 events.append("start") 3304 assertFalse(attrib) 3305 assertEquals("TAG", tag)

3306 def end(self, tag): 3307 events.append("end") 3308 assertEquals("TAG", tag) 3309 def close(self): 3310 return "DONE" 3311 3312 parser = self.etree.XMLParser(target=Target()) 3313 3314 parser.feed("<TAG/>") 3315 done = parser.close() 3316 3317 self.assertEquals("DONE", done) 3318 self.assertEquals(["start", "end"], events) 3319

3320 - def test_parser_target_attrib(self):

3321 assertEquals = self.assertEquals 3322 3323 events = [] 3324 class Target(object): 3325 def start(self, tag, attrib): 3326 events.append("start-" + tag) 3327 for name, value in attrib.iteritems(): 3328 assertEquals(tag + name, value)

3329 def end(self, tag): 3330 events.append("end-" + tag) 3331 def close(self): 3332 return "DONE" 3333 3334 parser = self.etree.XMLParser(target=Target()) 3335 3336 parser.feed('<root a="roota" b="rootb"></root>') 3337 done = parser.close() 3338 3339 self.assertEquals("DONE", done) 3340 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3341 events) 3342

3343 - def test_parser_target_data(self):

3344 events = [] 3345 class Target(object): 3346 def start(self, tag, attrib): 3347 events.append("start-" + tag)

3348 def end(self, tag): 3349 events.append("end-" + tag) 3350 def data(self, data): 3351 events.append("data-" + data) 3352 def close(self): 3353 return "DONE" 3354 3355 parser = self.etree.XMLParser(target=Target()) 3356 3357 parser.feed('<root>AB</root>') 3358 done = parser.close() 3359 3360 self.assertEquals("DONE", done) 3361 self.assertEquals(["start-root", "data-A", "start-sub", 3362 "end-sub", "data-B", "end-root"], 3363 events) 3364

3365 - def test_parser_target_entity(self):

3366 events = [] 3367 class Target(object): 3368 def __init__(self): 3369 self._data = []

3370 def _flush_data(self): 3371 if self._data: 3372 events.append("data-" + ''.join(self._data)) 3373 del self._data[:] 3374 def start(self, tag, attrib): 3375 self._flush_data() 3376 events.append("start-" + tag) 3377 def end(self, tag): 3378 self._flush_data() 3379 events.append("end-" + tag) 3380 def data(self, data): 3381 self._data.append(data) 3382 def close(self): 3383 self._flush_data() 3384 return "DONE" 3385 3386 parser = self.etree.XMLParser(target=Target()) 3387 3388 dtd = ''' 3389 <!DOCTYPE root [ 3390 <!ELEMENT root (sub*)> 3391 <!ELEMENT sub (#PCDATA)> 3392 <!ENTITY ent "an entity"> 3393 ]> 3394 ''' 3395 parser.feed(dtd+'<root>this is &ent;</root>') 3396 done = parser.close() 3397 3398 self.assertEquals("DONE", done) 3399 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub", 3400 "data-this is an entity", 3401 "end-sub", "start-sub", "end-sub", "end-root"], 3402 events) 3403

3404 - def test_parser_target_entity_unknown(self):

3405 events = [] 3406 class Target(object): 3407 def __init__(self): 3408 self._data = []

3409 def _flush_data(self): 3410 if self._data: 3411 events.append("data-" + ''.join(self._data)) 3412 del self._data[:] 3413 def start(self, tag, attrib): 3414 self._flush_data() 3415 events.append("start-" + tag) 3416 def end(self, tag): 3417 self._flush_data() 3418 events.append("end-" + tag) 3419 def data(self, data): 3420 self._data.append(data) 3421 def close(self): 3422 self._flush_data() 3423 return "DONE" 3424 3425 parser = self.etree.XMLParser(target=Target()) 3426 3427 def feed(): 3428 parser.feed('<root>some &ent;</root>') 3429 parser.close() 3430 3431 self.assertRaises(self.etree.ParseError, feed) 3432

3433 - def test_treebuilder(self):

3434 builder = self.etree.TreeBuilder() 3435 el = builder.start("root", {'a':'A', 'b':'B'}) 3436 self.assertEquals("root", el.tag) 3437 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3438 builder.data("ROOTTEXT") 3439 el = builder.start("child", {'x':'X', 'y':'Y'}) 3440 self.assertEquals("child", el.tag) 3441 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3442 builder.data("CHILDTEXT") 3443 el = builder.end("child") 3444 self.assertEquals("child", el.tag) 3445 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3446 self.assertEquals("CHILDTEXT", el.text) 3447 self.assertEquals(None, el.tail) 3448 builder.data("CHILDTAIL") 3449 root = builder.end("root") 3450 3451 self.assertEquals("root", root.tag) 3452 self.assertEquals("ROOTTEXT", root.text) 3453 self.assertEquals("CHILDTEXT", root[0].text) 3454 self.assertEquals("CHILDTAIL", root[0].tail)

3455

3456 - def test_treebuilder_target(self):

3457 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3458 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3459 root = parser.close() 3460 3461 self.assertEquals("root", root.tag) 3462 self.assertEquals("ROOTTEXT", root.text) 3463 self.assertEquals("CHILDTEXT", root[0].text) 3464 self.assertEquals("CHILDTAIL", root[0].tail)

3465 3466 # helper methods 3467

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

3469 """Write out element for comparison. 3470 """ 3471 data = self.etree.tostring(element, encoding=encoding) 3472 if encoding != 'us-ascii': 3473 data = unicode(data, encoding) 3474 return canonicalize(data)

3475

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

3477 """Write out element for comparison, using real file. 3478 """ 3479 ElementTree = self.etree.ElementTree 3480 handle, filename = tempfile.mkstemp() 3481 try: 3482 f = open(filename, 'wb') 3483 tree = ElementTree(element=element) 3484 tree.write(f, encoding=encoding) 3485 f.close() 3486 f = open(filename, 'rb') 3487 data = f.read() 3488 f.close() 3489 finally: 3490 os.close(handle) 3491 os.remove(filename) 3492 if encoding != 'us-ascii': 3493 data = unicode(data, encoding) 3494 return canonicalize(data)

3495

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

3497 """Writes element out and checks whether it is expected. 3498 3499 Does this two ways; once using StringIO, once using a real file. 3500 """ 3501 self.assertEquals(expected, self._writeElement(element, encoding)) 3502 self.assertEquals(expected, self._writeElementFile(element, encoding))

3503

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

3505 "Checks if the result XML byte string specifies the encoding." 3506 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 3507 self.assert_(has_encoding(result)) 3508 result_encoding = has_encoding(result).group(1) 3509 self.assertEquals(result_encoding.upper(), encoding.upper())

3510

3511 - def _rootstring(self, tree):

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

3513

3514 - def _check_element_tree(self, tree):

3515 self._check_element(tree.getroot())

3516

3517 - def _check_element(self, element):

3518 self.assert_(hasattr(element, 'tag')) 3519 self.assert_(hasattr(element, 'attrib')) 3520 self.assert_(hasattr(element, 'text')) 3521 self.assert_(hasattr(element, 'tail')) 3522 self._check_string(element.tag) 3523 self._check_mapping(element.attrib) 3524 if element.text != None: 3525 self._check_string(element.text) 3526 if element.tail != None: 3527 self._check_string(element.tail)

3528

3529 - def _check_string(self, string):

3530 len(string) 3531 for char in string: 3532 self.assertEquals(1, len(char)) 3533 new_string = string + "" 3534 new_string = string + " " 3535 string[:0]

3536

3537 - def _check_mapping(self, mapping):

3538 len(mapping) 3539 keys = mapping.keys() 3540 items = mapping.items() 3541 for key in keys: 3542 item = mapping[key] 3543 mapping["key"] = "value" 3544 self.assertEquals("value", mapping["key"])

3545 3546 3547 if etree:

3548 - class ETreeTestCase(ETreeTestCaseBase):

3549 etree = etree

3550 3551 if ElementTree:

3552 - class ElementTreeTestCase(ETreeTestCaseBase):

3553 etree = ElementTree

3554 3555 if cElementTree:

3556 - class CElementTreeTestCase(ETreeTestCaseBase):

3557 etree = cElementTree

3558

3559 -def test_suite():

3560 suite = unittest.TestSuite() 3561 if etree: 3562 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3563 if ElementTree: 3564 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3565 if cElementTree: 3566 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3567 return suite

3568 3569 if __name__ == '__main__': 3570 print 'to test use test.py %s' % __file__ 3571