lxml.tests.test_elementtree

Source Code for Module lxml.tests.test_elementtree

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests for the ElementTree API 5 6 Only test cases that apply equally well to etree and ElementTree 7 belong here. Note that there is a second test module called test_io.py 8 for IO related test cases. 9 """ 10 11 import unittest, doctest 12 import os, re, tempfile, copy, operator, gc 13 14 from common_imports import StringIO, etree, ElementTree, cElementTree 15 from common_imports import fileInTestDir, canonicalize 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(unittest.TestCase):

31 etree = None 32

33 - def tearDown(self):

34 gc.collect()

35

36 - def test_element(self):

37 for i in range(10): 38 e = self.etree.Element('foo') 39 self.assertEquals(e.tag, 'foo') 40 self.assertEquals(e.text, None) 41 self.assertEquals(e.tail, None)

42

43 - def test_simple(self):

44 Element = self.etree.Element 45 46 root = Element('root') 47 root.append(Element('one')) 48 root.append(Element('two')) 49 root.append(Element('three')) 50 self.assertEquals(3, len(root)) 51 self.assertEquals('one', root[0].tag) 52 self.assertEquals('two', root[1].tag) 53 self.assertEquals('three', root[2].tag) 54 self.assertRaises(IndexError, operator.getitem, root, 3)

55

56 - def test_subelement(self):

57 Element = self.etree.Element 58 SubElement = self.etree.SubElement 59 60 root = Element('root') 61 SubElement(root, 'one') 62 SubElement(root, 'two') 63 SubElement(root, 'three') 64 self.assertEquals(3, len(root)) 65 self.assertEquals('one', root[0].tag) 66 self.assertEquals('two', root[1].tag) 67 self.assertEquals('three', root[2].tag)

68

69 - def test_element_contains(self):

70 Element = self.etree.Element 71 SubElement = self.etree.SubElement 72 73 root1 = Element('root') 74 SubElement(root1, 'one') 75 self.assert_(root1[0] in root1) 76 77 root2 = Element('root') 78 SubElement(root2, 'two') 79 SubElement(root2, 'three') 80 self.assert_(root2[0] in root2) 81 self.assert_(root2[1] in root2) 82 83 self.assertFalse(root1[0] in root2) 84 self.assertFalse(root2[0] in root1) 85 self.assertFalse(None in root2)

86

87 - def test_element_indexing_with_text(self):

88 ElementTree = self.etree.ElementTree 89 90 f = StringIO('<doc>Test<one>One</one></doc>') 91 doc = ElementTree(file=f) 92 root = doc.getroot() 93 self.assertEquals(1, len(root)) 94 self.assertEquals('one', root[0].tag) 95 self.assertRaises(IndexError, operator.getitem, root, 1)

96

97 - def test_element_indexing_with_text2(self):

98 ElementTree = self.etree.ElementTree 99 100 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 101 doc = ElementTree(file=f) 102 root = doc.getroot() 103 self.assertEquals(3, len(root)) 104 self.assertEquals('one', root[0].tag) 105 self.assertEquals('two', root[1].tag) 106 self.assertEquals('three', root[2].tag)

107

108 - def test_element_indexing_only_text(self):

109 ElementTree = self.etree.ElementTree 110 111 f = StringIO('<doc>Test</doc>') 112 doc = ElementTree(file=f) 113 root = doc.getroot() 114 self.assertEquals(0, len(root))

115

116 - def test_element_indexing_negative(self):

117 Element = self.etree.Element 118 SubElement = self.etree.SubElement 119 a = Element('a') 120 b = SubElement(a, 'b') 121 c = SubElement(a, 'c') 122 d = SubElement(a, 'd') 123 self.assertEquals(d, a[-1]) 124 self.assertEquals(c, a[-2]) 125 self.assertEquals(b, a[-3]) 126 self.assertRaises(IndexError, operator.getitem, a, -4) 127 a[-1] = e = Element('e') 128 self.assertEquals(e, a[-1]) 129 del a[-1] 130 self.assertEquals(2, len(a))

131

132 - def test_elementtree(self):

133 ElementTree = self.etree.ElementTree 134 135 f = StringIO('<doc><one>One</one><two>Two</two></doc>') 136 doc = ElementTree(file=f) 137 root = doc.getroot() 138 self.assertEquals(2, len(root)) 139 self.assertEquals('one', root[0].tag) 140 self.assertEquals('two', root[1].tag)

141

142 - def test_text(self):

143 ElementTree = self.etree.ElementTree 144 145 f = StringIO('<doc>This is a text</doc>') 146 doc = ElementTree(file=f) 147 root = doc.getroot() 148 self.assertEquals('This is a text', root.text)

149

150 - def test_text_empty(self):

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

157

158 - def test_text_other(self):

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

166

167 - def test_text_escape_in(self):

168 ElementTree = self.etree.ElementTree 169 170 f = StringIO('<doc>This is > than a text</doc>') 171 doc = ElementTree(file=f) 172 root = doc.getroot() 173 self.assertEquals('This is > than a text', root.text)

174

175 - def test_text_escape_out(self):

176 Element = self.etree.Element 177 178 a = Element("a") 179 a.text = "<>&" 180 self.assertXML('<a><>&</a>', 181 a)

182

183 - def test_text_escape_tostring(self):

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

191

192 - def test_text_str_subclass(self):

193 Element = self.etree.Element 194 195 class strTest(str): 196 pass

197 198 a = Element("a") 199 a.text = strTest("text") 200 self.assertXML('<a>text</a>', 201 a)

202

203 - def test_tail(self):

204 ElementTree = self.etree.ElementTree 205 206 f = StringIO('<doc>This is mixed content.</doc>') 207 doc = ElementTree(file=f) 208 root = doc.getroot() 209 self.assertEquals(1, len(root)) 210 self.assertEquals('This is ', root.text) 211 self.assertEquals(None, root.tail) 212 self.assertEquals('mixed', root[0].text) 213 self.assertEquals(' content.', root[0].tail)

214

215 - def test_tail_str_subclass(self):

216 Element = self.etree.Element 217 SubElement = self.etree.SubElement 218 219 class strTest(str): 220 pass

221 222 a = Element("a") 223 SubElement(a, "t").tail = strTest("tail") 224 self.assertXML('<a><t></t>tail</a>', 225 a) 226

227 - def _test_del_tail(self):

228 # this is discouraged for ET compat, should not be tested... 229 XML = self.etree.XML 230 231 root = XML('<doc>This is mixed content.</doc>') 232 self.assertEquals(1, len(root)) 233 self.assertEquals('This is ', root.text) 234 self.assertEquals(None, root.tail) 235 self.assertEquals('mixed', root[0].text) 236 self.assertEquals(' content.', root[0].tail) 237 238 del root[0].tail 239 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(None, root[0].tail) 245 246 root[0].tail = "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('TAIL', root[0].tail)

253

254 - def test_ElementTree(self):

255 Element = self.etree.Element 256 ElementTree = self.etree.ElementTree 257 258 el = Element('hoi') 259 doc = ElementTree(el) 260 root = doc.getroot() 261 self.assertEquals(None, root.text) 262 self.assertEquals('hoi', root.tag)

263

264 - def test_attributes(self):

265 ElementTree = self.etree.ElementTree 266 267 f = StringIO('<doc one="One" two="Two"/>') 268 doc = ElementTree(file=f) 269 root = doc.getroot() 270 self.assertEquals('One', root.attrib['one']) 271 self.assertEquals('Two', root.attrib['two']) 272 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

273

274 - def test_attributes2(self):

275 ElementTree = self.etree.ElementTree 276 277 f = StringIO('<doc one="One" two="Two"/>') 278 doc = ElementTree(file=f) 279 root = doc.getroot() 280 self.assertEquals('One', root.attrib.get('one')) 281 self.assertEquals('Two', root.attrib.get('two')) 282 self.assertEquals(None, root.attrib.get('three')) 283 self.assertEquals('foo', root.attrib.get('three', 'foo'))

284

285 - def test_attributes3(self):

286 ElementTree = self.etree.ElementTree 287 288 f = StringIO('<doc one="One" two="Two"/>') 289 doc = ElementTree(file=f) 290 root = doc.getroot() 291 self.assertEquals('One', root.get('one')) 292 self.assertEquals('Two', root.get('two')) 293 self.assertEquals(None, root.get('three')) 294 self.assertEquals('foo', root.get('three', 'foo'))

295

296 - def test_attrib_clear(self):

297 XML = self.etree.XML 298 299 root = XML('<doc one="One" two="Two"/>') 300 self.assertEquals('One', root.get('one')) 301 self.assertEquals('Two', root.get('two')) 302 root.attrib.clear() 303 self.assertEquals(None, root.get('one')) 304 self.assertEquals(None, root.get('two'))

305

306 - def test_attrib_set_clear(self):

307 Element = self.etree.Element 308 309 root = Element("root", one="One") 310 root.set("two", "Two") 311 self.assertEquals('One', root.get('one')) 312 self.assertEquals('Two', root.get('two')) 313 root.attrib.clear() 314 self.assertEquals(None, root.get('one')) 315 self.assertEquals(None, root.get('two'))

316

317 - def test_attrib_ns_clear(self):

318 Element = self.etree.Element 319 SubElement = self.etree.SubElement 320 321 attribNS = '{http://foo/bar}x' 322 323 parent = Element('parent') 324 parent.set(attribNS, 'a') 325 child = SubElement(parent, 'child') 326 child.set(attribNS, 'b') 327 328 self.assertEquals('a', parent.get(attribNS)) 329 self.assertEquals('b', child.get(attribNS)) 330 331 parent.clear() 332 self.assertEquals(None, parent.get(attribNS)) 333 self.assertEquals('b', child.get(attribNS))

334

335 - def test_attribute_update_dict(self):

336 XML = self.etree.XML 337 338 root = XML('<doc alpha="Alpha" beta="Beta"/>') 339 items = root.attrib.items() 340 items.sort() 341 self.assertEquals( 342 [('alpha', 'Alpha'), ('beta', 'Beta')], 343 items) 344 345 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 346 347 items = root.attrib.items() 348 items.sort() 349 self.assertEquals( 350 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 351 items)

352

353 - def test_attribute_update_sequence(self):

354 XML = self.etree.XML 355 356 root = XML('<doc alpha="Alpha" beta="Beta"/>') 357 items = root.attrib.items() 358 items.sort() 359 self.assertEquals( 360 [('alpha', 'Alpha'), ('beta', 'Beta')], 361 items) 362 363 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 364 365 items = root.attrib.items() 366 items.sort() 367 self.assertEquals( 368 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 369 items)

370

371 - def test_attribute_update_iter(self):

372 XML = self.etree.XML 373 374 root = XML('<doc alpha="Alpha" beta="Beta"/>') 375 items = root.attrib.items() 376 items.sort() 377 self.assertEquals( 378 [('alpha', 'Alpha'), ('beta', 'Beta')], 379 items) 380 381 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.iteritems()) 382 383 items = root.attrib.items() 384 items.sort() 385 self.assertEquals( 386 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 387 items)

388

389 - def test_attribute_keys(self):

390 XML = self.etree.XML 391 392 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 393 keys = root.attrib.keys() 394 keys.sort() 395 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

396

397 - def test_attribute_keys2(self):

398 XML = self.etree.XML 399 400 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 401 keys = root.keys() 402 keys.sort() 403 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

404

405 - def test_attribute_items2(self):

406 XML = self.etree.XML 407 408 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 409 items = root.items() 410 items.sort() 411 self.assertEquals( 412 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 413 items)

414

415 - def test_attribute_keys_ns(self):

416 XML = self.etree.XML 417 418 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 419 keys = root.keys() 420 keys.sort() 421 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 422 keys)

423

424 - def test_attribute_values(self):

425 XML = self.etree.XML 426 427 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 428 values = root.attrib.values() 429 values.sort() 430 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)

431

432 - def test_attribute_values_ns(self):

433 XML = self.etree.XML 434 435 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 436 values = root.attrib.values() 437 values.sort() 438 self.assertEquals( 439 ['Bar', 'Baz'], values)

440

441 - def test_attribute_items(self):

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

453

454 - def test_attribute_items_ns(self):

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

463

464 - def test_attribute_str(self):

465 XML = self.etree.XML 466 467 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 468 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 469 470 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 471 try: 472 self.assertEquals(expected, str(root.attrib)) 473 except AssertionError: 474 self.assertEquals(alternative, str(root.attrib))

475

476 - def test_attribute_has_key(self):

477 XML = self.etree.XML 478 479 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 480 self.assertEquals( 481 True, root.attrib.has_key('bar')) 482 self.assertEquals( 483 False, root.attrib.has_key('baz')) 484 self.assertEquals( 485 False, root.attrib.has_key('hah')) 486 self.assertEquals( 487 True, 488 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))

489

490 - def test_attribute_contains(self):

491 XML = self.etree.XML 492 493 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 494 self.assertEquals( 495 True, 'bar' in root.attrib) 496 self.assertEquals( 497 False, 'baz' in root.attrib) 498 self.assertEquals( 499 False, 'hah' in root.attrib) 500 self.assertEquals( 501 True, 502 '{http://ns.codespeak.net/test}baz' in root.attrib)

503

504 - def test_attribute_set(self):

505 Element = self.etree.Element 506 507 root = Element("root") 508 root.set("attr", "TEST") 509 self.assertEquals("TEST", root.get("attr"))

510

511 - def test_XML(self):

512 XML = self.etree.XML 513 514 root = XML('<doc>This is a text.</doc>') 515 self.assertEquals(0, len(root)) 516 self.assertEquals('This is a text.', root.text)

517

518 - def test_XMLID(self):

519 XMLID = self.etree.XMLID 520 XML = self.etree.XML 521 xml_text = ''' 522 <document> 523 <h1 id="chapter1">...</h1> 524 ... 525 Regular paragraph. 526 XML:ID paragraph. 527 ... 528 </document> 529 ''' 530 531 root, dic = XMLID(xml_text) 532 root2 = XML(xml_text) 533 self.assertEquals(self._writeElement(root), 534 self._writeElement(root2)) 535 expected = { 536 "chapter1" : root[0], 537 "note1" : root[1], 538 "warn1" : root[4] 539 } 540 self.assertEquals(dic, expected)

541

542 - def test_fromstring(self):

543 fromstring = self.etree.fromstring 544 545 root = fromstring('<doc>This is a text.</doc>') 546 self.assertEquals(0, len(root)) 547 self.assertEquals('This is a text.', root.text)

548

549 - def test_fromstringlist(self):

550 fromstringlist = self.etree.fromstringlist 551 552 root = fromstringlist(["<do", "c>T", "hi", "s is", 553 " a text.<", "/doc", ">"]) 554 self.assertEquals(0, len(root)) 555 self.assertEquals('This is a text.', root.text)

556

557 - def test_fromstringlist_characters(self):

558 fromstringlist = self.etree.fromstringlist 559 560 root = fromstringlist(list('<doc>This is a text.</doc>')) 561 self.assertEquals(0, len(root)) 562 self.assertEquals('This is a text.', root.text)

563

564 - def test_fromstringlist_single(self):

565 fromstringlist = self.etree.fromstringlist 566 567 root = fromstringlist(['<doc>This is a text.</doc>']) 568 self.assertEquals(0, len(root)) 569 self.assertEquals('This is a text.', root.text)

570

571 - def test_iselement(self):

572 iselement = self.etree.iselement 573 Element = self.etree.Element 574 ElementTree = self.etree.ElementTree 575 XML = self.etree.XML 576 Comment = self.etree.Comment 577 ProcessingInstruction = self.etree.ProcessingInstruction 578 579 el = Element('hoi') 580 self.assert_(iselement(el)) 581 582 el2 = XML('<foo/>') 583 self.assert_(iselement(el2)) 584 585 tree = ElementTree(element=Element('dag')) 586 self.assert_(not iselement(tree)) 587 self.assert_(iselement(tree.getroot())) 588 589 c = Comment('test') 590 self.assert_(iselement(c)) 591 592 p = ProcessingInstruction("test", "some text") 593 self.assert_(iselement(p))

594

595 - def test_iteration(self):

596 XML = self.etree.XML 597 598 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 599 result = [] 600 for el in root: 601 result.append(el.tag) 602 self.assertEquals(['one', 'two', 'three'], result)

603

604 - def test_iteration_empty(self):

605 XML = self.etree.XML 606 607 root = XML('<doc></doc>') 608 result = [] 609 for el in root: 610 result.append(el.tag) 611 self.assertEquals([], result)

612

613 - def test_iteration_text_only(self):

614 XML = self.etree.XML 615 616 root = XML('<doc>Text</doc>') 617 result = [] 618 for el in root: 619 result.append(el.tag) 620 self.assertEquals([], result)

621

622 - def test_iteration_crash(self):

623 # this would cause a crash in the past 624 fromstring = self.etree.fromstring 625 root = etree.fromstring('<html>x</html>') 626 for elem in root: 627 elem.tail = ''

628

629 - def test_iteration_reversed(self):

630 XML = self.etree.XML 631 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 632 result = [] 633 for el in reversed(root): 634 result.append(el.tag) 635 self.assertEquals(['three', 'two', 'one'], result)

636

637 - def test_iteration_subelement(self):

638 XML = self.etree.XML 639 640 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 641 result = [] 642 add = True 643 for el in root: 644 result.append(el.tag) 645 if add: 646 self.etree.SubElement(root, 'four') 647 add = False 648 self.assertEquals(['one', 'two', 'three', 'four'], result)

649

650 - def test_iteration_del_child(self):

651 XML = self.etree.XML 652 653 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 654 result = [] 655 for el in root: 656 result.append(el.tag) 657 del root[-1] 658 self.assertEquals(['one', 'two'], result)

659

660 - def test_iteration_double(self):

661 XML = self.etree.XML 662 663 root = XML('<doc><one/><two/></doc>') 664 result = [] 665 for el0 in root: 666 result.append(el0.tag) 667 for el1 in root: 668 result.append(el1.tag) 669 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

670

671 - def test_attribute_iterator(self):

672 XML = self.etree.XML 673 674 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />') 675 result = [] 676 for key in root.attrib: 677 result.append(key) 678 result.sort() 679 self.assertEquals(['alpha', 'beta', 'gamma'], result)

680

681 - def test_findall(self):

682 XML = self.etree.XML 683 root = XML('<a><c/><c></c></a>') 684 self.assertEquals(len(list(root.findall("c"))), 1) 685 self.assertEquals(len(list(root.findall(".//c"))), 2) 686 self.assertEquals(len(list(root.findall(".//b"))), 3) 687 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 688 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 689 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

690

691 - def test_findall_ns(self):

692 XML = self.etree.XML 693 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 694 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 695 self.assertEquals(len(list(root.findall(".//b"))), 3) 696 self.assertEquals(len(list(root.findall("b"))), 2)

697

698 - def test_element_with_attributes_keywords(self):

699 Element = self.etree.Element 700 701 el = Element('tag', foo='Foo', bar='Bar') 702 self.assertEquals('Foo', el.attrib['foo']) 703 self.assertEquals('Bar', el.attrib['bar'])

704

705 - def test_element_with_attributes(self):

706 Element = self.etree.Element 707 708 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 709 self.assertEquals('Foo', el.attrib['foo']) 710 self.assertEquals('Bar', el.attrib['bar'])

711

712 - def test_element_with_attributes_ns(self):

713 Element = self.etree.Element 714 715 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 716 self.assertEquals('Foo', el.attrib['{ns1}foo']) 717 self.assertEquals('Bar', el.attrib['{ns2}bar'])

718

719 - def test_subelement_with_attributes(self):

720 Element = self.etree.Element 721 SubElement = self.etree.SubElement 722 723 el = Element('tag') 724 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 725 self.assertEquals("Baz", el[0].attrib['baz']) 726 self.assertEquals('Foo', el[0].attrib['foo'])

727

728 - def test_subelement_with_attributes_ns(self):

729 Element = self.etree.Element 730 SubElement = self.etree.SubElement 731 732 el = Element('tag') 733 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 734 self.assertEquals('Foo', el[0].attrib['{ns1}foo']) 735 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])

736

737 - def test_write(self):

738 ElementTree = self.etree.ElementTree 739 XML = self.etree.XML 740 741 for i in range(10): 742 f = StringIO() 743 root = XML('<doc%s>This is a test.</doc%s>' % (i, i)) 744 tree = ElementTree(element=root) 745 tree.write(f) 746 data = f.getvalue() 747 self.assertEquals( 748 '<doc%s>This is a test.</doc%s>' % (i, i), 749 canonicalize(data))

750

751 - def test_write_method_html(self):

752 ElementTree = self.etree.ElementTree 753 Element = self.etree.Element 754 SubElement = self.etree.SubElement 755 756 html = Element('html') 757 body = SubElement(html, 'body') 758 p = SubElement(body, 'p') 759 p.text = "html" 760 SubElement(p, 'br').tail = "test" 761 762 tree = ElementTree(element=html) 763 f = StringIO() 764 tree.write(f, method="html") 765 data = f.getvalue().replace('\n','') 766 767 self.assertEquals('<html><body>html test</body></html>', 768 data)

769

770 - def test_write_method_text(self):

771 ElementTree = self.etree.ElementTree 772 Element = self.etree.Element 773 SubElement = self.etree.SubElement 774 775 a = Element('a') 776 a.text = "A" 777 a.tail = "tail" 778 b = SubElement(a, 'b') 779 b.text = "B" 780 b.tail = "TAIL" 781 c = SubElement(a, 'c') 782 c.text = "C" 783 784 tree = ElementTree(element=a) 785 f = StringIO() 786 tree.write(f, method="text") 787 data = f.getvalue() 788 789 self.assertEquals('ABTAILCtail', 790 data)

791

792 - def test_write_fail(self):

793 ElementTree = self.etree.ElementTree 794 XML = self.etree.XML 795 796 tree = ElementTree( XML('<doc>This is a test.</doc>') ) 797 self.assertRaises(IOError, tree.write, 798 "definitely////\\-\\nonexisting\\-\\////FILE")

799 800 # this could trigger a crash, apparently because the document 801 # reference was prematurely garbage collected

802 - def test_crash(self):

803 Element = self.etree.Element 804 805 element = Element('tag') 806 for i in range(10): 807 element.attrib['key'] = 'value' 808 value = element.attrib['key'] 809 self.assertEquals(value, 'value')

810 811 # from doctest; for some reason this caused crashes too

812 - def test_write_ElementTreeDoctest(self):

813 Element = self.etree.Element 814 ElementTree = self.etree.ElementTree 815 816 f = StringIO() 817 for i in range(10): 818 element = Element('tag%s' % i) 819 self._check_element(element) 820 tree = ElementTree(element) 821 tree.write(f) 822 self._check_element_tree(tree)

823

824 - def test_subelement_reference(self):

825 Element = self.etree.Element 826 SubElement = self.etree.SubElement 827 828 el = Element('foo') 829 el2 = SubElement(el, 'bar') 830 el3 = SubElement(el2, 'baz') 831 832 al = Element('foo2') 833 al2 = SubElement(al, 'bar2') 834 al3 = SubElement(al2, 'baz2') 835 836 # now move al2 into el 837 el.append(al2) 838 839 # now change al3 directly 840 al3.text = 'baz2-modified' 841 842 # it should have changed through this route too 843 self.assertEquals( 844 'baz2-modified', 845 el[1][0].text)

846

847 - def test_set_text(self):

848 Element = self.etree.Element 849 SubElement = self.etree.SubElement 850 851 a = Element('a') 852 b = SubElement(a, 'b') 853 a.text = 'hoi' 854 self.assertEquals( 855 'hoi', 856 a.text) 857 self.assertEquals( 858 'b', 859 a[0].tag)

860

861 - def test_set_text2(self):

862 Element = self.etree.Element 863 SubElement = self.etree.SubElement 864 865 a = Element('a') 866 a.text = 'hoi' 867 b = SubElement(a ,'b') 868 self.assertEquals( 869 'hoi', 870 a.text) 871 self.assertEquals( 872 'b', 873 a[0].tag)

874

875 - def test_set_text_none(self):

876 Element = self.etree.Element 877 878 a = Element('a') 879 880 a.text = 'foo' 881 a.text = None 882 883 self.assertEquals( 884 None, 885 a.text) 886 self.assertXML('<a></a>', a)

887

888 - def test_set_text_empty(self):

889 Element = self.etree.Element 890 891 a = Element('a') 892 self.assertEquals(None, a.text) 893 894 a.text = '' 895 self.assertEquals('', a.text) 896 self.assertXML('<a></a>', a)

897

898 - def test_tail1(self):

899 Element = self.etree.Element 900 SubElement = self.etree.SubElement 901 902 a = Element('a') 903 a.tail = 'dag' 904 self.assertEquals('dag', 905 a.tail) 906 b = SubElement(a, 'b') 907 b.tail = 'hoi' 908 self.assertEquals('hoi', 909 b.tail) 910 self.assertEquals('dag', 911 a.tail)

912

913 - def test_tail_append(self):

914 Element = self.etree.Element 915 916 a = Element('a') 917 b = Element('b') 918 b.tail = 'b_tail' 919 a.append(b) 920 self.assertEquals('b_tail', 921 b.tail)

922

923 - def test_tail_set_twice(self):

924 Element = self.etree.Element 925 SubElement = self.etree.SubElement 926 927 a = Element('a') 928 b = SubElement(a, 'b') 929 b.tail = 'foo' 930 b.tail = 'bar' 931 self.assertEquals('bar', 932 b.tail) 933 self.assertXML('<a>bar</a>', a)

934

935 - def test_tail_set_none(self):

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

944

945 - def test_comment(self):

946 Element = self.etree.Element 947 SubElement = self.etree.SubElement 948 Comment = self.etree.Comment 949 950 a = Element('a') 951 a.append(Comment('foo')) 952 self.assertEquals(a[0].tag, Comment) 953 self.assertEquals(a[0].text, 'foo')

954

955 - def test_comment_text(self):

956 Element = self.etree.Element 957 SubElement = self.etree.SubElement 958 Comment = self.etree.Comment 959 960 a = Element('a') 961 a.append(Comment('foo')) 962 self.assertEquals(a[0].text, 'foo') 963 964 a[0].text = "TEST" 965 self.assertEquals(a[0].text, 'TEST')

966

967 - def test_comment_whitespace(self):

968 Element = self.etree.Element 969 SubElement = self.etree.SubElement 970 Comment = self.etree.Comment 971 972 a = Element('a') 973 a.append(Comment(' foo ')) 974 self.assertEquals(a[0].text, ' foo ')

975

976 - def test_comment_nonsense(self):

977 Comment = self.etree.Comment 978 c = Comment('foo') 979 self.assertEquals({}, c.attrib) 980 self.assertEquals([], c.keys()) 981 self.assertEquals([], c.items()) 982 self.assertEquals(None, c.get('hoi')) 983 self.assertEquals(0, len(c)) 984 # should not iterate 985 for i in c: 986 pass

987

988 - def test_pi(self):

989 # lxml.etree separates target and text 990 Element = self.etree.Element 991 SubElement = self.etree.SubElement 992 ProcessingInstruction = self.etree.ProcessingInstruction 993 994 a = Element('a') 995 a.append(ProcessingInstruction('foo', 'some more text')) 996 self.assertEquals(a[0].tag, ProcessingInstruction) 997 self.assertXML("<a><?foo some more text?></a>", 998 a)

999

1000 - def test_processinginstruction(self):

1001 # lxml.etree separates target and text 1002 Element = self.etree.Element 1003 SubElement = self.etree.SubElement 1004 ProcessingInstruction = self.etree.PI 1005 1006 a = Element('a') 1007 a.append(ProcessingInstruction('foo', 'some more text')) 1008 self.assertEquals(a[0].tag, ProcessingInstruction) 1009 self.assertXML("<a><?foo some more text?></a>", 1010 a)

1011

1012 - def test_pi_nonsense(self):

1013 ProcessingInstruction = self.etree.ProcessingInstruction 1014 pi = ProcessingInstruction('foo') 1015 self.assertEquals({}, pi.attrib) 1016 self.assertEquals([], pi.keys()) 1017 self.assertEquals([], pi.items()) 1018 self.assertEquals(None, pi.get('hoi')) 1019 self.assertEquals(0, len(pi)) 1020 # should not iterate 1021 for i in pi: 1022 pass

1023

1024 - def test_setitem(self):

1025 Element = self.etree.Element 1026 SubElement = self.etree.SubElement 1027 1028 a = Element('a') 1029 b = SubElement(a, 'b') 1030 c = Element('c') 1031 a[0] = c 1032 self.assertEquals( 1033 c, 1034 a[0]) 1035 self.assertXML('<a><c></c></a>', 1036 a) 1037 self.assertXML('', 1038 b)

1039

1040 - def test_setitem2(self):

1041 Element = self.etree.Element 1042 SubElement = self.etree.SubElement 1043 1044 a = Element('a') 1045 for i in range(5): 1046 b = SubElement(a, 'b%s' % i) 1047 c = SubElement(b, 'c') 1048 for i in range(5): 1049 d = Element('d') 1050 e = SubElement(d, 'e') 1051 a[i] = d 1052 self.assertXML( 1053 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>', 1054 a) 1055 self.assertXML('<c></c>', 1056 c)

1057

1058 - def test_setitem_replace(self):

1059 Element = self.etree.Element 1060 SubElement = self.etree.SubElement 1061 1062 a = Element('a') 1063 SubElement(a, 'b') 1064 d = Element('d') 1065 a[0] = d 1066 self.assertXML('<a><d></d></a>', a)

1067

1068 - def test_setitem_indexerror(self):

1069 Element = self.etree.Element 1070 SubElement = self.etree.SubElement 1071 1072 a = Element('a') 1073 b = SubElement(a, 'b') 1074 1075 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1076

1077 - def test_setitem_tail(self):

1078 Element = self.etree.Element 1079 SubElement = self.etree.SubElement 1080 1081 a = Element('a') 1082 b = SubElement(a, 'b') 1083 b.tail = 'B2' 1084 c = Element('c') 1085 c.tail = 'C2' 1086 1087 a[0] = c 1088 self.assertXML( 1089 '<a><c></c>C2</a>', 1090 a)

1091

1092 - def test_tag_write(self):

1093 Element = self.etree.Element 1094 SubElement = self.etree.SubElement 1095 1096 a = Element('a') 1097 b = SubElement(a, 'b') 1098 1099 a.tag = 'c' 1100 1101 self.assertEquals( 1102 'c', 1103 a.tag) 1104 1105 self.assertXML( 1106 '<c></c>', 1107 a)

1108

1109 - def test_tag_reset_ns(self):

1110 Element = self.etree.Element 1111 SubElement = self.etree.SubElement 1112 tostring = self.etree.tostring 1113 1114 a = Element('{a}a') 1115 b1 = SubElement(a, '{a}b') 1116 b2 = SubElement(a, '{b}b') 1117 1118 self.assertEquals('{a}b', b1.tag) 1119 1120 b1.tag = 'c' 1121 1122 # can't use C14N here! 1123 self.assertEquals('c', b1.tag) 1124 self.assertEquals('<c', tostring(b1)[:2]) 1125 self.assert_('<c' in tostring(a))

1126

1127 - def test_tag_reset_root_ns(self):

1128 Element = self.etree.Element 1129 SubElement = self.etree.SubElement 1130 tostring = self.etree.tostring 1131 1132 a = Element('{a}a') 1133 b1 = SubElement(a, '{a}b') 1134 b2 = SubElement(a, '{b}b') 1135 1136 a.tag = 'c' 1137 1138 self.assertEquals( 1139 'c', 1140 a.tag) 1141 1142 # can't use C14N here! 1143 self.assertEquals('c', a.tag) 1144 self.assertEquals('<c', tostring(a)[:2])

1145

1146 - def test_tag_str_subclass(self):

1147 Element = self.etree.Element 1148 1149 class strTest(str): 1150 pass

1151 1152 a = Element("a") 1153 a.tag = strTest("TAG") 1154 self.assertXML('<TAG></TAG>', 1155 a) 1156

1157 - def test_delitem(self):

1158 Element = self.etree.Element 1159 SubElement = self.etree.SubElement 1160 1161 a = Element('a') 1162 b = SubElement(a, 'b') 1163 c = SubElement(a, 'c') 1164 d = SubElement(a, 'd') 1165 1166 del a[1] 1167 self.assertXML( 1168 '<a><d></d></a>', 1169 a) 1170 1171 del a[0] 1172 self.assertXML( 1173 '<a><d></d></a>', 1174 a) 1175 1176 del a[0] 1177 self.assertXML( 1178 '<a></a>', 1179 a) 1180 # move deleted element into other tree afterwards 1181 other = Element('other') 1182 other.append(c) 1183 self.assertXML( 1184 '<other><c></c></other>', 1185 other)

1186

1187 - def test_del_insert(self):

1188 Element = self.etree.Element 1189 SubElement = self.etree.SubElement 1190 1191 a = Element('a') 1192 b = SubElement(a, 'b') 1193 bs = SubElement(b, 'bs') 1194 c = SubElement(a, 'c') 1195 cs = SubElement(c, 'cs') 1196 1197 el = a[0] 1198 self.assertXML( 1199 '<a><bs></bs><c><cs></cs></c></a>', 1200 a) 1201 self.assertXML('<bs></bs>', b) 1202 self.assertXML('<c><cs></cs></c>', c) 1203 1204 del a[0] 1205 self.assertXML( 1206 '<a><c><cs></cs></c></a>', 1207 a) 1208 self.assertXML('<bs></bs>', b) 1209 self.assertXML('<c><cs></cs></c>', c) 1210 1211 a.insert(0, el) 1212 self.assertXML( 1213 '<a><bs></bs><c><cs></cs></c></a>', 1214 a) 1215 self.assertXML('<bs></bs>', b) 1216 self.assertXML('<c><cs></cs></c>', c)

1217

1218 - def test_del_setitem(self):

1219 Element = self.etree.Element 1220 SubElement = self.etree.SubElement 1221 1222 a = Element('a') 1223 b = SubElement(a, 'b') 1224 bs = SubElement(b, 'bs') 1225 c = SubElement(a, 'c') 1226 cs = SubElement(c, 'cs') 1227 1228 el = a[0] 1229 del a[0] 1230 a[0] = el 1231 self.assertXML( 1232 '<a><bs></bs></a>', 1233 a) 1234 self.assertXML('<bs></bs>', b) 1235 self.assertXML('<c><cs></cs></c>', c)

1236

1237 - def test_del_setslice(self):

1238 Element = self.etree.Element 1239 SubElement = self.etree.SubElement 1240 1241 a = Element('a') 1242 b = SubElement(a, 'b') 1243 bs = SubElement(b, 'bs') 1244 c = SubElement(a, 'c') 1245 cs = SubElement(c, 'cs') 1246 1247 el = a[0] 1248 del a[0] 1249 a[0:0] = [el] 1250 self.assertXML( 1251 '<a><bs></bs><c><cs></cs></c></a>', 1252 a) 1253 self.assertXML('<bs></bs>', b) 1254 self.assertXML('<c><cs></cs></c>', c)

1255

1256 - def test_replace_slice_tail(self):

1257 XML = self.etree.XML 1258 a = XML('<a>B2<c></c>C2</a>') 1259 b, c = a 1260 1261 a[:] = [] 1262 1263 self.assertEquals("B2", b.tail) 1264 self.assertEquals("C2", c.tail)

1265

1266 - def test_delitem_tail(self):

1267 ElementTree = self.etree.ElementTree 1268 f = StringIO('<a>B2<c></c>C2</a>') 1269 doc = ElementTree(file=f) 1270 a = doc.getroot() 1271 del a[0] 1272 self.assertXML( 1273 '<a><c></c>C2</a>', 1274 a)

1275

1276 - def test_clear(self):

1277 Element = self.etree.Element 1278 1279 a = Element('a') 1280 a.text = 'foo' 1281 a.tail = 'bar' 1282 a.set('hoi', 'dag') 1283 a.clear() 1284 self.assertEquals(None, a.text) 1285 self.assertEquals(None, a.tail) 1286 self.assertEquals(None, a.get('hoi')) 1287 self.assertEquals('a', a.tag)

1288

1289 - def test_clear_sub(self):

1290 Element = self.etree.Element 1291 SubElement = self.etree.SubElement 1292 1293 a = Element('a') 1294 a.text = 'foo' 1295 a.tail = 'bar' 1296 a.set('hoi', 'dag') 1297 b = SubElement(a, 'b') 1298 c = SubElement(b, 'c') 1299 a.clear() 1300 self.assertEquals(None, a.text) 1301 self.assertEquals(None, a.tail) 1302 self.assertEquals(None, a.get('hoi')) 1303 self.assertEquals('a', a.tag) 1304 self.assertEquals(0, len(a)) 1305 self.assertXML('<a></a>', 1306 a) 1307 self.assertXML('<c></c>', 1308 b)

1309

1310 - def test_clear_tail(self):

1311 ElementTree = self.etree.ElementTree 1312 f = StringIO('<a>B2<c></c>C2</a>') 1313 doc = ElementTree(file=f) 1314 a = doc.getroot() 1315 a.clear() 1316 self.assertXML( 1317 '<a></a>', 1318 a)

1319

1320 - def test_insert(self):

1321 Element = self.etree.Element 1322 SubElement = self.etree.SubElement 1323 1324 a = Element('a') 1325 b = SubElement(a, 'b') 1326 c = SubElement(a, 'c') 1327 d = Element('d') 1328 a.insert(0, d) 1329 1330 self.assertEquals( 1331 d, 1332 a[0]) 1333 1334 self.assertXML( 1335 '<a><d></d><c></c></a>', 1336 a) 1337 1338 e = Element('e') 1339 a.insert(2, e) 1340 self.assertEquals( 1341 e, 1342 a[2]) 1343 self.assertXML( 1344 '<a><d></d><e></e><c></c></a>', 1345 a)

1346

1347 - def test_insert_beyond_index(self):

1348 Element = self.etree.Element 1349 SubElement = self.etree.SubElement 1350 1351 a = Element('a') 1352 b = SubElement(a, 'b') 1353 c = Element('c') 1354 1355 a.insert(2, c) 1356 self.assertEquals( 1357 c, 1358 a[1]) 1359 self.assertXML( 1360 '<a><c></c></a>', 1361 a)

1362

1363 - def test_insert_negative(self):

1364 Element = self.etree.Element 1365 SubElement = self.etree.SubElement 1366 1367 a = Element('a') 1368 b = SubElement(a, 'b') 1369 c = SubElement(a, 'c') 1370 1371 d = Element('d') 1372 a.insert(-1, d) 1373 self.assertEquals( 1374 d, 1375 a[-2]) 1376 self.assertXML( 1377 '<a><d></d><c></c></a>', 1378 a)

1379

1380 - def test_insert_tail(self):

1381 Element = self.etree.Element 1382 SubElement = self.etree.SubElement 1383 1384 a = Element('a') 1385 b = SubElement(a, 'b') 1386 1387 c = Element('c') 1388 c.tail = 'C2' 1389 1390 a.insert(0, c) 1391 self.assertXML( 1392 '<a><c></c>C2</a>', 1393 a)

1394

1395 - def test_remove(self):

1396 Element = self.etree.Element 1397 SubElement = self.etree.SubElement 1398 1399 a = Element('a') 1400 b = SubElement(a, 'b') 1401 c = SubElement(a, 'c') 1402 1403 a.remove(b) 1404 self.assertEquals( 1405 c, 1406 a[0]) 1407 self.assertXML( 1408 '<a><c></c></a>', 1409 a)

1410

1411 - def test_remove_ns(self):

1412 Element = self.etree.Element 1413 SubElement = self.etree.SubElement 1414 1415 a = Element('{http://test}a') 1416 b = SubElement(a, '{http://test}b') 1417 c = SubElement(a, '{http://test}c') 1418 1419 a.remove(b) 1420 self.assertXML( 1421 '<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>', 1422 a) 1423 self.assertXML( 1424 '<ns0:b xmlns:ns0="http://test"></ns0:b>', 1425 b)

1426

1427 - def test_remove_nonexisting(self):

1428 Element = self.etree.Element 1429 SubElement = self.etree.SubElement 1430 1431 a = Element('a') 1432 b = SubElement(a, 'b') 1433 c = SubElement(a, 'c') 1434 d = Element('d') 1435 self.assertRaises( 1436 ValueError, a.remove, d)

1437

1438 - def test_remove_tail(self):

1439 Element = self.etree.Element 1440 SubElement = self.etree.SubElement 1441 1442 a = Element('a') 1443 b = SubElement(a, 'b') 1444 b.tail = 'b2' 1445 a.remove(b) 1446 self.assertXML( 1447 '<a></a>', 1448 a) 1449 self.assertEquals('b2', b.tail)

1450

1451 - def _test_getchildren(self):

1452 Element = self.etree.Element 1453 SubElement = self.etree.SubElement 1454 1455 a = Element('a') 1456 b = SubElement(a, 'b') 1457 c = SubElement(a, 'c') 1458 d = SubElement(b, 'd') 1459 e = SubElement(c, 'e') 1460 self.assertXML( 1461 '<a><d></d><c><e></e></c></a>', 1462 a) 1463 self.assertEquals( 1464 [b, c], 1465 a.getchildren()) 1466 self.assertEquals( 1467 [d], 1468 b.getchildren()) 1469 self.assertEquals( 1470 [], 1471 d.getchildren())

1472

1473 - def test_makeelement(self):

1474 Element = self.etree.Element 1475 1476 a = Element('a') 1477 b = a.makeelement('c', {'hoi':'dag'}) 1478 self.assertXML( 1479 '<c hoi="dag"></c>', 1480 b)

1481

1482 - def test_iter(self):

1483 Element = self.etree.Element 1484 SubElement = self.etree.SubElement 1485 1486 a = Element('a') 1487 b = SubElement(a, 'b') 1488 c = SubElement(a, 'c') 1489 d = SubElement(b, 'd') 1490 e = SubElement(c, 'e') 1491 1492 self.assertEquals( 1493 [a, b, d, c, e], 1494 list(a.iter())) 1495 self.assertEquals( 1496 [d], 1497 list(d.iter()))

1498

1499 - def test_getiterator(self):

1500 Element = self.etree.Element 1501 SubElement = self.etree.SubElement 1502 1503 a = Element('a') 1504 b = SubElement(a, 'b') 1505 c = SubElement(a, 'c') 1506 d = SubElement(b, 'd') 1507 e = SubElement(c, 'e') 1508 1509 self.assertEquals( 1510 [a, b, d, c, e], 1511 list(a.getiterator())) 1512 self.assertEquals( 1513 [d], 1514 list(d.getiterator()))

1515

1516 - def test_getiterator_empty(self):

1517 Element = self.etree.Element 1518 SubElement = self.etree.SubElement 1519 1520 a = Element('a') 1521 b = SubElement(a, 'b') 1522 c = SubElement(a, 'c') 1523 d = SubElement(b, 'd') 1524 e = SubElement(c, 'e') 1525 1526 self.assertEquals( 1527 [], 1528 list(a.getiterator('none'))) 1529 self.assertEquals( 1530 [], 1531 list(e.getiterator('none'))) 1532 self.assertEquals( 1533 [e], 1534 list(e.getiterator()))

1535

1536 - def test_getiterator_filter(self):

1537 Element = self.etree.Element 1538 SubElement = self.etree.SubElement 1539 1540 a = Element('a') 1541 b = SubElement(a, 'b') 1542 c = SubElement(a, 'c') 1543 d = SubElement(b, 'd') 1544 e = SubElement(c, 'e') 1545 1546 self.assertEquals( 1547 [a], 1548 list(a.getiterator('a'))) 1549 a2 = SubElement(e, 'a') 1550 self.assertEquals( 1551 [a, a2], 1552 list(a.getiterator('a'))) 1553 self.assertEquals( 1554 [a2], 1555 list(c.getiterator('a')))

1556

1557 - def test_getiterator_filter_all(self):

1558 Element = self.etree.Element 1559 SubElement = self.etree.SubElement 1560 1561 a = Element('a') 1562 b = SubElement(a, 'b') 1563 c = SubElement(a, 'c') 1564 d = SubElement(b, 'd') 1565 e = SubElement(c, 'e') 1566 1567 self.assertEquals( 1568 [a, b, d, c, e], 1569 list(a.getiterator('*')))

1570

1571 - def test_getiterator_filter_comment(self):

1572 Element = self.etree.Element 1573 Comment = self.etree.Comment 1574 SubElement = self.etree.SubElement 1575 1576 a = Element('a') 1577 b = SubElement(a, 'b') 1578 comment_b = Comment("TEST-b") 1579 b.append(comment_b) 1580 1581 self.assertEquals( 1582 [comment_b], 1583 list(a.getiterator(Comment))) 1584 1585 comment_a = Comment("TEST-a") 1586 a.append(comment_a) 1587 1588 self.assertEquals( 1589 [comment_b, comment_a], 1590 list(a.getiterator(Comment))) 1591 1592 self.assertEquals( 1593 [comment_b], 1594 list(b.getiterator(Comment)))

1595

1596 - def test_getiterator_filter_pi(self):

1597 Element = self.etree.Element 1598 PI = self.etree.ProcessingInstruction 1599 SubElement = self.etree.SubElement 1600 1601 a = Element('a') 1602 b = SubElement(a, 'b') 1603 pi_b = PI("TEST-b") 1604 b.append(pi_b) 1605 1606 self.assertEquals( 1607 [pi_b], 1608 list(a.getiterator(PI))) 1609 1610 pi_a = PI("TEST-a") 1611 a.append(pi_a) 1612 1613 self.assertEquals( 1614 [pi_b, pi_a], 1615 list(a.getiterator(PI))) 1616 1617 self.assertEquals( 1618 [pi_b], 1619 list(b.getiterator(PI)))

1620

1621 - def test_getiterator_with_text(self):

1622 Element = self.etree.Element 1623 SubElement = self.etree.SubElement 1624 1625 a = Element('a') 1626 a.text = 'a' 1627 b = SubElement(a, 'b') 1628 b.text = 'b' 1629 b.tail = 'b1' 1630 c = SubElement(a, 'c') 1631 c.text = 'c' 1632 c.tail = 'c1' 1633 d = SubElement(b, 'd') 1634 c.text = 'd' 1635 c.tail = 'd1' 1636 e = SubElement(c, 'e') 1637 e.text = 'e' 1638 e.tail = 'e1' 1639 1640 self.assertEquals( 1641 [a, b, d, c, e], 1642 list(a.getiterator()))

1643 #self.assertEquals( 1644 # [d], 1645 # list(d.getiterator())) 1646

1647 - def test_getiterator_filter_with_text(self):

1648 Element = self.etree.Element 1649 SubElement = self.etree.SubElement 1650 1651 a = Element('a') 1652 a.text = 'a' 1653 b = SubElement(a, 'b') 1654 b.text = 'b' 1655 b.tail = 'b1' 1656 c = SubElement(a, 'c') 1657 c.text = 'c' 1658 c.tail = 'c1' 1659 d = SubElement(b, 'd') 1660 c.text = 'd' 1661 c.tail = 'd1' 1662 e = SubElement(c, 'e') 1663 e.text = 'e' 1664 e.tail = 'e1' 1665 1666 self.assertEquals( 1667 [a], 1668 list(a.getiterator('a'))) 1669 a2 = SubElement(e, 'a') 1670 self.assertEquals( 1671 [a, a2], 1672 list(a.getiterator('a'))) 1673 self.assertEquals( 1674 [a2], 1675 list(e.getiterator('a')))

1676

1677 - def test_attribute_manipulation(self):

1678 Element = self.etree.Element 1679 1680 a = Element('a') 1681 a.attrib['foo'] = 'Foo' 1682 a.attrib['bar'] = 'Bar' 1683 self.assertEquals('Foo', a.attrib['foo']) 1684 del a.attrib['foo'] 1685 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

1686

1687 - def test_getslice(self):

1688 Element = self.etree.Element 1689 SubElement = self.etree.SubElement 1690 1691 a = Element('a') 1692 b = SubElement(a, 'b') 1693 c = SubElement(a, 'c') 1694 d = SubElement(a, 'd') 1695 1696 self.assertEquals( 1697 [b, c], 1698 a[0:2]) 1699 self.assertEquals( 1700 [b, c, d], 1701 a[:]) 1702 self.assertEquals( 1703 [b, c, d], 1704 a[:10]) 1705 self.assertEquals( 1706 [b], 1707 a[0:1]) 1708 self.assertEquals( 1709 [], 1710 a[10:12])

1711

1712 - def test_getslice_negative(self):

1713 Element = self.etree.Element 1714 SubElement = self.etree.SubElement 1715 1716 a = Element('a') 1717 b = SubElement(a, 'b') 1718 c = SubElement(a, 'c') 1719 d = SubElement(a, 'd') 1720 1721 self.assertEquals( 1722 [d], 1723 a[-1:]) 1724 self.assertEquals( 1725 [c, d], 1726 a[-2:]) 1727 self.assertEquals( 1728 [c], 1729 a[-2:-1]) 1730 self.assertEquals( 1731 [b, c], 1732 a[-3:-1]) 1733 self.assertEquals( 1734 [b, c], 1735 a[-3:2])

1736

1737 - def test_getslice_step(self):

1738 Element = self.etree.Element 1739 SubElement = self.etree.SubElement 1740 1741 a = Element('a') 1742 b = SubElement(a, 'b') 1743 c = SubElement(a, 'c') 1744 d = SubElement(a, 'd') 1745 e = SubElement(a, 'e') 1746 1747 self.assertEquals( 1748 [e,d,c,b], 1749 a[::-1]) 1750 self.assertEquals( 1751 [b,d], 1752 a[::2]) 1753 self.assertEquals( 1754 [e,c], 1755 a[::-2]) 1756 self.assertEquals( 1757 [d,c], 1758 a[-2:0:-1]) 1759 self.assertEquals( 1760 [e], 1761 a[:1:-2])

1762

1763 - def test_getslice_text(self):

1764 ElementTree = self.etree.ElementTree 1765 1766 f = StringIO('<a>BB1<c>C</c>C1</a>') 1767 doc = ElementTree(file=f) 1768 a = doc.getroot() 1769 b = a[0] 1770 c = a[1] 1771 self.assertEquals( 1772 [b, c], 1773 a[:]) 1774 self.assertEquals( 1775 [b], 1776 a[0:1]) 1777 self.assertEquals( 1778 [c], 1779 a[1:])

1780

1781 - def test_comment_getitem_getslice(self):

1782 Element = self.etree.Element 1783 Comment = self.etree.Comment 1784 SubElement = self.etree.SubElement 1785 1786 a = Element('a') 1787 b = SubElement(a, 'b') 1788 foo = Comment('foo') 1789 a.append(foo) 1790 c = SubElement(a, 'c') 1791 self.assertEquals( 1792 [b, foo, c], 1793 a[:]) 1794 self.assertEquals( 1795 foo, 1796 a[1]) 1797 a[1] = new = Element('new') 1798 self.assertEquals( 1799 new, 1800 a[1]) 1801 self.assertXML( 1802 '<a><new></new><c></c></a>', 1803 a)

1804

1805 - def test_delslice(self):

1806 Element = self.etree.Element 1807 SubElement = self.etree.SubElement 1808 1809 a = Element('a') 1810 b = SubElement(a, 'b') 1811 c = SubElement(a, 'c') 1812 d = SubElement(a, 'd') 1813 e = SubElement(a, 'e') 1814 1815 del a[1:3] 1816 self.assertEquals( 1817 [b, e], 1818 list(a))

1819

1820 - def test_delslice_negative1(self):

1821 Element = self.etree.Element 1822 SubElement = self.etree.SubElement 1823 1824 a = Element('a') 1825 b = SubElement(a, 'b') 1826 c = SubElement(a, 'c') 1827 d = SubElement(a, 'd') 1828 e = SubElement(a, 'e') 1829 1830 del a[1:-1] 1831 self.assertEquals( 1832 [b, e], 1833 list(a))

1834

1835 - def test_delslice_negative2(self):

1836 Element = self.etree.Element 1837 SubElement = self.etree.SubElement 1838 1839 a = Element('a') 1840 b = SubElement(a, 'b') 1841 c = SubElement(a, 'c') 1842 d = SubElement(a, 'd') 1843 e = SubElement(a, 'e') 1844 1845 del a[-3:-1] 1846 self.assertEquals( 1847 [b, e], 1848 list(a))

1849

1850 - def test_delslice_step(self):

1851 Element = self.etree.Element 1852 SubElement = self.etree.SubElement 1853 1854 a = Element('a') 1855 b = SubElement(a, 'b') 1856 c = SubElement(a, 'c') 1857 d = SubElement(a, 'd') 1858 e = SubElement(a, 'e') 1859 1860 del a[1::2] 1861 self.assertEquals( 1862 [b, d], 1863 list(a))

1864

1865 - def test_delslice_step_negative(self):

1866 Element = self.etree.Element 1867 SubElement = self.etree.SubElement 1868 1869 a = Element('a') 1870 b = SubElement(a, 'b') 1871 c = SubElement(a, 'c') 1872 d = SubElement(a, 'd') 1873 e = SubElement(a, 'e') 1874 1875 del a[::-1] 1876 self.assertEquals( 1877 [], 1878 list(a))

1879

1880 - def test_delslice_step_negative2(self):

1881 Element = self.etree.Element 1882 SubElement = self.etree.SubElement 1883 1884 a = Element('a') 1885 b = SubElement(a, 'b') 1886 c = SubElement(a, 'c') 1887 d = SubElement(a, 'd') 1888 e = SubElement(a, 'e') 1889 1890 del a[::-2] 1891 self.assertEquals( 1892 [b, d], 1893 list(a))

1894

1895 - def test_delslice_child_tail(self):

1896 ElementTree = self.etree.ElementTree 1897 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1898 doc = ElementTree(file=f) 1899 a = doc.getroot() 1900 del a[1:3] 1901 self.assertXML( 1902 '<a>B2<e></e>E2</a>', 1903 a)

1904

1905 - def test_delslice_tail(self):

1906 XML = self.etree.XML 1907 a = XML('<a>B2<c></c>C2</a>') 1908 b, c = a 1909 1910 del a[:] 1911 1912 self.assertEquals("B2", b.tail) 1913 self.assertEquals("C2", c.tail)

1914

1915 - def test_delslice_memory(self):

1916 # this could trigger a crash 1917 Element = self.etree.Element 1918 SubElement = self.etree.SubElement 1919 a = Element('a') 1920 b = SubElement(a, 'b') 1921 c = SubElement(b, 'c') 1922 del b # no more reference to b 1923 del a[:] 1924 self.assertEquals('c', c.tag)

1925

1926 - def test_setslice(self):

1927 Element = self.etree.Element 1928 SubElement = self.etree.SubElement 1929 1930 a = Element('a') 1931 b = SubElement(a, 'b') 1932 c = SubElement(a, 'c') 1933 d = SubElement(a, 'd') 1934 1935 e = Element('e') 1936 f = Element('f') 1937 g = Element('g') 1938 1939 s = [e, f, g] 1940 a[1:2] = s 1941 self.assertEquals( 1942 [b, e, f, g, d], 1943 list(a))

1944

1945 - def test_setslice_all(self):

1946 Element = self.etree.Element 1947 SubElement = self.etree.SubElement 1948 1949 a = Element('a') 1950 b = SubElement(a, 'b') 1951 c = SubElement(a, 'c') 1952 1953 e = Element('e') 1954 f = Element('f') 1955 g = Element('g') 1956 1957 s = [e, f, g] 1958 a[:] = s 1959 self.assertEquals( 1960 [e, f, g], 1961 list(a))

1962

1963 - def test_setslice_all_empty(self):

1964 Element = self.etree.Element 1965 SubElement = self.etree.SubElement 1966 1967 a = Element('a') 1968 1969 e = Element('e') 1970 f = Element('f') 1971 g = Element('g') 1972 1973 s = [e, f, g] 1974 a[:] = s 1975 self.assertEquals( 1976 [e, f, g], 1977 list(a))

1978

1979 - def test_setslice_all_replace(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 1988 s = [b, c, d] 1989 a[:] = s 1990 self.assertEquals( 1991 [b, c, d], 1992 list(a))

1993

1994 - def test_setslice_all_replace_reversed(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 2003 s = [d, c, b] 2004 a[:] = s 2005 self.assertEquals( 2006 [d, c, b], 2007 list(a))

2008

2009 - def test_setslice_all_replace_reversed_ns1(self):

2010 Element = self.etree.Element 2011 SubElement = self.etree.SubElement 2012 2013 a = Element('{ns}a') 2014 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2015 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2016 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2017 2018 s = [d, c, b] 2019 a[:] = s 2020 self.assertEquals( 2021 [d, c, b], 2022 list(a)) 2023 self.assertEquals( 2024 ['{ns}d', '{ns}c', '{ns}b'], 2025 [ child.tag for child in a ]) 2026 2027 self.assertEquals( 2028 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2029 [ child.attrib.keys() for child in a ])

2030

2031 - def test_setslice_all_replace_reversed_ns2(self):

2032 Element = self.etree.Element 2033 SubElement = self.etree.SubElement 2034 2035 a = Element('{ns}a') 2036 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 2037 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 2038 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 2039 2040 s = [d, c, b] 2041 a[:] = s 2042 self.assertEquals( 2043 [d, c, b], 2044 list(a)) 2045 self.assertEquals( 2046 ['{ns3}d', '{ns2}c', '{ns1}b'], 2047 [ child.tag for child in a ]) 2048 2049 self.assertEquals( 2050 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 2051 [ child.attrib.keys() for child in a ])

2052

2053 - def test_setslice_end(self):

2054 Element = self.etree.Element 2055 SubElement = self.etree.SubElement 2056 2057 a = Element('a') 2058 b = SubElement(a, 'b') 2059 c = SubElement(a, 'c') 2060 2061 e = Element('e') 2062 f = Element('f') 2063 g = Element('g') 2064 h = Element('h') 2065 2066 s = [e, f] 2067 a[99:] = s 2068 self.assertEquals( 2069 [a, b, e, f], 2070 list(a)) 2071 2072 s = [g, h] 2073 a[:0] = s 2074 self.assertEquals( 2075 [g, h, a, b, e, f], 2076 list(a))

2077

2078 - def test_setslice_single(self):

2079 Element = self.etree.Element 2080 SubElement = self.etree.SubElement 2081 2082 a = Element('a') 2083 b = SubElement(a, 'b') 2084 c = SubElement(a, 'c') 2085 2086 e = Element('e') 2087 f = Element('f') 2088 2089 s = [e] 2090 a[0:1] = s 2091 self.assertEquals( 2092 [e, c], 2093 list(a)) 2094 2095 s = [f] 2096 a[1:2] = s 2097 self.assertEquals( 2098 [e, f], 2099 list(a))

2100

2101 - def test_setslice_tail(self):

2102 ElementTree = self.etree.ElementTree 2103 Element = self.etree.Element 2104 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2105 doc = ElementTree(file=f) 2106 a = doc.getroot() 2107 x = Element('x') 2108 y = Element('y') 2109 z = Element('z') 2110 x.tail = 'X2' 2111 y.tail = 'Y2' 2112 z.tail = 'Z2' 2113 a[1:3] = [x, y, z] 2114 self.assertXML( 2115 '<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>', 2116 a)

2117

2118 - def test_setslice_negative(self):

2119 Element = self.etree.Element 2120 SubElement = self.etree.SubElement 2121 2122 a = Element('a') 2123 b = SubElement(a, 'b') 2124 c = SubElement(a, 'c') 2125 d = SubElement(a, 'd') 2126 2127 x = Element('x') 2128 y = Element('y') 2129 2130 a[1:-1] = [x, y] 2131 self.assertEquals( 2132 [b, x, y, d], 2133 list(a))

2134

2135 - def test_setslice_negative2(self):

2136 Element = self.etree.Element 2137 SubElement = self.etree.SubElement 2138 2139 a = Element('a') 2140 b = SubElement(a, 'b') 2141 c = SubElement(a, 'c') 2142 d = SubElement(a, 'd') 2143 2144 x = Element('x') 2145 y = Element('y') 2146 2147 a[1:-2] = [x, y] 2148 self.assertEquals( 2149 [b, x, y, c, d], 2150 list(a))

2151

2152 - def test_setslice_end(self):

2153 Element = self.etree.Element 2154 SubElement = self.etree.SubElement 2155 2156 a = Element('a') 2157 b = SubElement(a, 'b') 2158 c = SubElement(a, 'c') 2159 d = SubElement(a, 'd') 2160 2161 e = Element('e') 2162 f = Element('f') 2163 g = Element('g') 2164 2165 s = [e, f, g] 2166 a[3:] = s 2167 self.assertEquals( 2168 [b, c, d, e, f, g], 2169 list(a))

2170

2171 - def test_setslice_empty(self):

2172 Element = self.etree.Element 2173 2174 a = Element('a') 2175 2176 b = Element('b') 2177 c = Element('c') 2178 2179 a[:] = [b, c] 2180 self.assertEquals( 2181 [b, c], 2182 list(a))

2183

2184 - def test_tail_elementtree_root(self):

2185 Element = self.etree.Element 2186 ElementTree = self.etree.ElementTree 2187 2188 a = Element('a') 2189 a.tail = 'A2' 2190 t = ElementTree(element=a) 2191 self.assertEquals('A2', 2192 a.tail)

2193

2194 - def test_elementtree_getiterator(self):

2195 Element = self.etree.Element 2196 SubElement = self.etree.SubElement 2197 ElementTree = self.etree.ElementTree 2198 2199 a = Element('a') 2200 b = SubElement(a, 'b') 2201 c = SubElement(a, 'c') 2202 d = SubElement(b, 'd') 2203 e = SubElement(c, 'e') 2204 t = ElementTree(element=a) 2205 2206 self.assertEquals( 2207 [a, b, d, c, e], 2208 list(t.getiterator()))

2209

2210 - def test_elementtree_getiterator_filter(self):

2211 Element = self.etree.Element 2212 SubElement = self.etree.SubElement 2213 ElementTree = self.etree.ElementTree 2214 a = Element('a') 2215 b = SubElement(a, 'b') 2216 c = SubElement(a, 'c') 2217 d = SubElement(b, 'd') 2218 e = SubElement(c, 'e') 2219 t = ElementTree(element=a) 2220 2221 self.assertEquals( 2222 [a], 2223 list(t.getiterator('a'))) 2224 a2 = SubElement(e, 'a') 2225 self.assertEquals( 2226 [a, a2], 2227 list(t.getiterator('a')))

2228

2229 - def test_ns_access(self):

2230 ElementTree = self.etree.ElementTree 2231 ns = 'http://xml.infrae.com/1' 2232 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2233 t = ElementTree(file=f) 2234 a = t.getroot() 2235 self.assertEquals('{%s}a' % ns, 2236 a.tag) 2237 self.assertEquals('{%s}b' % ns, 2238 a[0].tag)

2239

2240 - def test_ns_access2(self):

2241 ElementTree = self.etree.ElementTree 2242 ns = 'http://xml.infrae.com/1' 2243 ns2 = 'http://xml.infrae.com/2' 2244 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2245 t = ElementTree(file=f) 2246 a = t.getroot() 2247 self.assertEquals('{%s}a' % ns, 2248 a.tag) 2249 self.assertEquals('{%s}b' % ns, 2250 a[0].tag) 2251 self.assertEquals('{%s}b' % ns2, 2252 a[1].tag)

2253

2254 - def test_ns_setting(self):

2255 Element = self.etree.Element 2256 SubElement = self.etree.SubElement 2257 ns = 'http://xml.infrae.com/1' 2258 ns2 = 'http://xml.infrae.com/2' 2259 a = Element('{%s}a' % ns) 2260 b = SubElement(a, '{%s}b' % ns2) 2261 c = SubElement(a, '{%s}c' % ns) 2262 self.assertEquals('{%s}a' % ns, 2263 a.tag) 2264 self.assertEquals('{%s}b' % ns2, 2265 b.tag) 2266 self.assertEquals('{%s}c' % ns, 2267 c.tag) 2268 self.assertEquals('{%s}a' % ns, 2269 a.tag) 2270 self.assertEquals('{%s}b' % ns2, 2271 b.tag) 2272 self.assertEquals('{%s}c' % ns, 2273 c.tag)

2274

2275 - def test_ns_tag_parse(self):

2276 Element = self.etree.Element 2277 SubElement = self.etree.SubElement 2278 ElementTree = self.etree.ElementTree 2279 2280 ns = 'http://xml.infrae.com/1' 2281 ns2 = 'http://xml.infrae.com/2' 2282 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2283 t = ElementTree(file=f) 2284 2285 a = t.getroot() 2286 self.assertEquals('{%s}a' % ns, 2287 a.tag) 2288 self.assertEquals('{%s}b' % ns2, 2289 a[0].tag) 2290 self.assertEquals('{%s}b' % ns, 2291 a[1].tag)

2292

2293 - def test_ns_attr(self):

2294 Element = self.etree.Element 2295 ns = 'http://xml.infrae.com/1' 2296 ns2 = 'http://xml.infrae.com/2' 2297 a = Element('a') 2298 a.set('{%s}foo' % ns, 'Foo') 2299 a.set('{%s}bar' % ns2, 'Bar') 2300 self.assertEquals( 2301 'Foo', 2302 a.get('{%s}foo' % ns)) 2303 self.assertEquals( 2304 'Bar', 2305 a.get('{%s}bar' % ns2)) 2306 try: 2307 self.assertXML( 2308 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2), 2309 a) 2310 except AssertionError: 2311 self.assertXML( 2312 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns), 2313 a)

2314

2315 - def test_ns_move(self):

2316 Element = self.etree.Element 2317 ElementTree = self.etree.ElementTree 2318 2319 one = self.etree.parse( 2320 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2321 baz = one.getroot()[0][0] 2322 2323 two = ElementTree(Element('root')) 2324 two.getroot().append(baz) 2325 # removing the originating document could cause a crash/error before 2326 # as namespace is not moved along with it 2327 del one 2328 self.assertEquals('{http://a.b.c}baz', baz.tag)

2329

2330 - def test_ns_decl_tostring(self):

2331 tostring = self.etree.tostring 2332 root = self.etree.XML( 2333 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>') 2334 baz = root[0][0] 2335 2336 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2337 tostring(baz)) 2338 self.assertEquals(["http://a.b.c"], nsdecl)

2339

2340 - def test_ns_decl_tostring_default(self):

2341 tostring = self.etree.tostring 2342 root = self.etree.XML( 2343 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>') 2344 baz = root[0][0] 2345 2346 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2347 tostring(baz)) 2348 self.assertEquals(["http://a.b.c"], nsdecl)

2349

2350 - def test_ns_decl_tostring_root(self):

2351 tostring = self.etree.tostring 2352 root = self.etree.XML( 2353 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>') 2354 baz = root[0][0] 2355 2356 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2357 tostring(baz)) 2358 2359 self.assertEquals(["http://a.b.c"], nsdecl)

2360

2361 - def test_ns_decl_tostring_element(self):

2362 Element = self.etree.Element 2363 SubElement = self.etree.SubElement 2364 2365 root = Element("foo") 2366 bar = SubElement(root, "{http://a.b.c}bar") 2367 baz = SubElement(bar, "{http://a.b.c}baz") 2368 2369 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2370 self.etree.tostring(baz)) 2371 2372 self.assertEquals(["http://a.b.c"], nsdecl)

2373

2374 - def test_attribute_xmlns_move(self):

2375 Element = self.etree.Element 2376 2377 root = Element('element') 2378 2379 subelement = Element('subelement', 2380 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2381 self.assertEquals(1, len(subelement.attrib)) 2382 self.assertEquals( 2383 "foo", 2384 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2385 2386 root.append(subelement) 2387 self.assertEquals(1, len(subelement.attrib)) 2388 self.assertEquals( 2389 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(), 2390 subelement.attrib.items()) 2391 self.assertEquals( 2392 "foo", 2393 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2394

2395 - def test_tostring(self):

2396 tostring = self.etree.tostring 2397 Element = self.etree.Element 2398 SubElement = self.etree.SubElement 2399 2400 a = Element('a') 2401 b = SubElement(a, 'b') 2402 c = SubElement(a, 'c') 2403 2404 self.assertEquals('<a><c></c></a>', 2405 canonicalize(tostring(a)))

2406

2407 - def test_tostring_element(self):

2408 tostring = self.etree.tostring 2409 Element = self.etree.Element 2410 SubElement = self.etree.SubElement 2411 2412 a = Element('a') 2413 b = SubElement(a, 'b') 2414 c = SubElement(a, 'c') 2415 d = SubElement(c, 'd') 2416 self.assertEquals('', 2417 canonicalize(tostring(b))) 2418 self.assertEquals('<c><d></d></c>', 2419 canonicalize(tostring(c)))

2420

2421 - def test_tostring_element_tail(self):

2422 tostring = self.etree.tostring 2423 Element = self.etree.Element 2424 SubElement = self.etree.SubElement 2425 2426 a = Element('a') 2427 b = SubElement(a, 'b') 2428 c = SubElement(a, 'c') 2429 d = SubElement(c, 'd') 2430 b.tail = 'Foo' 2431 2432 self.assert_(tostring(b) == 'Foo' or 2433 tostring(b) == 'Foo')

2434

2435 - def test_tostring_method_html(self):

2436 tostring = self.etree.tostring 2437 Element = self.etree.Element 2438 SubElement = self.etree.SubElement 2439 2440 html = Element('html') 2441 body = SubElement(html, 'body') 2442 p = SubElement(body, 'p') 2443 p.text = "html" 2444 SubElement(p, 'br').tail = "test" 2445 2446 self.assertEquals('<html><body>html test</body></html>', 2447 tostring(html, method="html"))

2448

2449 - def test_tostring_method_text(self):

2450 tostring = self.etree.tostring 2451 Element = self.etree.Element 2452 SubElement = self.etree.SubElement 2453 2454 a = Element('a') 2455 a.text = "A" 2456 a.tail = "tail" 2457 b = SubElement(a, 'b') 2458 b.text = "B" 2459 b.tail = "TAIL" 2460 c = SubElement(a, 'c') 2461 c.text = "C" 2462 2463 self.assertEquals('ABTAILCtail', 2464 tostring(a, method="text"))

2465

2466 - def test_iterparse(self):

2467 iterparse = self.etree.iterparse 2468 f = StringIO('<a><c/></a>') 2469 2470 iterator = iterparse(f) 2471 self.assertEquals(None, 2472 iterator.root) 2473 events = list(iterator) 2474 root = iterator.root 2475 self.assertEquals( 2476 [('end', root[0]), ('end', root[1]), ('end', root)], 2477 events)

2478

2479 - def test_iterparse_file(self):

2480 iterparse = self.etree.iterparse 2481 iterator = iterparse(fileInTestDir("test.xml")) 2482 self.assertEquals(None, 2483 iterator.root) 2484 events = list(iterator) 2485 root = iterator.root 2486 self.assertEquals( 2487 [('end', root[0]), ('end', root)], 2488 events)

2489

2490 - def test_iterparse_start(self):

2491 iterparse = self.etree.iterparse 2492 f = StringIO('<a><c/></a>') 2493 2494 iterator = iterparse(f, events=('start',)) 2495 events = list(iterator) 2496 root = iterator.root 2497 self.assertEquals( 2498 [('start', root), ('start', root[0]), ('start', root[1])], 2499 events)

2500

2501 - def test_iterparse_start_end(self):

2502 iterparse = self.etree.iterparse 2503 f = StringIO('<a><c/></a>') 2504 2505 iterator = iterparse(f, events=('start','end')) 2506 events = list(iterator) 2507 root = iterator.root 2508 self.assertEquals( 2509 [('start', root), ('start', root[0]), ('end', root[0]), 2510 ('start', root[1]), ('end', root[1]), ('end', root)], 2511 events)

2512

2513 - def test_iterparse_clear(self):

2514 iterparse = self.etree.iterparse 2515 f = StringIO('<a><c/></a>') 2516 2517 iterator = iterparse(f) 2518 for event, elem in iterator: 2519 elem.clear() 2520 2521 root = iterator.root 2522 self.assertEquals(0, 2523 len(root))

2524

2525 - def test_iterparse_large(self):

2526 iterparse = self.etree.iterparse 2527 CHILD_COUNT = 12345 2528 f = StringIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2529 2530 i = 0 2531 for key in iterparse(f): 2532 event, element = key 2533 i += 1 2534 self.assertEquals(i, CHILD_COUNT + 1)

2535

2536 - def test_iterparse_attrib_ns(self):

2537 iterparse = self.etree.iterparse 2538 f = StringIO('<a xmlns="ns1"><c xmlns="ns2"/></a>') 2539 2540 attr_name = '{testns}bla' 2541 events = [] 2542 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2543 for event, elem in iterator: 2544 events.append(event) 2545 if event == 'start': 2546 if elem.tag != '{ns1}a': 2547 elem.set(attr_name, 'value') 2548 2549 self.assertEquals( 2550 ['start-ns', 'start', 'start', 'start-ns', 'start', 2551 'end', 'end-ns', 'end', 'end', 'end-ns'], 2552 events) 2553 2554 root = iterator.root 2555 self.assertEquals( 2556 None, 2557 root.get(attr_name)) 2558 self.assertEquals( 2559 'value', 2560 root[0].get(attr_name))

2561

2562 - def test_iterparse_getiterator(self):

2563 iterparse = self.etree.iterparse 2564 f = StringIO('<a><d/><c/></a>') 2565 2566 counts = [] 2567 for event, elem in iterparse(f): 2568 counts.append(len(list(elem.getiterator()))) 2569 self.assertEquals( 2570 [1,2,1,4], 2571 counts)

2572

2573 - def test_parse_file(self):

2574 parse = self.etree.parse 2575 # from file 2576 tree = parse(fileInTestDir('test.xml')) 2577 self.assertXML( 2578 '<a></a>', 2579 tree.getroot())

2580

2581 - def test_parse_file_nonexistent(self):

2582 parse = self.etree.parse 2583 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2584

2585 - def test_parse_file_object(self):

2586 parse = self.etree.parse 2587 # from file object 2588 f = open(fileInTestDir('test.xml'), 'r') 2589 tree = parse(f) 2590 f.close() 2591 self.assertXML( 2592 '<a></a>', 2593 tree.getroot())

2594

2595 - def test_parse_stringio(self):

2596 parse = self.etree.parse 2597 # from StringIO 2598 f = StringIO('<a></a>') 2599 tree = parse(f) 2600 f.close() 2601 self.assertXML( 2602 '<a></a>', 2603 tree.getroot() 2604 )

2605

2606 - def test_parse_with_encoding(self):

2607 # this can fail in libxml2 <= 2.6.22 2608 parse = self.etree.parse 2609 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2610 self.assertXML('<html></html>', 2611 tree.getroot())

2612

2613 - def test_encoding(self):

2614 Element = self.etree.Element 2615 2616 a = Element('a') 2617 a.text = u'Søk på nettet' 2618 self.assertXML( 2619 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2620 a, 'utf-8')

2621

2622 - def test_encoding_exact(self):

2623 ElementTree = self.etree.ElementTree 2624 Element = self.etree.Element 2625 2626 a = Element('a') 2627 a.text = u'Søk på nettet' 2628 2629 f = StringIO() 2630 tree = ElementTree(element=a) 2631 tree.write(f, encoding='utf-8') 2632 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2633 f.getvalue().replace('\n',''))

2634

2635 - def test_parse_file_encoding(self):

2636 parse = self.etree.parse 2637 # from file 2638 tree = parse(fileInTestDir('test-string.xml')) 2639 self.assertXML( 2640 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2641 tree.getroot(), 'UTF-8')

2642

2643 - def test_parse_file_object_encoding(self):

2644 parse = self.etree.parse 2645 # from file object 2646 f = open(fileInTestDir('test-string.xml'), 'r') 2647 tree = parse(f) 2648 f.close() 2649 self.assertXML( 2650 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2651 tree.getroot(), 'UTF-8')

2652

2653 - def test_encoding_8bit_latin1(self):

2654 ElementTree = self.etree.ElementTree 2655 Element = self.etree.Element 2656 2657 a = Element('a') 2658 a.text = u'Søk på nettet' 2659 2660 f = StringIO() 2661 tree = ElementTree(element=a) 2662 tree.write(f, encoding='iso-8859-1') 2663 result = f.getvalue() 2664 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2665 self.assertEncodingDeclaration(result,'iso-8859-1') 2666 result = result.split('?>', 1)[-1].replace('\n','') 2667 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2668 result)

2669

2670 - def test_parse_encoding_8bit_explicit(self):

2671 XMLParser = self.etree.XMLParser 2672 2673 text = u'Søk på nettet' 2674 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1') 2675 2676 self.assertRaises(self.etree.ParseError, 2677 self.etree.parse, 2678 StringIO(xml_latin1)) 2679 2680 tree = self.etree.parse(StringIO(xml_latin1), 2681 XMLParser(encoding="iso-8859-1")) 2682 a = tree.getroot() 2683 self.assertEquals(a.text, text)

2684

2685 - def test_parse_encoding_8bit_override(self):

2686 XMLParser = self.etree.XMLParser 2687 2688 text = u'Søk på nettet' 2689 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 2690 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 2691 ).encode('iso-8859-1') 2692 2693 self.assertRaises(self.etree.ParseError, 2694 self.etree.parse, 2695 StringIO(xml_latin1)) 2696 2697 tree = self.etree.parse(StringIO(xml_latin1), 2698 XMLParser(encoding="iso-8859-1")) 2699 a = tree.getroot() 2700 self.assertEquals(a.text, text)

2701

2702 - def _test_wrong_unicode_encoding(self):

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

2708

2709 - def test_encoding_write_default_encoding(self):

2710 ElementTree = self.etree.ElementTree 2711 Element = self.etree.Element 2712 2713 a = Element('a') 2714 a.text = u'Søk på nettet' 2715 2716 f = StringIO() 2717 tree = ElementTree(element=a) 2718 tree.write(f) 2719 data = f.getvalue().replace('\n','') 2720 self.assertEquals( 2721 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2722 data)

2723

2724 - def test_encoding_tostring(self):

2725 Element = self.etree.Element 2726 tostring = self.etree.tostring 2727 2728 a = Element('a') 2729 a.text = u'Søk på nettet' 2730 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2731 tostring(a, encoding='utf-8'))

2732

2733 - def test_encoding_tostring_unknown(self):

2734 Element = self.etree.Element 2735 tostring = self.etree.tostring 2736 2737 a = Element('a') 2738 a.text = u'Søk på nettet' 2739 self.assertRaises(LookupError, tostring, a, 2740 encoding='Invalid Encoding')

2741

2742 - def test_encoding_tostring_sub(self):

2743 Element = self.etree.Element 2744 SubElement = self.etree.SubElement 2745 tostring = self.etree.tostring 2746 2747 a = Element('a') 2748 b = SubElement(a, 'b') 2749 b.text = u'Søk på nettet' 2750 self.assertEquals(u'Søk på nettet'.encode('UTF-8'), 2751 tostring(b, encoding='utf-8'))

2752

2753 - def test_encoding_tostring_sub_tail(self):

2754 Element = self.etree.Element 2755 SubElement = self.etree.SubElement 2756 tostring = self.etree.tostring 2757 2758 a = Element('a') 2759 b = SubElement(a, 'b') 2760 b.text = u'Søk på nettet' 2761 b.tail = u'Søk' 2762 self.assertEquals(u'Søk på nettetSøk'.encode('UTF-8'), 2763 tostring(b, encoding='utf-8'))

2764

2765 - def test_encoding_tostring_default_encoding(self):

2766 Element = self.etree.Element 2767 SubElement = self.etree.SubElement 2768 tostring = self.etree.tostring 2769 2770 a = Element('a') 2771 a.text = u'Søk på nettet' 2772 2773 expected = '<a>Søk på nettet</a>' 2774 self.assertEquals( 2775 expected, 2776 tostring(a))

2777

2778 - def test_encoding_sub_tostring_default_encoding(self):

2779 Element = self.etree.Element 2780 SubElement = self.etree.SubElement 2781 tostring = self.etree.tostring 2782 2783 a = Element('a') 2784 b = SubElement(a, 'b') 2785 b.text = u'Søk på nettet' 2786 2787 expected = 'Søk på nettet' 2788 self.assertEquals( 2789 expected, 2790 tostring(b))

2791

2792 - def test_encoding_8bit_xml(self):

2793 utext = u'Søk på nettet' 2794 uxml = u'%s' % utext 2795 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2796 isoxml = prologue + uxml.encode('iso-8859-1') 2797 tree = self.etree.XML(isoxml) 2798 self.assertEquals(utext, tree.text)

2799

2800 - def test_encoding_utf8_bom(self):

2801 utext = u'Søk på nettet' 2802 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \ 2803 u'%s' % utext 2804 bom = '\xEF\xBB\xBF' 2805 xml = bom + uxml.encode("utf-8") 2806 tree = etree.XML(xml) 2807 self.assertEquals(utext, tree.text)

2808

2809 - def test_encoding_8bit_parse_stringio(self):

2810 utext = u'Søk på nettet' 2811 uxml = u'%s' % utext 2812 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2813 isoxml = prologue + uxml.encode('iso-8859-1') 2814 el = self.etree.parse(StringIO(isoxml)).getroot() 2815 self.assertEquals(utext, el.text)

2816

2817 - def test_deepcopy_elementtree(self):

2818 Element = self.etree.Element 2819 ElementTree = self.etree.ElementTree 2820 2821 a = Element('a') 2822 a.text = "Foo" 2823 atree = ElementTree(a) 2824 2825 btree = copy.deepcopy(atree) 2826 self.assertEqual("Foo", atree.getroot().text) 2827 self.assertEqual("Foo", btree.getroot().text) 2828 self.assertFalse(btree is atree) 2829 self.assertFalse(btree.getroot() is atree.getroot())

2830

2831 - def test_deepcopy(self):

2832 Element = self.etree.Element 2833 2834 a = Element('a') 2835 a.text = 'Foo' 2836 2837 b = copy.deepcopy(a) 2838 self.assertEquals('Foo', b.text) 2839 2840 b.text = 'Bar' 2841 self.assertEquals('Bar', b.text) 2842 self.assertEquals('Foo', a.text) 2843 2844 del a 2845 self.assertEquals('Bar', b.text)

2846

2847 - def test_deepcopy_tail(self):

2848 Element = self.etree.Element 2849 2850 a = Element('a') 2851 a.tail = 'Foo' 2852 2853 b = copy.deepcopy(a) 2854 self.assertEquals('Foo', b.tail) 2855 2856 b.tail = 'Bar' 2857 self.assertEquals('Bar', b.tail) 2858 self.assertEquals('Foo', a.tail) 2859 2860 del a 2861 self.assertEquals('Bar', b.tail)

2862

2863 - def test_deepcopy_subelement(self):

2864 Element = self.etree.Element 2865 SubElement = self.etree.SubElement 2866 2867 root = Element('root') 2868 a = SubElement(root, 'a') 2869 a.text = 'FooText' 2870 a.tail = 'FooTail' 2871 2872 b = copy.deepcopy(a) 2873 self.assertEquals('FooText', b.text) 2874 self.assertEquals('FooTail', b.tail) 2875 2876 b.text = 'BarText' 2877 b.tail = 'BarTail' 2878 self.assertEquals('BarTail', b.tail) 2879 self.assertEquals('FooTail', a.tail) 2880 self.assertEquals('BarText', b.text) 2881 self.assertEquals('FooText', a.text) 2882 2883 del a 2884 self.assertEquals('BarTail', b.tail) 2885 self.assertEquals('BarText', b.text)

2886

2887 - def test_deepcopy_namespaces(self):

2888 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 2889 <parent><node t:foo="bar" /></parent> 2890 </doc>''') 2891 self.assertEquals( 2892 root[0][0].get('{tns}foo'), 2893 copy.deepcopy(root[0])[0].get('{tns}foo') ) 2894 self.assertEquals( 2895 root[0][0].get('{tns}foo'), 2896 copy.deepcopy(root[0][0]).get('{tns}foo') )

2897

2898 - def test_deepcopy_append(self):

2899 # previously caused a crash 2900 Element = self.etree.Element 2901 tostring = self.etree.tostring 2902 2903 a = Element('a') 2904 b = copy.deepcopy(a) 2905 a.append( Element('C') ) 2906 b.append( Element('X') ) 2907 2908 self.assertEquals('<a><C/></a>', 2909 tostring(a).replace(' ', '')) 2910 self.assertEquals('<a><X/></a>', 2911 tostring(b).replace(' ', ''))

2912

2913 - def test_shallowcopy(self):

2914 Element = self.etree.Element 2915 2916 a = Element('a') 2917 a.text = 'Foo' 2918 2919 b = copy.copy(a) 2920 self.assertEquals('Foo', b.text) 2921 2922 b.text = 'Bar' 2923 self.assertEquals('Bar', b.text) 2924 self.assertEquals('Foo', a.text)

2925 # XXX ElementTree will share nodes, but lxml.etree won't.. 2926

2927 - def test_shallowcopy_elementtree(self):

2928 Element = self.etree.Element 2929 ElementTree = self.etree.ElementTree 2930 2931 a = Element('a') 2932 a.text = 'Foo' 2933 atree = ElementTree(a) 2934 2935 btree = copy.copy(atree) 2936 self.assertFalse(btree is atree) 2937 self.assert_(btree.getroot() is atree.getroot()) 2938 self.assertEquals('Foo', atree.getroot().text)

2939

2940 - def _test_element_boolean(self):

2941 # deprecated as of ET 1.3/lxml 2.0 2942 etree = self.etree 2943 e = etree.Element('foo') 2944 self.assertEquals(False, bool(e)) 2945 etree.SubElement(e, 'bar') 2946 self.assertEquals(True, bool(e)) 2947 e = etree.Element('foo') 2948 e.text = 'hey' 2949 self.assertEquals(False, bool(e)) 2950 e = etree.Element('foo') 2951 e.tail = 'bar' 2952 self.assertEquals(False, bool(e)) 2953 e = etree.Element('foo') 2954 e.set('bar', 'Bar') 2955 self.assertEquals(False, bool(e))

2956

2957 - def test_multiple_elementrees(self):

2958 etree = self.etree 2959 2960 a = etree.Element('a') 2961 b = etree.SubElement(a, 'b') 2962 2963 t = etree.ElementTree(a) 2964 self.assertEquals(self._rootstring(t), '<a></a>') 2965 2966 t1 = etree.ElementTree(a) 2967 self.assertEquals(self._rootstring(t1), '<a></a>') 2968 self.assertEquals(self._rootstring(t), '<a></a>') 2969 2970 t2 = etree.ElementTree(b) 2971 self.assertEquals(self._rootstring(t2), '') 2972 self.assertEquals(self._rootstring(t1), '<a></a>') 2973 self.assertEquals(self._rootstring(t), '<a></a>')

2974

2975 - def test_qname(self):

2976 etree = self.etree 2977 qname = etree.QName('myns', 'a') 2978 a1 = etree.Element(qname) 2979 a2 = etree.SubElement(a1, qname) 2980 self.assertEquals(a1.tag, "{myns}a") 2981 self.assertEquals(a2.tag, "{myns}a")

2982

2983 - def test_qname_cmp(self):

2984 etree = self.etree 2985 qname1 = etree.QName('myns', 'a') 2986 qname2 = etree.QName('myns', 'a') 2987 self.assertEquals(qname1, "{myns}a") 2988 self.assertEquals("{myns}a", qname2) 2989 self.assertEquals(qname1, qname1) 2990 self.assertEquals(qname1, qname2)

2991

2992 - def test_qname_attribute_getset(self):

2993 etree = self.etree 2994 qname = etree.QName('myns', 'a') 2995 2996 a = etree.Element(qname) 2997 a.set(qname, "value") 2998 2999 self.assertEquals(a.get(qname), "value") 3000 self.assertEquals(a.get("{myns}a"), "value")

3001

3002 - def test_qname_attrib(self):

3003 etree = self.etree 3004 qname = etree.QName('myns', 'a') 3005 3006 a = etree.Element(qname) 3007 a.attrib[qname] = "value" 3008 3009 self.assertEquals(a.attrib[qname], "value") 3010 self.assertEquals(a.attrib.get(qname), "value") 3011 3012 self.assertEquals(a.attrib["{myns}a"], "value") 3013 self.assertEquals(a.attrib.get("{myns}a"), "value")

3014

3015 - def test_qname_attribute_resolve(self):

3016 etree = self.etree 3017 qname = etree.QName('http://myns', 'a') 3018 a = etree.Element(qname) 3019 a.set(qname, qname) 3020 3021 self.assertXML( 3022 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3023 a)

3024

3025 - def test_qname_attribute_resolve_new(self):

3026 etree = self.etree 3027 qname = etree.QName('http://myns', 'a') 3028 a = etree.Element('a') 3029 a.set('a', qname) 3030 3031 self.assertXML( 3032 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 3033 a)

3034

3035 - def test_qname_attrib_resolve(self):

3036 etree = self.etree 3037 qname = etree.QName('http://myns', 'a') 3038 a = etree.Element(qname) 3039 a.attrib[qname] = qname 3040 3041 self.assertXML( 3042 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 3043 a)

3044

3045 - def test_parser_version(self):

3046 etree = self.etree 3047 parser = etree.XMLParser() 3048 if hasattr(parser, "version"): 3049 # ElementTree 1.3+, cET 3050 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

3051 3052 # feed parser interface 3053

3054 - def test_feed_parser(self):

3055 parser = self.etree.XMLParser() 3056 3057 parser.feed('<?xml version=') 3058 parser.feed('"1.0"?><ro') 3059 parser.feed('ot><') 3060 parser.feed('a test="works"/') 3061 parser.feed('></root') 3062 parser.feed('>') 3063 3064 root = parser.close() 3065 3066 self.assertEquals(root.tag, "root") 3067 self.assertEquals(root[0].tag, "a") 3068 self.assertEquals(root[0].get("test"), "works")

3069

3070 - def test_feed_parser_error_close_empty(self):

3071 ParseError = self.etree.ParseError 3072 parser = self.etree.XMLParser() 3073 self.assertRaises(ParseError, parser.close)

3074

3075 - def test_feed_parser_error_close_incomplete(self):

3076 ParseError = self.etree.ParseError 3077 parser = self.etree.XMLParser() 3078 3079 parser.feed('<?xml version=') 3080 parser.feed('"1.0"?><ro') 3081 3082 self.assertRaises(ParseError, parser.close)

3083

3084 - def test_feed_parser_error_broken(self):

3085 ParseError = self.etree.ParseError 3086 parser = self.etree.XMLParser() 3087 3088 parser.feed('<?xml version=') 3089 parser.feed('"1.0"?><ro') 3090 try: 3091 parser.feed('<><><><><><><') 3092 except ParseError: 3093 # can raise, but not required before close() 3094 pass 3095 3096 self.assertRaises(ParseError, parser.close)

3097

3098 - def test_feed_parser_error_position(self):

3099 ParseError = self.etree.ParseError 3100 parser = self.etree.XMLParser() 3101 try: 3102 parser.close() 3103 except ParseError, e: 3104 self.assertNotEquals(None, e.code) 3105 self.assertNotEquals(0, e.code) 3106 self.assert_(isinstance(e.position, tuple)) 3107 self.assert_(e.position >= (0, 0))

3108 3109 # parser target interface 3110

3111 - def test_parser_target_tag(self):

3112 assertEquals = self.assertEquals 3113 assertFalse = self.assertFalse 3114 3115 events = [] 3116 class Target(object): 3117 def start(self, tag, attrib): 3118 events.append("start") 3119 assertFalse(attrib) 3120 assertEquals("TAG", tag)

3121 def end(self, tag): 3122 events.append("end") 3123 assertEquals("TAG", tag) 3124 def close(self): 3125 return "DONE" 3126 3127 parser = self.etree.XMLParser(target=Target()) 3128 3129 parser.feed("<TAG/>") 3130 done = parser.close() 3131 3132 self.assertEquals("DONE", done) 3133 self.assertEquals(["start", "end"], events) 3134

3135 - def test_parser_target_attrib(self):

3136 assertEquals = self.assertEquals 3137 3138 events = [] 3139 class Target(object): 3140 def start(self, tag, attrib): 3141 events.append("start-" + tag) 3142 for name, value in attrib.iteritems(): 3143 assertEquals(tag + name, value)

3144 def end(self, tag): 3145 events.append("end-" + tag) 3146 def close(self): 3147 return "DONE" 3148 3149 parser = self.etree.XMLParser(target=Target()) 3150 3151 parser.feed('<root a="roota" b="rootb"></root>') 3152 done = parser.close() 3153 3154 self.assertEquals("DONE", done) 3155 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3156 events) 3157

3158 - def test_parser_target_data(self):

3159 events = [] 3160 class Target(object): 3161 def start(self, tag, attrib): 3162 events.append("start-" + tag)

3163 def end(self, tag): 3164 events.append("end-" + tag) 3165 def data(self, data): 3166 events.append("data-" + data) 3167 def close(self): 3168 return "DONE" 3169 3170 parser = self.etree.XMLParser(target=Target()) 3171 3172 parser.feed('<root>AB</root>') 3173 done = parser.close() 3174 3175 self.assertEquals("DONE", done) 3176 self.assertEquals(["start-root", "data-A", "start-sub", 3177 "end-sub", "data-B", "end-root"], 3178 events) 3179

3180 - def test_treebuilder(self):

3181 builder = self.etree.TreeBuilder() 3182 el = builder.start("root", {'a':'A', 'b':'B'}) 3183 self.assertEquals("root", el.tag) 3184 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3185 builder.data("ROOTTEXT") 3186 el = builder.start("child", {'x':'X', 'y':'Y'}) 3187 self.assertEquals("child", el.tag) 3188 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3189 builder.data("CHILDTEXT") 3190 el = builder.end("child") 3191 self.assertEquals("child", el.tag) 3192 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3193 self.assertEquals("CHILDTEXT", el.text) 3194 self.assertEquals(None, el.tail) 3195 builder.data("CHILDTAIL") 3196 root = builder.end("root") 3197 3198 self.assertEquals("root", root.tag) 3199 self.assertEquals("ROOTTEXT", root.text) 3200 self.assertEquals("CHILDTEXT", root[0].text) 3201 self.assertEquals("CHILDTAIL", root[0].tail)

3202

3203 - def test_treebuilder_target(self):

3204 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3205 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3206 root = parser.close() 3207 3208 self.assertEquals("root", root.tag) 3209 self.assertEquals("ROOTTEXT", root.text) 3210 self.assertEquals("CHILDTEXT", root[0].text) 3211 self.assertEquals("CHILDTAIL", root[0].tail)

3212 3213 # helper methods 3214

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

3216 """Write out element for comparison. 3217 """ 3218 data = self.etree.tostring(element, encoding=encoding) 3219 if encoding != 'us-ascii': 3220 data = unicode(data, encoding) 3221 return canonicalize(data)

3222

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

3224 """Write out element for comparison, using real file. 3225 """ 3226 ElementTree = self.etree.ElementTree 3227 handle, filename = tempfile.mkstemp() 3228 try: 3229 f = open(filename, 'wb') 3230 tree = ElementTree(element=element) 3231 tree.write(f, encoding=encoding) 3232 f.close() 3233 f = open(filename, 'rb') 3234 data = f.read() 3235 f.close() 3236 finally: 3237 os.close(handle) 3238 os.remove(filename) 3239 if encoding != 'us-ascii': 3240 data = unicode(data, encoding) 3241 return canonicalize(data)

3242

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

3244 """Writes element out and checks whether it is expected. 3245 3246 Does this two ways; once using StringIO, once using a real file. 3247 """ 3248 self.assertEquals(expected, self._writeElement(element, encoding)) 3249 self.assertEquals(expected, self._writeElementFile(element, encoding))

3250

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

3252 "Checks if the result XML byte string specifies the encoding." 3253 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 3254 self.assert_(has_encoding(result)) 3255 result_encoding = has_encoding(result).group(1) 3256 self.assertEquals(result_encoding.upper(), encoding.upper())

3257

3258 - def _rootstring(self, tree):

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

3260

3261 - def _check_element_tree(self, tree):

3262 self._check_element(tree.getroot())

3263

3264 - def _check_element(self, element):

3265 self.assert_(hasattr(element, 'tag')) 3266 self.assert_(hasattr(element, 'attrib')) 3267 self.assert_(hasattr(element, 'text')) 3268 self.assert_(hasattr(element, 'tail')) 3269 self._check_string(element.tag) 3270 self._check_mapping(element.attrib) 3271 if element.text != None: 3272 self._check_string(element.text) 3273 if element.tail != None: 3274 self._check_string(element.tail)

3275

3276 - def _check_string(self, string):

3277 len(string) 3278 for char in string: 3279 self.assertEquals(1, len(char)) 3280 new_string = string + "" 3281 new_string = string + " " 3282 string[:0]

3283

3284 - def _check_mapping(self, mapping):

3285 len(mapping) 3286 keys = mapping.keys() 3287 items = mapping.items() 3288 for key in keys: 3289 item = mapping[key] 3290 mapping["key"] = "value" 3291 self.assertEquals("value", mapping["key"])

3292 3293 # assertFalse doesn't exist in Python 2.3 3294 try: 3295 unittest.TestCase.assertFalse 3296 except AttributeError: 3297 assertFalse = unittest.TestCase.failIf 3298 3299 3300 if etree:

3301 - class ETreeTestCase(ETreeTestCaseBase):

3302 etree = etree

3303 3304 if ElementTree:

3305 - class ElementTreeTestCase(ETreeTestCaseBase):

3306 etree = ElementTree

3307 3308 if cElementTree:

3309 - class CElementTreeTestCase(ETreeTestCaseBase):

3310 etree = cElementTree

3311

3312 -def test_suite():

3313 suite = unittest.TestSuite() 3314 if etree: 3315 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3316 if ElementTree: 3317 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3318 if cElementTree: 3319 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3320 return suite

3321 3322 if __name__ == '__main__': 3323 print 'to test use test.py %s' % __file__ 3324