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,6): 20 cElementTree = None 21

22 -class ETreeTestCaseBase(unittest.TestCase):

23 etree = None 24

25 - def tearDown(self):

26 gc.collect()

27

28 - def test_element(self):

29 for i in range(10): 30 e = self.etree.Element('foo') 31 self.assertEquals(e.tag, 'foo') 32 self.assertEquals(e.text, None) 33 self.assertEquals(e.tail, None)

34

35 - def test_simple(self):

36 Element = self.etree.Element 37 38 root = Element('root') 39 root.append(Element('one')) 40 root.append(Element('two')) 41 root.append(Element('three')) 42 self.assertEquals(3, len(root)) 43 self.assertEquals('one', root[0].tag) 44 self.assertEquals('two', root[1].tag) 45 self.assertEquals('three', root[2].tag) 46 self.assertRaises(IndexError, operator.getitem, root, 3)

47

48 - def test_subelement(self):

49 Element = self.etree.Element 50 SubElement = self.etree.SubElement 51 52 root = Element('root') 53 SubElement(root, 'one') 54 SubElement(root, 'two') 55 SubElement(root, 'three') 56 self.assertEquals(3, len(root)) 57 self.assertEquals('one', root[0].tag) 58 self.assertEquals('two', root[1].tag) 59 self.assertEquals('three', root[2].tag)

60

61 - def test_element_contains(self):

62 Element = self.etree.Element 63 SubElement = self.etree.SubElement 64 65 root1 = Element('root') 66 SubElement(root1, 'one') 67 self.assert_(root1[0] in root1) 68 69 root2 = Element('root') 70 SubElement(root2, 'two') 71 SubElement(root2, 'three') 72 self.assert_(root2[0] in root2) 73 self.assert_(root2[1] in root2) 74 75 self.assertFalse(root1[0] in root2) 76 self.assertFalse(root2[0] in root1) 77 self.assertFalse(None in root2)

78

79 - def test_element_indexing_with_text(self):

80 ElementTree = self.etree.ElementTree 81 82 f = StringIO('<doc>Test<one>One</one></doc>') 83 doc = ElementTree(file=f) 84 root = doc.getroot() 85 self.assertEquals(1, len(root)) 86 self.assertEquals('one', root[0].tag) 87 self.assertRaises(IndexError, operator.getitem, root, 1)

88

89 - def test_element_indexing_with_text2(self):

90 ElementTree = self.etree.ElementTree 91 92 f = StringIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 93 doc = ElementTree(file=f) 94 root = doc.getroot() 95 self.assertEquals(3, len(root)) 96 self.assertEquals('one', root[0].tag) 97 self.assertEquals('two', root[1].tag) 98 self.assertEquals('three', root[2].tag)

99

100 - def test_element_indexing_only_text(self):

101 ElementTree = self.etree.ElementTree 102 103 f = StringIO('<doc>Test</doc>') 104 doc = ElementTree(file=f) 105 root = doc.getroot() 106 self.assertEquals(0, len(root))

107

108 - def test_element_indexing_negative(self):

109 Element = self.etree.Element 110 SubElement = self.etree.SubElement 111 a = Element('a') 112 b = SubElement(a, 'b') 113 c = SubElement(a, 'c') 114 d = SubElement(a, 'd') 115 self.assertEquals(d, a[-1]) 116 self.assertEquals(c, a[-2]) 117 self.assertEquals(b, a[-3]) 118 self.assertRaises(IndexError, operator.getitem, a, -4) 119 a[-1] = e = Element('e') 120 self.assertEquals(e, a[-1]) 121 del a[-1] 122 self.assertEquals(2, len(a))

123

124 - def test_elementtree(self):

125 ElementTree = self.etree.ElementTree 126 127 f = StringIO('<doc><one>One</one><two>Two</two></doc>') 128 doc = ElementTree(file=f) 129 root = doc.getroot() 130 self.assertEquals(2, len(root)) 131 self.assertEquals('one', root[0].tag) 132 self.assertEquals('two', root[1].tag)

133

134 - def test_text(self):

135 ElementTree = self.etree.ElementTree 136 137 f = StringIO('<doc>This is a text</doc>') 138 doc = ElementTree(file=f) 139 root = doc.getroot() 140 self.assertEquals('This is a text', root.text)

141

142 - def test_text_empty(self):

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

149

150 - def test_text_other(self):

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

158

159 - def test_text_escape_in(self):

160 ElementTree = self.etree.ElementTree 161 162 f = StringIO('<doc>This is > than a text</doc>') 163 doc = ElementTree(file=f) 164 root = doc.getroot() 165 self.assertEquals('This is > than a text', root.text)

166

167 - def test_text_escape_out(self):

168 Element = self.etree.Element 169 170 a = Element("a") 171 a.text = "<>&" 172 self.assertXML('<a><>&</a>', 173 a)

174

175 - def test_text_escape_tostring(self):

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

183

184 - def test_text_str_subclass(self):

185 Element = self.etree.Element 186 187 class strTest(str): 188 pass

189 190 a = Element("a") 191 a.text = strTest("text") 192 self.assertXML('<a>text</a>', 193 a)

194

195 - def test_tail(self):

196 ElementTree = self.etree.ElementTree 197 198 f = StringIO('<doc>This is mixed content.</doc>') 199 doc = ElementTree(file=f) 200 root = doc.getroot() 201 self.assertEquals(1, len(root)) 202 self.assertEquals('This is ', root.text) 203 self.assertEquals(None, root.tail) 204 self.assertEquals('mixed', root[0].text) 205 self.assertEquals(' content.', root[0].tail)

206

207 - def test_tail_str_subclass(self):

208 Element = self.etree.Element 209 SubElement = self.etree.SubElement 210 211 class strTest(str): 212 pass

213 214 a = Element("a") 215 SubElement(a, "t").tail = strTest("tail") 216 self.assertXML('<a><t></t>tail</a>', 217 a) 218

219 - def test_ElementTree(self):

220 Element = self.etree.Element 221 ElementTree = self.etree.ElementTree 222 223 el = Element('hoi') 224 doc = ElementTree(el) 225 root = doc.getroot() 226 self.assertEquals(None, root.text) 227 self.assertEquals('hoi', root.tag)

228

229 - def test_attributes(self):

230 ElementTree = self.etree.ElementTree 231 232 f = StringIO('<doc one="One" two="Two"/>') 233 doc = ElementTree(file=f) 234 root = doc.getroot() 235 self.assertEquals('One', root.attrib['one']) 236 self.assertEquals('Two', root.attrib['two']) 237 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

238

239 - def test_attributes2(self):

240 ElementTree = self.etree.ElementTree 241 242 f = StringIO('<doc one="One" two="Two"/>') 243 doc = ElementTree(file=f) 244 root = doc.getroot() 245 self.assertEquals('One', root.attrib.get('one')) 246 self.assertEquals('Two', root.attrib.get('two')) 247 self.assertEquals(None, root.attrib.get('three')) 248 self.assertEquals('foo', root.attrib.get('three', 'foo'))

249

250 - def test_attributes3(self):

251 ElementTree = self.etree.ElementTree 252 253 f = StringIO('<doc one="One" two="Two"/>') 254 doc = ElementTree(file=f) 255 root = doc.getroot() 256 self.assertEquals('One', root.get('one')) 257 self.assertEquals('Two', root.get('two')) 258 self.assertEquals(None, root.get('three')) 259 self.assertEquals('foo', root.get('three', 'foo'))

260

261 - def test_attrib_clear(self):

262 XML = self.etree.XML 263 264 root = XML('<doc one="One" two="Two"/>') 265 self.assertEquals('One', root.get('one')) 266 self.assertEquals('Two', root.get('two')) 267 root.attrib.clear() 268 self.assertEquals(None, root.get('one')) 269 self.assertEquals(None, root.get('two'))

270

271 - def test_attrib_set_clear(self):

272 Element = self.etree.Element 273 274 root = Element("root", one="One") 275 root.set("two", "Two") 276 self.assertEquals('One', root.get('one')) 277 self.assertEquals('Two', root.get('two')) 278 root.attrib.clear() 279 self.assertEquals(None, root.get('one')) 280 self.assertEquals(None, root.get('two'))

281

282 - def test_attrib_ns_clear(self):

283 Element = self.etree.Element 284 SubElement = self.etree.SubElement 285 286 attribNS = '{http://foo/bar}x' 287 288 parent = Element('parent') 289 parent.set(attribNS, 'a') 290 child = SubElement(parent, 'child') 291 child.set(attribNS, 'b') 292 293 self.assertEquals('a', parent.get(attribNS)) 294 self.assertEquals('b', child.get(attribNS)) 295 296 parent.clear() 297 self.assertEquals(None, parent.get(attribNS)) 298 self.assertEquals('b', child.get(attribNS))

299

300 - def test_attribute_update_dict(self):

301 XML = self.etree.XML 302 303 root = XML('<doc alpha="Alpha" beta="Beta"/>') 304 items = root.attrib.items() 305 items.sort() 306 self.assertEquals( 307 [('alpha', 'Alpha'), ('beta', 'Beta')], 308 items) 309 310 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 311 312 items = root.attrib.items() 313 items.sort() 314 self.assertEquals( 315 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 316 items)

317

318 - def test_attribute_update_sequence(self):

319 XML = self.etree.XML 320 321 root = XML('<doc alpha="Alpha" beta="Beta"/>') 322 items = root.attrib.items() 323 items.sort() 324 self.assertEquals( 325 [('alpha', 'Alpha'), ('beta', 'Beta')], 326 items) 327 328 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 329 330 items = root.attrib.items() 331 items.sort() 332 self.assertEquals( 333 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 334 items)

335

336 - def test_attribute_update_iter(self):

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

353

354 - def test_attribute_keys(self):

355 XML = self.etree.XML 356 357 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 358 keys = root.attrib.keys() 359 keys.sort() 360 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

361

362 - def test_attribute_keys2(self):

363 XML = self.etree.XML 364 365 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 366 keys = root.keys() 367 keys.sort() 368 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

369

370 - def test_attribute_items2(self):

371 XML = self.etree.XML 372 373 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 374 items = root.items() 375 items.sort() 376 self.assertEquals( 377 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 378 items)

379

380 - def test_attribute_keys_ns(self):

381 XML = self.etree.XML 382 383 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 384 keys = root.keys() 385 keys.sort() 386 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 387 keys)

388

389 - def test_attribute_values(self):

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

396

397 - def test_attribute_values_ns(self):

398 XML = self.etree.XML 399 400 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 401 values = root.attrib.values() 402 values.sort() 403 self.assertEquals( 404 ['Bar', 'Baz'], values)

405

406 - def test_attribute_items(self):

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

418

419 - def test_attribute_items_ns(self):

420 XML = self.etree.XML 421 422 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 423 items = root.attrib.items() 424 items.sort() 425 self.assertEquals( 426 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 427 items)

428

429 - def test_attribute_str(self):

430 XML = self.etree.XML 431 432 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 433 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 434 435 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 436 try: 437 self.assertEquals(expected, str(root.attrib)) 438 except AssertionError: 439 self.assertEquals(alternative, str(root.attrib))

440

441 - def test_attribute_has_key(self):

442 XML = self.etree.XML 443 444 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 445 self.assertEquals( 446 True, root.attrib.has_key('bar')) 447 self.assertEquals( 448 False, root.attrib.has_key('baz')) 449 self.assertEquals( 450 False, root.attrib.has_key('hah')) 451 self.assertEquals( 452 True, 453 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))

454

455 - def test_attribute_contains(self):

456 XML = self.etree.XML 457 458 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 459 self.assertEquals( 460 True, 'bar' in root.attrib) 461 self.assertEquals( 462 False, 'baz' in root.attrib) 463 self.assertEquals( 464 False, 'hah' in root.attrib) 465 self.assertEquals( 466 True, 467 '{http://ns.codespeak.net/test}baz' in root.attrib)

468

469 - def test_attribute_set(self):

470 Element = self.etree.Element 471 472 root = Element("root") 473 root.set("attr", "TEST") 474 self.assertEquals("TEST", root.get("attr"))

475

476 - def test_XML(self):

477 XML = self.etree.XML 478 479 root = XML('<doc>This is a text.</doc>') 480 self.assertEquals(0, len(root)) 481 self.assertEquals('This is a text.', root.text)

482

483 - def test_XMLID(self):

484 XMLID = self.etree.XMLID 485 XML = self.etree.XML 486 xml_text = ''' 487 <document> 488 <h1 id="chapter1">...</h1> 489 ... 490 Regular paragraph. 491 XML:ID paragraph. 492 ... 493 </document> 494 ''' 495 496 root, dic = XMLID(xml_text) 497 root2 = XML(xml_text) 498 self.assertEquals(self._writeElement(root), 499 self._writeElement(root2)) 500 expected = { 501 "chapter1" : root[0], 502 "note1" : root[1], 503 "warn1" : root[4] 504 } 505 self.assertEquals(dic, expected)

506

507 - def test_fromstring(self):

508 fromstring = self.etree.fromstring 509 510 root = fromstring('<doc>This is a text.</doc>') 511 self.assertEquals(0, len(root)) 512 self.assertEquals('This is a text.', root.text)

513

514 - def test_fromstringlist(self):

515 fromstringlist = self.etree.fromstringlist 516 517 root = fromstringlist(["<do", "c>T", "hi", "s is", 518 " a text.<", "/doc", ">"]) 519 self.assertEquals(0, len(root)) 520 self.assertEquals('This is a text.', root.text)

521

522 - def test_fromstringlist_characters(self):

523 fromstringlist = self.etree.fromstringlist 524 525 root = fromstringlist(list('<doc>This is a text.</doc>')) 526 self.assertEquals(0, len(root)) 527 self.assertEquals('This is a text.', root.text)

528

529 - def test_fromstringlist_single(self):

530 fromstringlist = self.etree.fromstringlist 531 532 root = fromstringlist(['<doc>This is a text.</doc>']) 533 self.assertEquals(0, len(root)) 534 self.assertEquals('This is a text.', root.text)

535

536 - def test_iselement(self):

537 iselement = self.etree.iselement 538 Element = self.etree.Element 539 ElementTree = self.etree.ElementTree 540 XML = self.etree.XML 541 Comment = self.etree.Comment 542 ProcessingInstruction = self.etree.ProcessingInstruction 543 544 el = Element('hoi') 545 self.assert_(iselement(el)) 546 547 el2 = XML('<foo/>') 548 self.assert_(iselement(el2)) 549 550 tree = ElementTree(element=Element('dag')) 551 self.assert_(not iselement(tree)) 552 self.assert_(iselement(tree.getroot())) 553 554 c = Comment('test') 555 self.assert_(iselement(c)) 556 557 p = ProcessingInstruction("test", "some text") 558 self.assert_(iselement(p))

559

560 - def test_iteration(self):

561 XML = self.etree.XML 562 563 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 564 result = [] 565 for el in root: 566 result.append(el.tag) 567 self.assertEquals(['one', 'two', 'three'], result)

568

569 - def test_iteration_empty(self):

570 XML = self.etree.XML 571 572 root = XML('<doc></doc>') 573 result = [] 574 for el in root: 575 result.append(el.tag) 576 self.assertEquals([], result)

577

578 - def test_iteration_text_only(self):

579 XML = self.etree.XML 580 581 root = XML('<doc>Text</doc>') 582 result = [] 583 for el in root: 584 result.append(el.tag) 585 self.assertEquals([], result)

586

587 - def test_iteration_crash(self):

588 # this would cause a crash in the past 589 fromstring = self.etree.fromstring 590 root = etree.fromstring('<html>x</html>') 591 for elem in root: 592 elem.tail = ''

593

594 - def test_iteration_reversed(self):

595 XML = self.etree.XML 596 597 try: 598 reversed(()) 599 except NameError: 600 # before Python 2.4 601 return 602 603 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 604 result = [] 605 for el in reversed(root): 606 result.append(el.tag) 607 self.assertEquals(['three', 'two', 'one'], result)

608

609 - def test_iteration_subelement(self):

610 XML = self.etree.XML 611 612 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 613 result = [] 614 add = True 615 for el in root: 616 result.append(el.tag) 617 if add: 618 self.etree.SubElement(root, 'four') 619 add = False 620 self.assertEquals(['one', 'two', 'three', 'four'], result)

621

622 - def test_iteration_del_child(self):

623 XML = self.etree.XML 624 625 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 626 result = [] 627 for el in root: 628 result.append(el.tag) 629 del root[-1] 630 self.assertEquals(['one', 'two'], result)

631

632 - def test_iteration_double(self):

633 XML = self.etree.XML 634 635 root = XML('<doc><one/><two/></doc>') 636 result = [] 637 for el0 in root: 638 result.append(el0.tag) 639 for el1 in root: 640 result.append(el1.tag) 641 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

642

643 - def test_attribute_iterator(self):

644 XML = self.etree.XML 645 646 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />') 647 result = [] 648 for key in root.attrib: 649 result.append(key) 650 result.sort() 651 self.assertEquals(['alpha', 'beta', 'gamma'], result)

652

653 - def test_findall(self):

654 XML = self.etree.XML 655 root = XML('<a><c/><c></c></a>') 656 self.assertEquals(len(list(root.findall("c"))), 1) 657 self.assertEquals(len(list(root.findall(".//c"))), 2) 658 self.assertEquals(len(list(root.findall(".//b"))), 3) 659 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 660 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 661 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

662

663 - def test_findall_ns(self):

664 XML = self.etree.XML 665 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 666 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 667 self.assertEquals(len(list(root.findall(".//b"))), 3) 668 self.assertEquals(len(list(root.findall("b"))), 2)

669

670 - def test_element_with_attributes_keywords(self):

671 Element = self.etree.Element 672 673 el = Element('tag', foo='Foo', bar='Bar') 674 self.assertEquals('Foo', el.attrib['foo']) 675 self.assertEquals('Bar', el.attrib['bar'])

676

677 - def test_element_with_attributes(self):

678 Element = self.etree.Element 679 680 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 681 self.assertEquals('Foo', el.attrib['foo']) 682 self.assertEquals('Bar', el.attrib['bar'])

683

684 - def test_element_with_attributes_ns(self):

685 Element = self.etree.Element 686 687 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 688 self.assertEquals('Foo', el.attrib['{ns1}foo']) 689 self.assertEquals('Bar', el.attrib['{ns2}bar'])

690

691 - def test_subelement_with_attributes(self):

692 Element = self.etree.Element 693 SubElement = self.etree.SubElement 694 695 el = Element('tag') 696 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 697 self.assertEquals("Baz", el[0].attrib['baz']) 698 self.assertEquals('Foo', el[0].attrib['foo'])

699

700 - def test_subelement_with_attributes_ns(self):

701 Element = self.etree.Element 702 SubElement = self.etree.SubElement 703 704 el = Element('tag') 705 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 706 self.assertEquals('Foo', el[0].attrib['{ns1}foo']) 707 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])

708

709 - def test_write(self):

710 ElementTree = self.etree.ElementTree 711 XML = self.etree.XML 712 713 for i in range(10): 714 f = StringIO() 715 root = XML('<doc%s>This is a test.</doc%s>' % (i, i)) 716 tree = ElementTree(element=root) 717 tree.write(f) 718 data = f.getvalue() 719 self.assertEquals( 720 '<doc%s>This is a test.</doc%s>' % (i, i), 721 canonicalize(data))

722

723 - def test_write_method_html(self):

724 ElementTree = self.etree.ElementTree 725 Element = self.etree.Element 726 SubElement = self.etree.SubElement 727 728 html = Element('html') 729 body = SubElement(html, 'body') 730 p = SubElement(body, 'p') 731 p.text = "html" 732 SubElement(p, 'br').tail = "test" 733 734 tree = ElementTree(element=html) 735 f = StringIO() 736 tree.write(f, method="html") 737 data = f.getvalue() 738 739 self.assertEquals('<html><body>html test</body></html>', 740 data)

741

742 - def test_write_method_text(self):

743 ElementTree = self.etree.ElementTree 744 Element = self.etree.Element 745 SubElement = self.etree.SubElement 746 747 a = Element('a') 748 a.text = "A" 749 a.tail = "tail" 750 b = SubElement(a, 'b') 751 b.text = "B" 752 b.tail = "TAIL" 753 c = SubElement(a, 'c') 754 c.text = "C" 755 756 tree = ElementTree(element=a) 757 f = StringIO() 758 tree.write(f, method="text") 759 data = f.getvalue() 760 761 self.assertEquals('ABTAILCtail', 762 data)

763

764 - def test_write_fail(self):

765 ElementTree = self.etree.ElementTree 766 XML = self.etree.XML 767 768 tree = ElementTree( XML('<doc>This is a test.</doc>') ) 769 self.assertRaises(IOError, tree.write, 770 "definitely////\\-\\nonexisting\\-\\////FILE")

771 772 # this could trigger a crash, apparently because the document 773 # reference was prematurely garbage collected

774 - def test_crash(self):

775 Element = self.etree.Element 776 777 element = Element('tag') 778 for i in range(10): 779 element.attrib['key'] = 'value' 780 value = element.attrib['key'] 781 self.assertEquals(value, 'value')

782 783 # from doctest; for some reason this caused crashes too

784 - def test_write_ElementTreeDoctest(self):

785 Element = self.etree.Element 786 ElementTree = self.etree.ElementTree 787 788 f = StringIO() 789 for i in range(10): 790 element = Element('tag%s' % i) 791 self._check_element(element) 792 tree = ElementTree(element) 793 tree.write(f) 794 self._check_element_tree(tree)

795

796 - def test_subelement_reference(self):

797 Element = self.etree.Element 798 SubElement = self.etree.SubElement 799 800 el = Element('foo') 801 el2 = SubElement(el, 'bar') 802 el3 = SubElement(el2, 'baz') 803 804 al = Element('foo2') 805 al2 = SubElement(al, 'bar2') 806 al3 = SubElement(al2, 'baz2') 807 808 # now move al2 into el 809 el.append(al2) 810 811 # now change al3 directly 812 al3.text = 'baz2-modified' 813 814 # it should have changed through this route too 815 self.assertEquals( 816 'baz2-modified', 817 el[1][0].text)

818

819 - def test_set_text(self):

820 Element = self.etree.Element 821 SubElement = self.etree.SubElement 822 823 a = Element('a') 824 b = SubElement(a, 'b') 825 a.text = 'hoi' 826 self.assertEquals( 827 'hoi', 828 a.text) 829 self.assertEquals( 830 'b', 831 a[0].tag)

832

833 - def test_set_text2(self):

834 Element = self.etree.Element 835 SubElement = self.etree.SubElement 836 837 a = Element('a') 838 a.text = 'hoi' 839 b = SubElement(a ,'b') 840 self.assertEquals( 841 'hoi', 842 a.text) 843 self.assertEquals( 844 'b', 845 a[0].tag)

846

847 - def test_set_text_none(self):

848 Element = self.etree.Element 849 850 a = Element('a') 851 852 a.text = 'foo' 853 a.text = None 854 855 self.assertEquals( 856 None, 857 a.text) 858 self.assertXML('<a></a>', a)

859

860 - def test_set_text_empty(self):

861 Element = self.etree.Element 862 863 a = Element('a') 864 self.assertEquals(None, a.text) 865 866 a.text = '' 867 self.assertEquals('', a.text) 868 self.assertXML('<a></a>', a)

869

870 - def test_tail1(self):

871 Element = self.etree.Element 872 SubElement = self.etree.SubElement 873 874 a = Element('a') 875 a.tail = 'dag' 876 self.assertEquals('dag', 877 a.tail) 878 b = SubElement(a, 'b') 879 b.tail = 'hoi' 880 self.assertEquals('hoi', 881 b.tail) 882 self.assertEquals('dag', 883 a.tail)

884

885 - def test_tail_append(self):

886 Element = self.etree.Element 887 888 a = Element('a') 889 b = Element('b') 890 b.tail = 'b_tail' 891 a.append(b) 892 self.assertEquals('b_tail', 893 b.tail)

894

895 - def test_tail_set_twice(self):

896 Element = self.etree.Element 897 SubElement = self.etree.SubElement 898 899 a = Element('a') 900 b = SubElement(a, 'b') 901 b.tail = 'foo' 902 b.tail = 'bar' 903 self.assertEquals('bar', 904 b.tail) 905 self.assertXML('<a>bar</a>', a)

906

907 - def test_tail_set_none(self):

908 Element = self.etree.Element 909 a = Element('a') 910 a.tail = 'foo' 911 a.tail = None 912 self.assertEquals( 913 None, 914 a.tail) 915 self.assertXML('<a></a>', a)

916

917 - def test_comment(self):

918 Element = self.etree.Element 919 SubElement = self.etree.SubElement 920 Comment = self.etree.Comment 921 922 a = Element('a') 923 a.append(Comment('foo')) 924 self.assertEquals(a[0].tag, Comment) 925 self.assertEquals(a[0].text, 'foo')

926

927 - def test_comment_text(self):

928 Element = self.etree.Element 929 SubElement = self.etree.SubElement 930 Comment = self.etree.Comment 931 932 a = Element('a') 933 a.append(Comment('foo')) 934 self.assertEquals(a[0].text, 'foo') 935 936 a[0].text = "TEST" 937 self.assertEquals(a[0].text, 'TEST')

938

939 - def test_comment_whitespace(self):

940 Element = self.etree.Element 941 SubElement = self.etree.SubElement 942 Comment = self.etree.Comment 943 944 a = Element('a') 945 a.append(Comment(' foo ')) 946 self.assertEquals(a[0].text, ' foo ')

947

948 - def test_comment_nonsense(self):

949 Comment = self.etree.Comment 950 c = Comment('foo') 951 self.assertEquals({}, c.attrib) 952 self.assertEquals([], c.keys()) 953 self.assertEquals([], c.items()) 954 self.assertEquals(None, c.get('hoi')) 955 self.assertEquals(0, len(c)) 956 # should not iterate 957 for i in c: 958 pass

959

960 - def test_pi(self):

961 # lxml.etree separates target and text 962 Element = self.etree.Element 963 SubElement = self.etree.SubElement 964 ProcessingInstruction = self.etree.ProcessingInstruction 965 966 a = Element('a') 967 a.append(ProcessingInstruction('foo', 'some more text')) 968 self.assertEquals(a[0].tag, ProcessingInstruction) 969 self.assertXML("<a><?foo some more text?></a>", 970 a)

971

972 - def test_processinginstruction(self):

973 # lxml.etree separates target and text 974 Element = self.etree.Element 975 SubElement = self.etree.SubElement 976 ProcessingInstruction = self.etree.PI 977 978 a = Element('a') 979 a.append(ProcessingInstruction('foo', 'some more text')) 980 self.assertEquals(a[0].tag, ProcessingInstruction) 981 self.assertXML("<a><?foo some more text?></a>", 982 a)

983

984 - def test_pi_nonsense(self):

985 ProcessingInstruction = self.etree.ProcessingInstruction 986 pi = ProcessingInstruction('foo') 987 self.assertEquals({}, pi.attrib) 988 self.assertEquals([], pi.keys()) 989 self.assertEquals([], pi.items()) 990 self.assertEquals(None, pi.get('hoi')) 991 self.assertEquals(0, len(pi)) 992 # should not iterate 993 for i in pi: 994 pass

995

996 - def test_setitem(self):

997 Element = self.etree.Element 998 SubElement = self.etree.SubElement 999 1000 a = Element('a') 1001 b = SubElement(a, 'b') 1002 c = Element('c') 1003 a[0] = c 1004 self.assertEquals( 1005 c, 1006 a[0]) 1007 self.assertXML('<a><c></c></a>', 1008 a) 1009 self.assertXML('', 1010 b)

1011

1012 - def test_setitem2(self):

1013 Element = self.etree.Element 1014 SubElement = self.etree.SubElement 1015 1016 a = Element('a') 1017 for i in range(5): 1018 b = SubElement(a, 'b%s' % i) 1019 c = SubElement(b, 'c') 1020 for i in range(5): 1021 d = Element('d') 1022 e = SubElement(d, 'e') 1023 a[i] = d 1024 self.assertXML( 1025 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>', 1026 a) 1027 self.assertXML('<c></c>', 1028 c)

1029

1030 - def test_setitem_replace(self):

1031 Element = self.etree.Element 1032 SubElement = self.etree.SubElement 1033 1034 a = Element('a') 1035 SubElement(a, 'b') 1036 d = Element('d') 1037 a[0] = d 1038 self.assertXML('<a><d></d></a>', a)

1039

1040 - def test_setitem_indexerror(self):

1041 Element = self.etree.Element 1042 SubElement = self.etree.SubElement 1043 1044 a = Element('a') 1045 b = SubElement(a, 'b') 1046 1047 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1048

1049 - def test_setitem_tail(self):

1050 Element = self.etree.Element 1051 SubElement = self.etree.SubElement 1052 1053 a = Element('a') 1054 b = SubElement(a, 'b') 1055 b.tail = 'B2' 1056 c = Element('c') 1057 c.tail = 'C2' 1058 1059 a[0] = c 1060 self.assertXML( 1061 '<a><c></c>C2</a>', 1062 a)

1063

1064 - def test_tag_write(self):

1065 Element = self.etree.Element 1066 SubElement = self.etree.SubElement 1067 1068 a = Element('a') 1069 b = SubElement(a, 'b') 1070 1071 a.tag = 'c' 1072 1073 self.assertEquals( 1074 'c', 1075 a.tag) 1076 1077 self.assertXML( 1078 '<c></c>', 1079 a)

1080

1081 - def test_tag_reset_ns(self):

1082 Element = self.etree.Element 1083 SubElement = self.etree.SubElement 1084 tostring = self.etree.tostring 1085 1086 a = Element('{a}a') 1087 b1 = SubElement(a, '{a}b') 1088 b2 = SubElement(a, '{b}b') 1089 1090 self.assertEquals('{a}b', b1.tag) 1091 1092 b1.tag = 'c' 1093 1094 # can't use C14N here! 1095 self.assertEquals('c', b1.tag) 1096 self.assertEquals('<c', tostring(b1)[:2]) 1097 self.assert_('<c' in tostring(a))

1098

1099 - def test_tag_reset_root_ns(self):

1100 Element = self.etree.Element 1101 SubElement = self.etree.SubElement 1102 tostring = self.etree.tostring 1103 1104 a = Element('{a}a') 1105 b1 = SubElement(a, '{a}b') 1106 b2 = SubElement(a, '{b}b') 1107 1108 a.tag = 'c' 1109 1110 self.assertEquals( 1111 'c', 1112 a.tag) 1113 1114 # can't use C14N here! 1115 self.assertEquals('c', a.tag) 1116 self.assertEquals('<c', tostring(a)[:2])

1117

1118 - def test_tag_str_subclass(self):

1119 Element = self.etree.Element 1120 1121 class strTest(str): 1122 pass

1123 1124 a = Element("a") 1125 a.tag = strTest("TAG") 1126 self.assertXML('<TAG></TAG>', 1127 a) 1128

1129 - def test_delitem(self):

1130 Element = self.etree.Element 1131 SubElement = self.etree.SubElement 1132 1133 a = Element('a') 1134 b = SubElement(a, 'b') 1135 c = SubElement(a, 'c') 1136 d = SubElement(a, 'd') 1137 1138 del a[1] 1139 self.assertXML( 1140 '<a><d></d></a>', 1141 a) 1142 1143 del a[0] 1144 self.assertXML( 1145 '<a><d></d></a>', 1146 a) 1147 1148 del a[0] 1149 self.assertXML( 1150 '<a></a>', 1151 a) 1152 # move deleted element into other tree afterwards 1153 other = Element('other') 1154 other.append(c) 1155 self.assertXML( 1156 '<other><c></c></other>', 1157 other)

1158

1159 - def test_del_insert(self):

1160 Element = self.etree.Element 1161 SubElement = self.etree.SubElement 1162 1163 a = Element('a') 1164 b = SubElement(a, 'b') 1165 bs = SubElement(b, 'bs') 1166 c = SubElement(a, 'c') 1167 cs = SubElement(c, 'cs') 1168 1169 el = a[0] 1170 self.assertXML( 1171 '<a><bs></bs><c><cs></cs></c></a>', 1172 a) 1173 self.assertXML('<bs></bs>', b) 1174 self.assertXML('<c><cs></cs></c>', c) 1175 1176 del a[0] 1177 self.assertXML( 1178 '<a><c><cs></cs></c></a>', 1179 a) 1180 self.assertXML('<bs></bs>', b) 1181 self.assertXML('<c><cs></cs></c>', c) 1182 1183 a.insert(0, el) 1184 self.assertXML( 1185 '<a><bs></bs><c><cs></cs></c></a>', 1186 a) 1187 self.assertXML('<bs></bs>', b) 1188 self.assertXML('<c><cs></cs></c>', c)

1189

1190 - def test_del_setitem(self):

1191 Element = self.etree.Element 1192 SubElement = self.etree.SubElement 1193 1194 a = Element('a') 1195 b = SubElement(a, 'b') 1196 bs = SubElement(b, 'bs') 1197 c = SubElement(a, 'c') 1198 cs = SubElement(c, 'cs') 1199 1200 el = a[0] 1201 del a[0] 1202 a[0] = el 1203 self.assertXML( 1204 '<a><bs></bs></a>', 1205 a) 1206 self.assertXML('<bs></bs>', b) 1207 self.assertXML('<c><cs></cs></c>', c)

1208

1209 - def test_del_setslice(self):

1210 Element = self.etree.Element 1211 SubElement = self.etree.SubElement 1212 1213 a = Element('a') 1214 b = SubElement(a, 'b') 1215 bs = SubElement(b, 'bs') 1216 c = SubElement(a, 'c') 1217 cs = SubElement(c, 'cs') 1218 1219 el = a[0] 1220 del a[0] 1221 a[0:0] = [el] 1222 self.assertXML( 1223 '<a><bs></bs><c><cs></cs></c></a>', 1224 a) 1225 self.assertXML('<bs></bs>', b) 1226 self.assertXML('<c><cs></cs></c>', c)

1227

1228 - def test_replace_slice_tail(self):

1229 XML = self.etree.XML 1230 a = XML('<a>B2<c></c>C2</a>') 1231 b, c = a 1232 1233 a[:] = [] 1234 1235 self.assertEquals("B2", b.tail) 1236 self.assertEquals("C2", c.tail)

1237

1238 - def test_delitem_tail(self):

1239 ElementTree = self.etree.ElementTree 1240 f = StringIO('<a>B2<c></c>C2</a>') 1241 doc = ElementTree(file=f) 1242 a = doc.getroot() 1243 del a[0] 1244 self.assertXML( 1245 '<a><c></c>C2</a>', 1246 a)

1247

1248 - def test_clear(self):

1249 Element = self.etree.Element 1250 1251 a = Element('a') 1252 a.text = 'foo' 1253 a.tail = 'bar' 1254 a.set('hoi', 'dag') 1255 a.clear() 1256 self.assertEquals(None, a.text) 1257 self.assertEquals(None, a.tail) 1258 self.assertEquals(None, a.get('hoi')) 1259 self.assertEquals('a', a.tag)

1260

1261 - def test_clear_sub(self):

1262 Element = self.etree.Element 1263 SubElement = self.etree.SubElement 1264 1265 a = Element('a') 1266 a.text = 'foo' 1267 a.tail = 'bar' 1268 a.set('hoi', 'dag') 1269 b = SubElement(a, 'b') 1270 c = SubElement(b, 'c') 1271 a.clear() 1272 self.assertEquals(None, a.text) 1273 self.assertEquals(None, a.tail) 1274 self.assertEquals(None, a.get('hoi')) 1275 self.assertEquals('a', a.tag) 1276 self.assertEquals(0, len(a)) 1277 self.assertXML('<a></a>', 1278 a) 1279 self.assertXML('<c></c>', 1280 b)

1281

1282 - def test_clear_tail(self):

1283 ElementTree = self.etree.ElementTree 1284 f = StringIO('<a>B2<c></c>C2</a>') 1285 doc = ElementTree(file=f) 1286 a = doc.getroot() 1287 a.clear() 1288 self.assertXML( 1289 '<a></a>', 1290 a)

1291

1292 - def test_insert(self):

1293 Element = self.etree.Element 1294 SubElement = self.etree.SubElement 1295 1296 a = Element('a') 1297 b = SubElement(a, 'b') 1298 c = SubElement(a, 'c') 1299 d = Element('d') 1300 a.insert(0, d) 1301 1302 self.assertEquals( 1303 d, 1304 a[0]) 1305 1306 self.assertXML( 1307 '<a><d></d><c></c></a>', 1308 a) 1309 1310 e = Element('e') 1311 a.insert(2, e) 1312 self.assertEquals( 1313 e, 1314 a[2]) 1315 self.assertXML( 1316 '<a><d></d><e></e><c></c></a>', 1317 a)

1318

1319 - def test_insert_beyond_index(self):

1320 Element = self.etree.Element 1321 SubElement = self.etree.SubElement 1322 1323 a = Element('a') 1324 b = SubElement(a, 'b') 1325 c = Element('c') 1326 1327 a.insert(2, c) 1328 self.assertEquals( 1329 c, 1330 a[1]) 1331 self.assertXML( 1332 '<a><c></c></a>', 1333 a)

1334

1335 - def test_insert_negative(self):

1336 Element = self.etree.Element 1337 SubElement = self.etree.SubElement 1338 1339 a = Element('a') 1340 b = SubElement(a, 'b') 1341 c = SubElement(a, 'c') 1342 1343 d = Element('d') 1344 a.insert(-1, d) 1345 self.assertEquals( 1346 d, 1347 a[-2]) 1348 self.assertXML( 1349 '<a><d></d><c></c></a>', 1350 a)

1351

1352 - def test_insert_tail(self):

1353 Element = self.etree.Element 1354 SubElement = self.etree.SubElement 1355 1356 a = Element('a') 1357 b = SubElement(a, 'b') 1358 1359 c = Element('c') 1360 c.tail = 'C2' 1361 1362 a.insert(0, c) 1363 self.assertXML( 1364 '<a><c></c>C2</a>', 1365 a)

1366

1367 - def test_remove(self):

1368 Element = self.etree.Element 1369 SubElement = self.etree.SubElement 1370 1371 a = Element('a') 1372 b = SubElement(a, 'b') 1373 c = SubElement(a, 'c') 1374 1375 a.remove(b) 1376 self.assertEquals( 1377 c, 1378 a[0]) 1379 self.assertXML( 1380 '<a><c></c></a>', 1381 a)

1382

1383 - def test_remove_ns(self):

1384 Element = self.etree.Element 1385 SubElement = self.etree.SubElement 1386 1387 a = Element('{http://test}a') 1388 b = SubElement(a, '{http://test}b') 1389 c = SubElement(a, '{http://test}c') 1390 1391 a.remove(b) 1392 self.assertXML( 1393 '<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>', 1394 a) 1395 self.assertXML( 1396 '<ns0:b xmlns:ns0="http://test"></ns0:b>', 1397 b)

1398

1399 - def test_remove_nonexisting(self):

1400 Element = self.etree.Element 1401 SubElement = self.etree.SubElement 1402 1403 a = Element('a') 1404 b = SubElement(a, 'b') 1405 c = SubElement(a, 'c') 1406 d = Element('d') 1407 self.assertRaises( 1408 ValueError, a.remove, d)

1409

1410 - def test_remove_tail(self):

1411 Element = self.etree.Element 1412 SubElement = self.etree.SubElement 1413 1414 a = Element('a') 1415 b = SubElement(a, 'b') 1416 b.tail = 'b2' 1417 a.remove(b) 1418 self.assertXML( 1419 '<a></a>', 1420 a) 1421 self.assertEquals('b2', b.tail)

1422

1423 - def _test_getchildren(self):

1424 Element = self.etree.Element 1425 SubElement = self.etree.SubElement 1426 1427 a = Element('a') 1428 b = SubElement(a, 'b') 1429 c = SubElement(a, 'c') 1430 d = SubElement(b, 'd') 1431 e = SubElement(c, 'e') 1432 self.assertXML( 1433 '<a><d></d><c><e></e></c></a>', 1434 a) 1435 self.assertEquals( 1436 [b, c], 1437 a.getchildren()) 1438 self.assertEquals( 1439 [d], 1440 b.getchildren()) 1441 self.assertEquals( 1442 [], 1443 d.getchildren())

1444

1445 - def test_makeelement(self):

1446 Element = self.etree.Element 1447 1448 a = Element('a') 1449 b = a.makeelement('c', {'hoi':'dag'}) 1450 self.assertXML( 1451 '<c hoi="dag"></c>', 1452 b)

1453

1454 - def test_getiterator(self):

1455 Element = self.etree.Element 1456 SubElement = self.etree.SubElement 1457 1458 a = Element('a') 1459 b = SubElement(a, 'b') 1460 c = SubElement(a, 'c') 1461 d = SubElement(b, 'd') 1462 e = SubElement(c, 'e') 1463 1464 self.assertEquals( 1465 [a, b, d, c, e], 1466 list(a.getiterator())) 1467 self.assertEquals( 1468 [d], 1469 list(d.getiterator()))

1470

1471 - def test_getiterator_empty(self):

1472 Element = self.etree.Element 1473 SubElement = self.etree.SubElement 1474 1475 a = Element('a') 1476 b = SubElement(a, 'b') 1477 c = SubElement(a, 'c') 1478 d = SubElement(b, 'd') 1479 e = SubElement(c, 'e') 1480 1481 self.assertEquals( 1482 [], 1483 list(a.getiterator('none'))) 1484 self.assertEquals( 1485 [], 1486 list(e.getiterator('none'))) 1487 self.assertEquals( 1488 [e], 1489 list(e.getiterator()))

1490

1491 - def test_getiterator_filter(self):

1492 Element = self.etree.Element 1493 SubElement = self.etree.SubElement 1494 1495 a = Element('a') 1496 b = SubElement(a, 'b') 1497 c = SubElement(a, 'c') 1498 d = SubElement(b, 'd') 1499 e = SubElement(c, 'e') 1500 1501 self.assertEquals( 1502 [a], 1503 list(a.getiterator('a'))) 1504 a2 = SubElement(e, 'a') 1505 self.assertEquals( 1506 [a, a2], 1507 list(a.getiterator('a'))) 1508 self.assertEquals( 1509 [a2], 1510 list(c.getiterator('a')))

1511

1512 - def test_getiterator_filter_all(self):

1513 Element = self.etree.Element 1514 SubElement = self.etree.SubElement 1515 1516 a = Element('a') 1517 b = SubElement(a, 'b') 1518 c = SubElement(a, 'c') 1519 d = SubElement(b, 'd') 1520 e = SubElement(c, 'e') 1521 1522 self.assertEquals( 1523 [a, b, d, c, e], 1524 list(a.getiterator('*')))

1525

1526 - def test_getiterator_filter_comment(self):

1527 Element = self.etree.Element 1528 Comment = self.etree.Comment 1529 SubElement = self.etree.SubElement 1530 1531 a = Element('a') 1532 b = SubElement(a, 'b') 1533 comment_b = Comment("TEST-b") 1534 b.append(comment_b) 1535 1536 self.assertEquals( 1537 [comment_b], 1538 list(a.getiterator(Comment))) 1539 1540 comment_a = Comment("TEST-a") 1541 a.append(comment_a) 1542 1543 self.assertEquals( 1544 [comment_b, comment_a], 1545 list(a.getiterator(Comment))) 1546 1547 self.assertEquals( 1548 [comment_b], 1549 list(b.getiterator(Comment)))

1550

1551 - def test_getiterator_filter_pi(self):

1552 Element = self.etree.Element 1553 PI = self.etree.ProcessingInstruction 1554 SubElement = self.etree.SubElement 1555 1556 a = Element('a') 1557 b = SubElement(a, 'b') 1558 pi_b = PI("TEST-b") 1559 b.append(pi_b) 1560 1561 self.assertEquals( 1562 [pi_b], 1563 list(a.getiterator(PI))) 1564 1565 pi_a = PI("TEST-a") 1566 a.append(pi_a) 1567 1568 self.assertEquals( 1569 [pi_b, pi_a], 1570 list(a.getiterator(PI))) 1571 1572 self.assertEquals( 1573 [pi_b], 1574 list(b.getiterator(PI)))

1575

1576 - def test_getiterator_with_text(self):

1577 Element = self.etree.Element 1578 SubElement = self.etree.SubElement 1579 1580 a = Element('a') 1581 a.text = 'a' 1582 b = SubElement(a, 'b') 1583 b.text = 'b' 1584 b.tail = 'b1' 1585 c = SubElement(a, 'c') 1586 c.text = 'c' 1587 c.tail = 'c1' 1588 d = SubElement(b, 'd') 1589 c.text = 'd' 1590 c.tail = 'd1' 1591 e = SubElement(c, 'e') 1592 e.text = 'e' 1593 e.tail = 'e1' 1594 1595 self.assertEquals( 1596 [a, b, d, c, e], 1597 list(a.getiterator()))

1598 #self.assertEquals( 1599 # [d], 1600 # list(d.getiterator())) 1601

1602 - def test_getiterator_filter_with_text(self):

1603 Element = self.etree.Element 1604 SubElement = self.etree.SubElement 1605 1606 a = Element('a') 1607 a.text = 'a' 1608 b = SubElement(a, 'b') 1609 b.text = 'b' 1610 b.tail = 'b1' 1611 c = SubElement(a, 'c') 1612 c.text = 'c' 1613 c.tail = 'c1' 1614 d = SubElement(b, 'd') 1615 c.text = 'd' 1616 c.tail = 'd1' 1617 e = SubElement(c, 'e') 1618 e.text = 'e' 1619 e.tail = 'e1' 1620 1621 self.assertEquals( 1622 [a], 1623 list(a.getiterator('a'))) 1624 a2 = SubElement(e, 'a') 1625 self.assertEquals( 1626 [a, a2], 1627 list(a.getiterator('a'))) 1628 self.assertEquals( 1629 [a2], 1630 list(e.getiterator('a')))

1631

1632 - def test_attribute_manipulation(self):

1633 Element = self.etree.Element 1634 1635 a = Element('a') 1636 a.attrib['foo'] = 'Foo' 1637 a.attrib['bar'] = 'Bar' 1638 self.assertEquals('Foo', a.attrib['foo']) 1639 del a.attrib['foo'] 1640 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

1641

1642 - def test_getslice(self):

1643 Element = self.etree.Element 1644 SubElement = self.etree.SubElement 1645 1646 a = Element('a') 1647 b = SubElement(a, 'b') 1648 c = SubElement(a, 'c') 1649 d = SubElement(a, 'd') 1650 1651 self.assertEquals( 1652 [b, c], 1653 a[0:2]) 1654 self.assertEquals( 1655 [b, c, d], 1656 a[:]) 1657 self.assertEquals( 1658 [b, c, d], 1659 a[:10]) 1660 self.assertEquals( 1661 [b], 1662 a[0:1]) 1663 self.assertEquals( 1664 [], 1665 a[10:12])

1666

1667 - def test_getslice_negative(self):

1668 Element = self.etree.Element 1669 SubElement = self.etree.SubElement 1670 1671 a = Element('a') 1672 b = SubElement(a, 'b') 1673 c = SubElement(a, 'c') 1674 d = SubElement(a, 'd') 1675 1676 self.assertEquals( 1677 [d], 1678 a[-1:]) 1679 self.assertEquals( 1680 [c, d], 1681 a[-2:]) 1682 self.assertEquals( 1683 [c], 1684 a[-2:-1]) 1685 self.assertEquals( 1686 [b, c], 1687 a[-3:-1]) 1688 self.assertEquals( 1689 [b, c], 1690 a[-3:2])

1691

1692 - def test_getslice_step(self):

1693 Element = self.etree.Element 1694 SubElement = self.etree.SubElement 1695 1696 a = Element('a') 1697 b = SubElement(a, 'b') 1698 c = SubElement(a, 'c') 1699 d = SubElement(a, 'd') 1700 e = SubElement(a, 'e') 1701 1702 self.assertEquals( 1703 [e,d,c,b], 1704 a[::-1]) 1705 self.assertEquals( 1706 [b,d], 1707 a[::2]) 1708 self.assertEquals( 1709 [e,c], 1710 a[::-2]) 1711 self.assertEquals( 1712 [d,c], 1713 a[-2:0:-1]) 1714 self.assertEquals( 1715 [e], 1716 a[:1:-2])

1717

1718 - def test_getslice_text(self):

1719 ElementTree = self.etree.ElementTree 1720 1721 f = StringIO('<a>BB1<c>C</c>C1</a>') 1722 doc = ElementTree(file=f) 1723 a = doc.getroot() 1724 b = a[0] 1725 c = a[1] 1726 self.assertEquals( 1727 [b, c], 1728 a[:]) 1729 self.assertEquals( 1730 [b], 1731 a[0:1]) 1732 self.assertEquals( 1733 [c], 1734 a[1:])

1735

1736 - def test_comment_getitem_getslice(self):

1737 Element = self.etree.Element 1738 Comment = self.etree.Comment 1739 SubElement = self.etree.SubElement 1740 1741 a = Element('a') 1742 b = SubElement(a, 'b') 1743 foo = Comment('foo') 1744 a.append(foo) 1745 c = SubElement(a, 'c') 1746 self.assertEquals( 1747 [b, foo, c], 1748 a[:]) 1749 self.assertEquals( 1750 foo, 1751 a[1]) 1752 a[1] = new = Element('new') 1753 self.assertEquals( 1754 new, 1755 a[1]) 1756 self.assertXML( 1757 '<a><new></new><c></c></a>', 1758 a)

1759

1760 - def test_delslice(self):

1761 Element = self.etree.Element 1762 SubElement = self.etree.SubElement 1763 1764 a = Element('a') 1765 b = SubElement(a, 'b') 1766 c = SubElement(a, 'c') 1767 d = SubElement(a, 'd') 1768 e = SubElement(a, 'e') 1769 1770 del a[1:3] 1771 self.assertEquals( 1772 [b, e], 1773 list(a))

1774

1775 - def test_delslice_negative1(self):

1776 Element = self.etree.Element 1777 SubElement = self.etree.SubElement 1778 1779 a = Element('a') 1780 b = SubElement(a, 'b') 1781 c = SubElement(a, 'c') 1782 d = SubElement(a, 'd') 1783 e = SubElement(a, 'e') 1784 1785 del a[1:-1] 1786 self.assertEquals( 1787 [b, e], 1788 list(a))

1789

1790 - def test_delslice_negative2(self):

1791 Element = self.etree.Element 1792 SubElement = self.etree.SubElement 1793 1794 a = Element('a') 1795 b = SubElement(a, 'b') 1796 c = SubElement(a, 'c') 1797 d = SubElement(a, 'd') 1798 e = SubElement(a, 'e') 1799 1800 del a[-3:-1] 1801 self.assertEquals( 1802 [b, e], 1803 list(a))

1804

1805 - def test_delslice_step(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::2] 1816 self.assertEquals( 1817 [b, d], 1818 list(a))

1819

1820 - def test_delslice_step_negative(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] 1831 self.assertEquals( 1832 [], 1833 list(a))

1834

1835 - def test_delslice_step_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[::-2] 1846 self.assertEquals( 1847 [b, d], 1848 list(a))

1849

1850 - def test_delslice_child_tail(self):

1851 ElementTree = self.etree.ElementTree 1852 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1853 doc = ElementTree(file=f) 1854 a = doc.getroot() 1855 del a[1:3] 1856 self.assertXML( 1857 '<a>B2<e></e>E2</a>', 1858 a)

1859

1860 - def test_delslice_tail(self):

1861 XML = self.etree.XML 1862 a = XML('<a>B2<c></c>C2</a>') 1863 b, c = a 1864 1865 del a[:] 1866 1867 self.assertEquals("B2", b.tail) 1868 self.assertEquals("C2", c.tail)

1869

1870 - def test_delslice_memory(self):

1871 # this could trigger a crash 1872 Element = self.etree.Element 1873 SubElement = self.etree.SubElement 1874 a = Element('a') 1875 b = SubElement(a, 'b') 1876 c = SubElement(b, 'c') 1877 del b # no more reference to b 1878 del a[:] 1879 self.assertEquals('c', c.tag)

1880

1881 - def test_setslice(self):

1882 Element = self.etree.Element 1883 SubElement = self.etree.SubElement 1884 1885 a = Element('a') 1886 b = SubElement(a, 'b') 1887 c = SubElement(a, 'c') 1888 d = SubElement(a, 'd') 1889 1890 e = Element('e') 1891 f = Element('f') 1892 g = Element('g') 1893 1894 s = [e, f, g] 1895 a[1:2] = s 1896 self.assertEquals( 1897 [b, e, f, g, d], 1898 list(a))

1899

1900 - def test_setslice_all(self):

1901 Element = self.etree.Element 1902 SubElement = self.etree.SubElement 1903 1904 a = Element('a') 1905 b = SubElement(a, 'b') 1906 c = SubElement(a, 'c') 1907 1908 e = Element('e') 1909 f = Element('f') 1910 g = Element('g') 1911 1912 s = [e, f, g] 1913 a[:] = s 1914 self.assertEquals( 1915 [e, f, g], 1916 list(a))

1917

1918 - def test_setslice_all_empty(self):

1919 Element = self.etree.Element 1920 SubElement = self.etree.SubElement 1921 1922 a = Element('a') 1923 1924 e = Element('e') 1925 f = Element('f') 1926 g = Element('g') 1927 1928 s = [e, f, g] 1929 a[:] = s 1930 self.assertEquals( 1931 [e, f, g], 1932 list(a))

1933

1934 - def test_setslice_all_replace(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 1943 s = [b, c, d] 1944 a[:] = s 1945 self.assertEquals( 1946 [b, c, d], 1947 list(a))

1948

1949 - def test_setslice_all_replace_reversed(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 1958 s = [d, c, b] 1959 a[:] = s 1960 self.assertEquals( 1961 [d, c, b], 1962 list(a))

1963

1964 - def test_setslice_end(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 1972 e = Element('e') 1973 f = Element('f') 1974 g = Element('g') 1975 h = Element('h') 1976 1977 s = [e, f] 1978 a[99:] = s 1979 self.assertEquals( 1980 [a, b, e, f], 1981 list(a)) 1982 1983 s = [g, h] 1984 a[:0] = s 1985 self.assertEquals( 1986 [g, h, a, b, e, f], 1987 list(a))

1988

1989 - def test_setslice_single(self):

1990 Element = self.etree.Element 1991 SubElement = self.etree.SubElement 1992 1993 a = Element('a') 1994 b = SubElement(a, 'b') 1995 c = SubElement(a, 'c') 1996 1997 e = Element('e') 1998 f = Element('f') 1999 2000 s = [e] 2001 a[0:1] = s 2002 self.assertEquals( 2003 [e, c], 2004 list(a)) 2005 2006 s = [f] 2007 a[1:2] = s 2008 self.assertEquals( 2009 [e, f], 2010 list(a))

2011

2012 - def test_setslice_tail(self):

2013 ElementTree = self.etree.ElementTree 2014 Element = self.etree.Element 2015 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2016 doc = ElementTree(file=f) 2017 a = doc.getroot() 2018 x = Element('x') 2019 y = Element('y') 2020 z = Element('z') 2021 x.tail = 'X2' 2022 y.tail = 'Y2' 2023 z.tail = 'Z2' 2024 a[1:3] = [x, y, z] 2025 self.assertXML( 2026 '<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>', 2027 a)

2028

2029 - def test_setslice_negative(self):

2030 Element = self.etree.Element 2031 SubElement = self.etree.SubElement 2032 2033 a = Element('a') 2034 b = SubElement(a, 'b') 2035 c = SubElement(a, 'c') 2036 d = SubElement(a, 'd') 2037 2038 x = Element('x') 2039 y = Element('y') 2040 2041 a[1:-1] = [x, y] 2042 self.assertEquals( 2043 [b, x, y, d], 2044 list(a))

2045

2046 - def test_setslice_negative2(self):

2047 Element = self.etree.Element 2048 SubElement = self.etree.SubElement 2049 2050 a = Element('a') 2051 b = SubElement(a, 'b') 2052 c = SubElement(a, 'c') 2053 d = SubElement(a, 'd') 2054 2055 x = Element('x') 2056 y = Element('y') 2057 2058 a[1:-2] = [x, y] 2059 self.assertEquals( 2060 [b, x, y, c, d], 2061 list(a))

2062

2063 - def test_setslice_end(self):

2064 Element = self.etree.Element 2065 SubElement = self.etree.SubElement 2066 2067 a = Element('a') 2068 b = SubElement(a, 'b') 2069 c = SubElement(a, 'c') 2070 d = SubElement(a, 'd') 2071 2072 e = Element('e') 2073 f = Element('f') 2074 g = Element('g') 2075 2076 s = [e, f, g] 2077 a[3:] = s 2078 self.assertEquals( 2079 [b, c, d, e, f, g], 2080 list(a))

2081

2082 - def test_setslice_empty(self):

2083 Element = self.etree.Element 2084 2085 a = Element('a') 2086 2087 b = Element('b') 2088 c = Element('c') 2089 2090 a[:] = [b, c] 2091 self.assertEquals( 2092 [b, c], 2093 list(a))

2094

2095 - def test_tail_elementtree_root(self):

2096 Element = self.etree.Element 2097 ElementTree = self.etree.ElementTree 2098 2099 a = Element('a') 2100 a.tail = 'A2' 2101 t = ElementTree(element=a) 2102 self.assertEquals('A2', 2103 a.tail)

2104

2105 - def test_elementtree_getiterator(self):

2106 Element = self.etree.Element 2107 SubElement = self.etree.SubElement 2108 ElementTree = self.etree.ElementTree 2109 2110 a = Element('a') 2111 b = SubElement(a, 'b') 2112 c = SubElement(a, 'c') 2113 d = SubElement(b, 'd') 2114 e = SubElement(c, 'e') 2115 t = ElementTree(element=a) 2116 2117 self.assertEquals( 2118 [a, b, d, c, e], 2119 list(t.getiterator()))

2120

2121 - def test_elementtree_getiterator_filter(self):

2122 Element = self.etree.Element 2123 SubElement = self.etree.SubElement 2124 ElementTree = self.etree.ElementTree 2125 a = Element('a') 2126 b = SubElement(a, 'b') 2127 c = SubElement(a, 'c') 2128 d = SubElement(b, 'd') 2129 e = SubElement(c, 'e') 2130 t = ElementTree(element=a) 2131 2132 self.assertEquals( 2133 [a], 2134 list(t.getiterator('a'))) 2135 a2 = SubElement(e, 'a') 2136 self.assertEquals( 2137 [a, a2], 2138 list(t.getiterator('a')))

2139

2140 - def test_ns_access(self):

2141 ElementTree = self.etree.ElementTree 2142 ns = 'http://xml.infrae.com/1' 2143 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2144 t = ElementTree(file=f) 2145 a = t.getroot() 2146 self.assertEquals('{%s}a' % ns, 2147 a.tag) 2148 self.assertEquals('{%s}b' % ns, 2149 a[0].tag)

2150

2151 - def test_ns_access2(self):

2152 ElementTree = self.etree.ElementTree 2153 ns = 'http://xml.infrae.com/1' 2154 ns2 = 'http://xml.infrae.com/2' 2155 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2156 t = ElementTree(file=f) 2157 a = t.getroot() 2158 self.assertEquals('{%s}a' % ns, 2159 a.tag) 2160 self.assertEquals('{%s}b' % ns, 2161 a[0].tag) 2162 self.assertEquals('{%s}b' % ns2, 2163 a[1].tag)

2164

2165 - def test_ns_setting(self):

2166 Element = self.etree.Element 2167 SubElement = self.etree.SubElement 2168 ns = 'http://xml.infrae.com/1' 2169 ns2 = 'http://xml.infrae.com/2' 2170 a = Element('{%s}a' % ns) 2171 b = SubElement(a, '{%s}b' % ns2) 2172 c = SubElement(a, '{%s}c' % ns) 2173 self.assertEquals('{%s}a' % ns, 2174 a.tag) 2175 self.assertEquals('{%s}b' % ns2, 2176 b.tag) 2177 self.assertEquals('{%s}c' % ns, 2178 c.tag) 2179 self.assertEquals('{%s}a' % ns, 2180 a.tag) 2181 self.assertEquals('{%s}b' % ns2, 2182 b.tag) 2183 self.assertEquals('{%s}c' % ns, 2184 c.tag)

2185

2186 - def test_ns_tag_parse(self):

2187 Element = self.etree.Element 2188 SubElement = self.etree.SubElement 2189 ElementTree = self.etree.ElementTree 2190 2191 ns = 'http://xml.infrae.com/1' 2192 ns2 = 'http://xml.infrae.com/2' 2193 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2194 t = ElementTree(file=f) 2195 2196 a = t.getroot() 2197 self.assertEquals('{%s}a' % ns, 2198 a.tag) 2199 self.assertEquals('{%s}b' % ns2, 2200 a[0].tag) 2201 self.assertEquals('{%s}b' % ns, 2202 a[1].tag)

2203

2204 - def test_ns_attr(self):

2205 Element = self.etree.Element 2206 ns = 'http://xml.infrae.com/1' 2207 ns2 = 'http://xml.infrae.com/2' 2208 a = Element('a') 2209 a.set('{%s}foo' % ns, 'Foo') 2210 a.set('{%s}bar' % ns2, 'Bar') 2211 self.assertEquals( 2212 'Foo', 2213 a.get('{%s}foo' % ns)) 2214 self.assertEquals( 2215 'Bar', 2216 a.get('{%s}bar' % ns2)) 2217 try: 2218 self.assertXML( 2219 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2), 2220 a) 2221 except AssertionError: 2222 self.assertXML( 2223 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns), 2224 a)

2225

2226 - def test_ns_move(self):

2227 Element = self.etree.Element 2228 ElementTree = self.etree.ElementTree 2229 2230 one = self.etree.parse( 2231 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2232 baz = one.getroot()[0][0] 2233 2234 two = ElementTree(Element('root')) 2235 two.getroot().append(baz) 2236 # removing the originating document could cause a crash/error before 2237 # as namespace is not moved along with it 2238 del one 2239 self.assertEquals('{http://a.b.c}baz', baz.tag)

2240

2241 - def test_ns_decl_tostring(self):

2242 tostring = self.etree.tostring 2243 root = self.etree.XML( 2244 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>') 2245 baz = root[0][0] 2246 2247 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2248 tostring(baz)) 2249 self.assertEquals(["http://a.b.c"], nsdecl)

2250

2251 - def test_ns_decl_tostring_default(self):

2252 tostring = self.etree.tostring 2253 root = self.etree.XML( 2254 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>') 2255 baz = root[0][0] 2256 2257 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2258 tostring(baz)) 2259 self.assertEquals(["http://a.b.c"], nsdecl)

2260

2261 - def test_ns_decl_tostring_root(self):

2262 tostring = self.etree.tostring 2263 root = self.etree.XML( 2264 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>') 2265 baz = root[0][0] 2266 2267 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2268 tostring(baz)) 2269 2270 self.assertEquals(["http://a.b.c"], nsdecl)

2271

2272 - def test_ns_decl_tostring_element(self):

2273 Element = self.etree.Element 2274 SubElement = self.etree.SubElement 2275 2276 root = Element("foo") 2277 bar = SubElement(root, "{http://a.b.c}bar") 2278 baz = SubElement(bar, "{http://a.b.c}baz") 2279 2280 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2281 self.etree.tostring(baz)) 2282 2283 self.assertEquals(["http://a.b.c"], nsdecl)

2284

2285 - def test_attribute_xmlns_move(self):

2286 Element = self.etree.Element 2287 2288 root = Element('element') 2289 2290 subelement = Element('subelement', 2291 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2292 self.assertEquals(1, len(subelement.attrib)) 2293 self.assertEquals( 2294 "foo", 2295 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2296 2297 root.append(subelement) 2298 self.assertEquals(1, len(subelement.attrib)) 2299 self.assertEquals( 2300 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(), 2301 subelement.attrib.items()) 2302 self.assertEquals( 2303 "foo", 2304 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2305

2306 - def test_tostring(self):

2307 tostring = self.etree.tostring 2308 Element = self.etree.Element 2309 SubElement = self.etree.SubElement 2310 2311 a = Element('a') 2312 b = SubElement(a, 'b') 2313 c = SubElement(a, 'c') 2314 2315 self.assertEquals('<a><c></c></a>', 2316 canonicalize(tostring(a)))

2317

2318 - def test_tostring_element(self):

2319 tostring = self.etree.tostring 2320 Element = self.etree.Element 2321 SubElement = self.etree.SubElement 2322 2323 a = Element('a') 2324 b = SubElement(a, 'b') 2325 c = SubElement(a, 'c') 2326 d = SubElement(c, 'd') 2327 self.assertEquals('', 2328 canonicalize(tostring(b))) 2329 self.assertEquals('<c><d></d></c>', 2330 canonicalize(tostring(c)))

2331

2332 - def test_tostring_element_tail(self):

2333 tostring = self.etree.tostring 2334 Element = self.etree.Element 2335 SubElement = self.etree.SubElement 2336 2337 a = Element('a') 2338 b = SubElement(a, 'b') 2339 c = SubElement(a, 'c') 2340 d = SubElement(c, 'd') 2341 b.tail = 'Foo' 2342 2343 self.assert_(tostring(b) == 'Foo' or 2344 tostring(b) == 'Foo')

2345

2346 - def test_tostring_method_html(self):

2347 tostring = self.etree.tostring 2348 Element = self.etree.Element 2349 SubElement = self.etree.SubElement 2350 2351 html = Element('html') 2352 body = SubElement(html, 'body') 2353 p = SubElement(body, 'p') 2354 p.text = "html" 2355 SubElement(p, 'br').tail = "test" 2356 2357 self.assertEquals('<html><body>html test</body></html>', 2358 tostring(html, method="html"))

2359

2360 - def test_tostring_method_text(self):

2361 tostring = self.etree.tostring 2362 Element = self.etree.Element 2363 SubElement = self.etree.SubElement 2364 2365 a = Element('a') 2366 a.text = "A" 2367 a.tail = "tail" 2368 b = SubElement(a, 'b') 2369 b.text = "B" 2370 b.tail = "TAIL" 2371 c = SubElement(a, 'c') 2372 c.text = "C" 2373 2374 self.assertEquals('ABTAILCtail', 2375 tostring(a, method="text"))

2376

2377 - def test_iterparse(self):

2378 iterparse = self.etree.iterparse 2379 f = StringIO('<a><c/></a>') 2380 2381 iterator = iterparse(f) 2382 self.assertEquals(None, 2383 iterator.root) 2384 events = list(iterator) 2385 root = iterator.root 2386 self.assertEquals( 2387 [('end', root[0]), ('end', root[1]), ('end', root)], 2388 events)

2389

2390 - def test_iterparse_file(self):

2391 iterparse = self.etree.iterparse 2392 iterator = iterparse(fileInTestDir("test.xml")) 2393 self.assertEquals(None, 2394 iterator.root) 2395 events = list(iterator) 2396 root = iterator.root 2397 self.assertEquals( 2398 [('end', root[0]), ('end', root)], 2399 events)

2400

2401 - def test_iterparse_start(self):

2402 iterparse = self.etree.iterparse 2403 f = StringIO('<a><c/></a>') 2404 2405 iterator = iterparse(f, events=('start',)) 2406 events = list(iterator) 2407 root = iterator.root 2408 self.assertEquals( 2409 [('start', root), ('start', root[0]), ('start', root[1])], 2410 events)

2411

2412 - def test_iterparse_start_end(self):

2413 iterparse = self.etree.iterparse 2414 f = StringIO('<a><c/></a>') 2415 2416 iterator = iterparse(f, events=('start','end')) 2417 events = list(iterator) 2418 root = iterator.root 2419 self.assertEquals( 2420 [('start', root), ('start', root[0]), ('end', root[0]), 2421 ('start', root[1]), ('end', root[1]), ('end', root)], 2422 events)

2423

2424 - def test_iterparse_clear(self):

2425 iterparse = self.etree.iterparse 2426 f = StringIO('<a><c/></a>') 2427 2428 iterator = iterparse(f) 2429 for event, elem in iterator: 2430 elem.clear() 2431 2432 root = iterator.root 2433 self.assertEquals(0, 2434 len(root))

2435

2436 - def test_iterparse_large(self):

2437 iterparse = self.etree.iterparse 2438 CHILD_COUNT = 12345 2439 f = StringIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2440 2441 i = 0 2442 for key in iterparse(f): 2443 event, element = key 2444 i += 1 2445 self.assertEquals(i, CHILD_COUNT + 1)

2446

2447 - def test_iterparse_attrib_ns(self):

2448 iterparse = self.etree.iterparse 2449 f = StringIO('<a xmlns="ns1"><c xmlns="ns2"/></a>') 2450 2451 attr_name = '{testns}bla' 2452 events = [] 2453 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2454 for event, elem in iterator: 2455 events.append(event) 2456 if event == 'start': 2457 if elem.tag != '{ns1}a': 2458 elem.set(attr_name, 'value') 2459 2460 self.assertEquals( 2461 ['start-ns', 'start', 'start', 'start-ns', 'start', 2462 'end', 'end-ns', 'end', 'end', 'end-ns'], 2463 events) 2464 2465 root = iterator.root 2466 self.assertEquals( 2467 None, 2468 root.get(attr_name)) 2469 self.assertEquals( 2470 'value', 2471 root[0].get(attr_name))

2472

2473 - def test_iterparse_getiterator(self):

2474 iterparse = self.etree.iterparse 2475 f = StringIO('<a><d/><c/></a>') 2476 2477 counts = [] 2478 for event, elem in iterparse(f): 2479 counts.append(len(list(elem.getiterator()))) 2480 self.assertEquals( 2481 [1,2,1,4], 2482 counts)

2483

2484 - def test_parse_file(self):

2485 parse = self.etree.parse 2486 # from file 2487 tree = parse(fileInTestDir('test.xml')) 2488 self.assertXML( 2489 '<a></a>', 2490 tree.getroot())

2491

2492 - def test_parse_file_nonexistent(self):

2493 parse = self.etree.parse 2494 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2495

2496 - def test_parse_file_object(self):

2497 parse = self.etree.parse 2498 # from file object 2499 f = open(fileInTestDir('test.xml'), 'r') 2500 tree = parse(f) 2501 f.close() 2502 self.assertXML( 2503 '<a></a>', 2504 tree.getroot())

2505

2506 - def test_parse_stringio(self):

2507 parse = self.etree.parse 2508 # from StringIO 2509 f = StringIO('<a></a>') 2510 tree = parse(f) 2511 f.close() 2512 self.assertXML( 2513 '<a></a>', 2514 tree.getroot() 2515 )

2516

2517 - def test_parse_with_encoding(self):

2518 # this can fail in libxml2 <= 2.6.22 2519 parse = self.etree.parse 2520 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2521 self.assertXML('<html></html>', 2522 tree.getroot())

2523

2524 - def test_encoding(self):

2525 Element = self.etree.Element 2526 2527 a = Element('a') 2528 a.text = u'Søk på nettet' 2529 self.assertXML( 2530 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2531 a, 'utf-8')

2532

2533 - def test_encoding_exact(self):

2534 ElementTree = self.etree.ElementTree 2535 Element = self.etree.Element 2536 2537 a = Element('a') 2538 a.text = u'Søk på nettet' 2539 2540 f = StringIO() 2541 tree = ElementTree(element=a) 2542 tree.write(f, encoding='utf-8') 2543 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2544 f.getvalue())

2545

2546 - def test_parse_file_encoding(self):

2547 parse = self.etree.parse 2548 # from file 2549 tree = parse(fileInTestDir('test-string.xml')) 2550 self.assertXML( 2551 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2552 tree.getroot(), 'UTF-8')

2553

2554 - def test_parse_file_object_encoding(self):

2555 parse = self.etree.parse 2556 # from file object 2557 f = open(fileInTestDir('test-string.xml'), 'r') 2558 tree = parse(f) 2559 f.close() 2560 self.assertXML( 2561 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2562 tree.getroot(), 'UTF-8')

2563

2564 - def test_encoding_8bit_latin1(self):

2565 ElementTree = self.etree.ElementTree 2566 Element = self.etree.Element 2567 2568 a = Element('a') 2569 a.text = u'Søk på nettet' 2570 2571 f = StringIO() 2572 tree = ElementTree(element=a) 2573 tree.write(f, encoding='iso-8859-1') 2574 result = f.getvalue() 2575 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2576 self.assertEncodingDeclaration(result,'iso-8859-1') 2577 result = result.split('?>', 1)[-1] 2578 if result[0] == '\n': 2579 result = result[1:] 2580 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2581 result)

2582

2583 - def test_parse_encoding_8bit_explicit(self):

2584 XMLParser = self.etree.XMLParser 2585 2586 text = u'Søk på nettet' 2587 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1') 2588 2589 self.assertRaises(self.etree.ParseError, 2590 self.etree.parse, 2591 StringIO(xml_latin1)) 2592 2593 tree = self.etree.parse(StringIO(xml_latin1), 2594 XMLParser(encoding="iso-8859-1")) 2595 a = tree.getroot() 2596 self.assertEquals(a.text, text)

2597

2598 - def test_parse_encoding_8bit_override(self):

2599 XMLParser = self.etree.XMLParser 2600 2601 text = u'Søk på nettet' 2602 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 2603 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 2604 ).encode('iso-8859-1') 2605 2606 self.assertRaises(self.etree.ParseError, 2607 self.etree.parse, 2608 StringIO(xml_latin1)) 2609 2610 tree = self.etree.parse(StringIO(xml_latin1), 2611 XMLParser(encoding="iso-8859-1")) 2612 a = tree.getroot() 2613 self.assertEquals(a.text, text)

2614

2615 - def _test_wrong_unicode_encoding(self):

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

2621

2622 - def test_encoding_write_default_encoding(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) 2632 data = f.getvalue() 2633 self.assertEquals( 2634 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2635 data)

2636

2637 - def test_encoding_tostring(self):

2638 Element = self.etree.Element 2639 tostring = self.etree.tostring 2640 2641 a = Element('a') 2642 a.text = u'Søk på nettet' 2643 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2644 tostring(a, encoding='utf-8'))

2645

2646 - def test_encoding_tostring_unknown(self):

2647 Element = self.etree.Element 2648 tostring = self.etree.tostring 2649 2650 a = Element('a') 2651 a.text = u'Søk på nettet' 2652 self.assertRaises(LookupError, tostring, a, 2653 encoding='Invalid Encoding')

2654

2655 - def test_encoding_tostring_sub(self):

2656 Element = self.etree.Element 2657 SubElement = self.etree.SubElement 2658 tostring = self.etree.tostring 2659 2660 a = Element('a') 2661 b = SubElement(a, 'b') 2662 b.text = u'Søk på nettet' 2663 self.assertEquals(u'Søk på nettet'.encode('UTF-8'), 2664 tostring(b, encoding='utf-8'))

2665

2666 - def test_encoding_tostring_sub_tail(self):

2667 Element = self.etree.Element 2668 SubElement = self.etree.SubElement 2669 tostring = self.etree.tostring 2670 2671 a = Element('a') 2672 b = SubElement(a, 'b') 2673 b.text = u'Søk på nettet' 2674 b.tail = u'Søk' 2675 self.assertEquals(u'Søk på nettetSøk'.encode('UTF-8'), 2676 tostring(b, encoding='utf-8'))

2677

2678 - def test_encoding_tostring_default_encoding(self):

2679 Element = self.etree.Element 2680 SubElement = self.etree.SubElement 2681 tostring = self.etree.tostring 2682 2683 a = Element('a') 2684 a.text = u'Søk på nettet' 2685 2686 expected = '<a>Søk på nettet</a>' 2687 self.assertEquals( 2688 expected, 2689 tostring(a))

2690

2691 - def test_encoding_sub_tostring_default_encoding(self):

2692 Element = self.etree.Element 2693 SubElement = self.etree.SubElement 2694 tostring = self.etree.tostring 2695 2696 a = Element('a') 2697 b = SubElement(a, 'b') 2698 b.text = u'Søk på nettet' 2699 2700 expected = 'Søk på nettet' 2701 self.assertEquals( 2702 expected, 2703 tostring(b))

2704

2705 - def test_encoding_8bit_xml(self):

2706 utext = u'Søk på nettet' 2707 uxml = u'%s' % utext 2708 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2709 isoxml = prologue + uxml.encode('iso-8859-1') 2710 tree = self.etree.XML(isoxml) 2711 self.assertEquals(utext, tree.text)

2712

2713 - def test_encoding_utf8_bom(self):

2714 utext = u'Søk på nettet' 2715 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \ 2716 u'%s' % utext 2717 bom = '\xEF\xBB\xBF' 2718 xml = bom + uxml.encode("utf-8") 2719 tree = etree.XML(xml) 2720 self.assertEquals(utext, tree.text)

2721

2722 - def test_encoding_8bit_parse_stringio(self):

2723 utext = u'Søk på nettet' 2724 uxml = u'%s' % utext 2725 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2726 isoxml = prologue + uxml.encode('iso-8859-1') 2727 el = self.etree.parse(StringIO(isoxml)).getroot() 2728 self.assertEquals(utext, el.text)

2729

2730 - def test_deepcopy_elementtree(self):

2731 Element = self.etree.Element 2732 ElementTree = self.etree.ElementTree 2733 2734 a = Element('a') 2735 a.text = "Foo" 2736 atree = ElementTree(a) 2737 2738 btree = copy.deepcopy(atree) 2739 self.assertEqual("Foo", atree.getroot().text) 2740 self.assertEqual("Foo", btree.getroot().text) 2741 self.assertFalse(btree is atree) 2742 self.assertFalse(btree.getroot() is atree.getroot())

2743

2744 - def test_deepcopy(self):

2745 Element = self.etree.Element 2746 2747 a = Element('a') 2748 a.text = 'Foo' 2749 2750 b = copy.deepcopy(a) 2751 self.assertEquals('Foo', b.text) 2752 2753 b.text = 'Bar' 2754 self.assertEquals('Bar', b.text) 2755 self.assertEquals('Foo', a.text) 2756 2757 del a 2758 self.assertEquals('Bar', b.text)

2759

2760 - def test_deepcopy_tail(self):

2761 Element = self.etree.Element 2762 2763 a = Element('a') 2764 a.tail = 'Foo' 2765 2766 b = copy.deepcopy(a) 2767 self.assertEquals('Foo', b.tail) 2768 2769 b.tail = 'Bar' 2770 self.assertEquals('Bar', b.tail) 2771 self.assertEquals('Foo', a.tail) 2772 2773 del a 2774 self.assertEquals('Bar', b.tail)

2775

2776 - def test_deepcopy_subelement(self):

2777 Element = self.etree.Element 2778 SubElement = self.etree.SubElement 2779 2780 root = Element('root') 2781 a = SubElement(root, 'a') 2782 a.text = 'FooText' 2783 a.tail = 'FooTail' 2784 2785 b = copy.deepcopy(a) 2786 self.assertEquals('FooText', b.text) 2787 self.assertEquals('FooTail', b.tail) 2788 2789 b.text = 'BarText' 2790 b.tail = 'BarTail' 2791 self.assertEquals('BarTail', b.tail) 2792 self.assertEquals('FooTail', a.tail) 2793 self.assertEquals('BarText', b.text) 2794 self.assertEquals('FooText', a.text) 2795 2796 del a 2797 self.assertEquals('BarTail', b.tail) 2798 self.assertEquals('BarText', b.text)

2799

2800 - def test_deepcopy_namespaces(self):

2801 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 2802 <parent><node t:foo="bar" /></parent> 2803 </doc>''') 2804 self.assertEquals( 2805 root[0][0].get('{tns}foo'), 2806 copy.deepcopy(root[0])[0].get('{tns}foo') ) 2807 self.assertEquals( 2808 root[0][0].get('{tns}foo'), 2809 copy.deepcopy(root[0][0]).get('{tns}foo') )

2810

2811 - def test_deepcopy_append(self):

2812 # previously caused a crash 2813 Element = self.etree.Element 2814 tostring = self.etree.tostring 2815 2816 a = Element('a') 2817 b = copy.deepcopy(a) 2818 a.append( Element('C') ) 2819 b.append( Element('X') ) 2820 2821 self.assertEquals('<a><C/></a>', 2822 tostring(a).replace(' ', '')) 2823 self.assertEquals('<a><X/></a>', 2824 tostring(b).replace(' ', ''))

2825

2826 - def test_shallowcopy(self):

2827 Element = self.etree.Element 2828 2829 a = Element('a') 2830 a.text = 'Foo' 2831 2832 b = copy.copy(a) 2833 self.assertEquals('Foo', b.text) 2834 2835 b.text = 'Bar' 2836 self.assertEquals('Bar', b.text) 2837 self.assertEquals('Foo', a.text)

2838 # XXX ElementTree will share nodes, but lxml.etree won't.. 2839

2840 - def test_shallowcopy_elementtree(self):

2841 Element = self.etree.Element 2842 ElementTree = self.etree.ElementTree 2843 2844 a = Element('a') 2845 a.text = 'Foo' 2846 atree = ElementTree(a) 2847 2848 btree = copy.copy(atree) 2849 self.assertFalse(btree is atree) 2850 self.assert_(btree.getroot() is atree.getroot()) 2851 self.assertEquals('Foo', atree.getroot().text)

2852

2853 - def _test_element_boolean(self):

2854 # deprecated as of ET 1.3/lxml 2.0 2855 etree = self.etree 2856 e = etree.Element('foo') 2857 self.assertEquals(False, bool(e)) 2858 etree.SubElement(e, 'bar') 2859 self.assertEquals(True, bool(e)) 2860 e = etree.Element('foo') 2861 e.text = 'hey' 2862 self.assertEquals(False, bool(e)) 2863 e = etree.Element('foo') 2864 e.tail = 'bar' 2865 self.assertEquals(False, bool(e)) 2866 e = etree.Element('foo') 2867 e.set('bar', 'Bar') 2868 self.assertEquals(False, bool(e))

2869

2870 - def test_multiple_elementrees(self):

2871 etree = self.etree 2872 2873 a = etree.Element('a') 2874 b = etree.SubElement(a, 'b') 2875 2876 t = etree.ElementTree(a) 2877 self.assertEquals(self._rootstring(t), '<a></a>') 2878 2879 t1 = etree.ElementTree(a) 2880 self.assertEquals(self._rootstring(t1), '<a></a>') 2881 self.assertEquals(self._rootstring(t), '<a></a>') 2882 2883 t2 = etree.ElementTree(b) 2884 self.assertEquals(self._rootstring(t2), '') 2885 self.assertEquals(self._rootstring(t1), '<a></a>') 2886 self.assertEquals(self._rootstring(t), '<a></a>')

2887

2888 - def test_qname(self):

2889 etree = self.etree 2890 qname = etree.QName('myns', 'a') 2891 a1 = etree.Element(qname) 2892 a2 = etree.SubElement(a1, qname) 2893 self.assertEquals(a1.tag, "{myns}a") 2894 self.assertEquals(a2.tag, "{myns}a")

2895

2896 - def test_qname_cmp(self):

2897 etree = self.etree 2898 qname1 = etree.QName('myns', 'a') 2899 qname2 = etree.QName('myns', 'a') 2900 self.assertEquals(qname1, "{myns}a") 2901 self.assertEquals("{myns}a", qname2) 2902 self.assertEquals(qname1, qname1) 2903 self.assertEquals(qname1, qname2)

2904

2905 - def test_qname_attribute_getset(self):

2906 etree = self.etree 2907 qname = etree.QName('myns', 'a') 2908 2909 a = etree.Element(qname) 2910 a.set(qname, "value") 2911 2912 self.assertEquals(a.get(qname), "value") 2913 self.assertEquals(a.get("{myns}a"), "value")

2914

2915 - def test_qname_attrib(self):

2916 etree = self.etree 2917 qname = etree.QName('myns', 'a') 2918 2919 a = etree.Element(qname) 2920 a.attrib[qname] = "value" 2921 2922 self.assertEquals(a.attrib[qname], "value") 2923 self.assertEquals(a.attrib.get(qname), "value") 2924 2925 self.assertEquals(a.attrib["{myns}a"], "value") 2926 self.assertEquals(a.attrib.get("{myns}a"), "value")

2927

2928 - def test_qname_attribute_resolve(self):

2929 etree = self.etree 2930 qname = etree.QName('http://myns', 'a') 2931 a = etree.Element(qname) 2932 a.set(qname, qname) 2933 2934 self.assertXML( 2935 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2936 a)

2937

2938 - def test_qname_attribute_resolve_new(self):

2939 etree = self.etree 2940 qname = etree.QName('http://myns', 'a') 2941 a = etree.Element('a') 2942 a.set('a', qname) 2943 2944 self.assertXML( 2945 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 2946 a)

2947

2948 - def test_qname_attrib_resolve(self):

2949 etree = self.etree 2950 qname = etree.QName('http://myns', 'a') 2951 a = etree.Element(qname) 2952 a.attrib[qname] = qname 2953 2954 self.assertXML( 2955 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2956 a)

2957

2958 - def test_parser_version(self):

2959 etree = self.etree 2960 parser = etree.XMLParser() 2961 if hasattr(parser, "version"): 2962 # ElementTree 1.3+, cET 2963 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

2964 2965 # feed parser interface 2966

2967 - def test_feed_parser(self):

2968 parser = self.etree.XMLParser() 2969 2970 parser.feed('<?xml version=') 2971 parser.feed('"1.0"?><ro') 2972 parser.feed('ot><') 2973 parser.feed('a test="works"/') 2974 parser.feed('></root') 2975 parser.feed('>') 2976 2977 root = parser.close() 2978 2979 self.assertEquals(root.tag, "root") 2980 self.assertEquals(root[0].tag, "a") 2981 self.assertEquals(root[0].get("test"), "works")

2982

2983 - def test_feed_parser_error_close_empty(self):

2984 ParseError = self.etree.ParseError 2985 parser = self.etree.XMLParser() 2986 self.assertRaises(ParseError, parser.close)

2987

2988 - def test_feed_parser_error_close_incomplete(self):

2989 ParseError = self.etree.ParseError 2990 parser = self.etree.XMLParser() 2991 2992 parser.feed('<?xml version=') 2993 parser.feed('"1.0"?><ro') 2994 2995 self.assertRaises(ParseError, parser.close)

2996

2997 - def test_feed_parser_error_broken(self):

2998 ParseError = self.etree.ParseError 2999 parser = self.etree.XMLParser() 3000 3001 parser.feed('<?xml version=') 3002 parser.feed('"1.0"?><ro') 3003 try: 3004 parser.feed('<><><><><><><') 3005 except ParseError: 3006 # can raise, but not required before close() 3007 pass 3008 3009 self.assertRaises(ParseError, parser.close)

3010 3011 # parser target interface 3012

3013 - def test_parser_target_tag(self):

3014 assertEquals = self.assertEquals 3015 assertFalse = self.assertFalse 3016 3017 events = [] 3018 class Target(object): 3019 def start(self, tag, attrib): 3020 events.append("start") 3021 assertFalse(attrib) 3022 assertEquals("TAG", tag)

3023 def end(self, tag): 3024 events.append("end") 3025 assertEquals("TAG", tag) 3026 def close(self): 3027 return "DONE" 3028 3029 parser = self.etree.XMLParser(target=Target()) 3030 3031 parser.feed("<TAG/>") 3032 done = parser.close() 3033 3034 self.assertEquals("DONE", done) 3035 self.assertEquals(["start", "end"], events) 3036

3037 - def test_parser_target_attrib(self):

3038 assertEquals = self.assertEquals 3039 3040 events = [] 3041 class Target(object): 3042 def start(self, tag, attrib): 3043 events.append("start-" + tag) 3044 for name, value in attrib.iteritems(): 3045 assertEquals(tag + name, value)

3046 def end(self, tag): 3047 events.append("end-" + tag) 3048 def close(self): 3049 return "DONE" 3050 3051 parser = self.etree.XMLParser(target=Target()) 3052 3053 parser.feed('<root a="roota" b="rootb"></root>') 3054 done = parser.close() 3055 3056 self.assertEquals("DONE", done) 3057 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3058 events) 3059

3060 - def test_parser_target_data(self):

3061 events = [] 3062 class Target(object): 3063 def start(self, tag, attrib): 3064 events.append("start-" + tag)

3065 def end(self, tag): 3066 events.append("end-" + tag) 3067 def data(self, data): 3068 events.append("data-" + data) 3069 def close(self): 3070 return "DONE" 3071 3072 parser = self.etree.XMLParser(target=Target()) 3073 3074 parser.feed('<root>AB</root>') 3075 done = parser.close() 3076 3077 self.assertEquals("DONE", done) 3078 self.assertEquals(["start-root", "data-A", "start-sub", 3079 "end-sub", "data-B", "end-root"], 3080 events) 3081

3082 - def test_treebuilder(self):

3083 builder = self.etree.TreeBuilder() 3084 el = builder.start("root", {'a':'A', 'b':'B'}) 3085 self.assertEquals("root", el.tag) 3086 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3087 builder.data("ROOTTEXT") 3088 el = builder.start("child", {'x':'X', 'y':'Y'}) 3089 self.assertEquals("child", el.tag) 3090 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3091 builder.data("CHILDTEXT") 3092 el = builder.end("child") 3093 self.assertEquals("child", el.tag) 3094 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3095 self.assertEquals("CHILDTEXT", el.text) 3096 self.assertEquals(None, el.tail) 3097 builder.data("CHILDTAIL") 3098 root = builder.end("root") 3099 3100 self.assertEquals("root", root.tag) 3101 self.assertEquals("ROOTTEXT", root.text) 3102 self.assertEquals("CHILDTEXT", root[0].text) 3103 self.assertEquals("CHILDTAIL", root[0].tail)

3104

3105 - def test_treebuilder_target(self):

3106 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3107 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3108 root = parser.close() 3109 3110 self.assertEquals("root", root.tag) 3111 self.assertEquals("ROOTTEXT", root.text) 3112 self.assertEquals("CHILDTEXT", root[0].text) 3113 self.assertEquals("CHILDTAIL", root[0].tail)

3114 3115 # helper methods 3116

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

3118 """Write out element for comparison. 3119 """ 3120 data = self.etree.tostring(element, encoding=encoding) 3121 if encoding != 'us-ascii': 3122 data = unicode(data, encoding) 3123 return canonicalize(data)

3124

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

3126 """Write out element for comparison, using real file. 3127 """ 3128 ElementTree = self.etree.ElementTree 3129 handle, filename = tempfile.mkstemp() 3130 try: 3131 f = open(filename, 'wb') 3132 tree = ElementTree(element=element) 3133 tree.write(f, encoding=encoding) 3134 f.close() 3135 f = open(filename, 'rb') 3136 data = f.read() 3137 f.close() 3138 finally: 3139 os.close(handle) 3140 os.remove(filename) 3141 if encoding != 'us-ascii': 3142 data = unicode(data, encoding) 3143 return canonicalize(data)

3144

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

3146 """Writes element out and checks whether it is expected. 3147 3148 Does this two ways; once using StringIO, once using a real file. 3149 """ 3150 self.assertEquals(expected, self._writeElement(element, encoding)) 3151 self.assertEquals(expected, self._writeElementFile(element, encoding))

3152

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

3154 "Checks if the result XML byte string specifies the encoding." 3155 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 3156 self.assert_(has_encoding(result)) 3157 result_encoding = has_encoding(result).group(1) 3158 self.assertEquals(result_encoding.upper(), encoding.upper())

3159

3160 - def _rootstring(self, tree):

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

3162

3163 - def _check_element_tree(self, tree):

3164 self._check_element(tree.getroot())

3165

3166 - def _check_element(self, element):

3167 self.assert_(hasattr(element, 'tag')) 3168 self.assert_(hasattr(element, 'attrib')) 3169 self.assert_(hasattr(element, 'text')) 3170 self.assert_(hasattr(element, 'tail')) 3171 self._check_string(element.tag) 3172 self._check_mapping(element.attrib) 3173 if element.text != None: 3174 self._check_string(element.text) 3175 if element.tail != None: 3176 self._check_string(element.tail)

3177

3178 - def _check_string(self, string):

3179 len(string) 3180 for char in string: 3181 self.assertEquals(1, len(char)) 3182 new_string = string + "" 3183 new_string = string + " " 3184 string[:0]

3185

3186 - def _check_mapping(self, mapping):

3187 len(mapping) 3188 keys = mapping.keys() 3189 items = mapping.items() 3190 for key in keys: 3191 item = mapping[key] 3192 mapping["key"] = "value" 3193 self.assertEquals("value", mapping["key"])

3194 3195 # assertFalse doesn't exist in Python 2.3 3196 try: 3197 unittest.TestCase.assertFalse 3198 except AttributeError: 3199 assertFalse = unittest.TestCase.failIf 3200 3201 3202 if etree:

3203 - class ETreeTestCase(ETreeTestCaseBase):

3204 etree = etree

3205 3206 if ElementTree:

3207 - class ElementTreeTestCase(ETreeTestCaseBase):

3208 etree = ElementTree

3209 3210 if cElementTree:

3211 - class CElementTreeTestCase(ETreeTestCaseBase):

3212 etree = cElementTree

3213

3214 -def test_suite():

3215 suite = unittest.TestSuite() 3216 if etree: 3217 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3218 if ElementTree: 3219 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3220 if cElementTree: 3221 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3222 return suite

3223 3224 if __name__ == '__main__': 3225 print 'to test use test.py %s' % __file__ 3226