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, shutil, tempfile, copy, operator 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 setUp(self):

26 self._temp_dir = tempfile.mkdtemp()

27

28 - def tearDown(self):

29 shutil.rmtree(self._temp_dir)

30

31 - def getTestFilePath(self, name):

32 return os.path.join(self._temp_dir, name)

33

34 - def test_element(self):

35 for i in range(10): 36 e = self.etree.Element('foo')

37

38 - def test_tree(self):

39 Element = self.etree.Element 40 ElementTree = self.etree.ElementTree 41 42 element = Element('top') 43 tree = ElementTree(element) 44 self.buildNodes(element, 10, 3) 45 f = open(self.getTestFilePath('testdump.xml'), 'w') 46 tree.write(f, 'UTF-8') 47 f.close() 48 f = open(self.getTestFilePath('testdump.xml'), 'r') 49 tree = ElementTree(file=f) 50 f.close() 51 f = open(self.getTestFilePath('testdump2.xml'), 'w') 52 tree.write(f, 'UTF-8') 53 f.close() 54 f = open(self.getTestFilePath('testdump.xml'), 'r') 55 data1 = f.read() 56 f.close() 57 f = open(self.getTestFilePath('testdump2.xml'), 'r') 58 data2 = f.read() 59 f.close() 60 self.assertEquals(data1, data2)

61

62 - def buildNodes(self, element, children, depth):

63 Element = self.etree.Element 64 65 if depth == 0: 66 return 67 for i in range(children): 68 new_element = Element('element_%s_%s' % (depth, i)) 69 self.buildNodes(new_element, children, depth - 1) 70 element.append(new_element)

71

72 - def test_simple(self):

73 Element = self.etree.Element 74 75 root = Element('root') 76 root.append(Element('one')) 77 root.append(Element('two')) 78 root.append(Element('three')) 79 self.assertEquals(3, len(root)) 80 self.assertEquals('one', root[0].tag) 81 self.assertEquals('two', root[1].tag) 82 self.assertEquals('three', root[2].tag) 83 self.assertRaises(IndexError, operator.getitem, root, 3)

84

85 - def test_subelement(self):

86 Element = self.etree.Element 87 SubElement = self.etree.SubElement 88 89 root = Element('root') 90 SubElement(root, 'one') 91 SubElement(root, 'two') 92 SubElement(root, 'three') 93 self.assertEquals(3, len(root)) 94 self.assertEquals('one', root[0].tag) 95 self.assertEquals('two', root[1].tag) 96 self.assertEquals('three', root[2].tag)

97

98 - def test_element_contains(self):

99 Element = self.etree.Element 100 SubElement = self.etree.SubElement 101 102 root1 = Element('root') 103 SubElement(root1, 'one') 104 self.assert_(root1[0] in root1) 105 106 root2 = Element('root') 107 SubElement(root2, 'two') 108 SubElement(root2, 'three') 109 self.assert_(root2[0] in root2) 110 self.assert_(root2[1] in root2) 111 112 self.assertFalse(root1[0] in root2) 113 self.assertFalse(root2[0] in root1) 114 self.assertFalse(None in root2)

115

116 - def test_element_indexing_with_text(self):

117 ElementTree = self.etree.ElementTree 118 119 f = StringIO('<doc>Test<one>One</one></doc>') 120 doc = ElementTree(file=f) 121 root = doc.getroot() 122 self.assertEquals(1, len(root)) 123 self.assertEquals('one', root[0].tag) 124 self.assertRaises(IndexError, operator.getitem, root, 1)

125

126 - def test_element_indexing_with_text2(self):

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

136

137 - def test_element_indexing_only_text(self):

138 ElementTree = self.etree.ElementTree 139 140 f = StringIO('<doc>Test</doc>') 141 doc = ElementTree(file=f) 142 root = doc.getroot() 143 self.assertEquals(0, len(root))

144

145 - def test_element_indexing_negative(self):

146 Element = self.etree.Element 147 SubElement = self.etree.SubElement 148 a = Element('a') 149 b = SubElement(a, 'b') 150 c = SubElement(a, 'c') 151 d = SubElement(a, 'd') 152 self.assertEquals(d, a[-1]) 153 self.assertEquals(c, a[-2]) 154 self.assertEquals(b, a[-3]) 155 self.assertRaises(IndexError, operator.getitem, a, -4) 156 a[-1] = e = Element('e') 157 self.assertEquals(e, a[-1]) 158 del a[-1] 159 self.assertEquals(2, len(a))

160

161 - def test_elementtree(self):

162 ElementTree = self.etree.ElementTree 163 164 f = StringIO('<doc><one>One</one><two>Two</two></doc>') 165 doc = ElementTree(file=f) 166 root = doc.getroot() 167 self.assertEquals(2, len(root)) 168 self.assertEquals('one', root[0].tag) 169 self.assertEquals('two', root[1].tag)

170

171 - def test_text(self):

172 ElementTree = self.etree.ElementTree 173 174 f = StringIO('<doc>This is a text</doc>') 175 doc = ElementTree(file=f) 176 root = doc.getroot() 177 self.assertEquals('This is a text', root.text)

178

179 - def test_text_empty(self):

180 ElementTree = self.etree.ElementTree 181 182 f = StringIO('<doc></doc>') 183 doc = ElementTree(file=f) 184 root = doc.getroot() 185 self.assertEquals(None, root.text)

186

187 - def test_text_other(self):

188 ElementTree = self.etree.ElementTree 189 190 f = StringIO('<doc><one>One</one></doc>') 191 doc = ElementTree(file=f) 192 root = doc.getroot() 193 self.assertEquals(None, root.text) 194 self.assertEquals('One', root[0].text)

195

196 - def test_text_escape_in(self):

197 ElementTree = self.etree.ElementTree 198 199 f = StringIO('<doc>This is > than a text</doc>') 200 doc = ElementTree(file=f) 201 root = doc.getroot() 202 self.assertEquals('This is > than a text', root.text)

203

204 - def test_text_escape_out(self):

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

211

212 - def test_text_escape_tostring(self):

213 tostring = self.etree.tostring 214 Element = self.etree.Element 215 216 a = Element("a") 217 a.text = "<>&" 218 self.assertEquals('<a><>&</a>', 219 tostring(a))

220

221 - def test_text_str_subclass(self):

222 Element = self.etree.Element 223 224 class strTest(str): 225 pass

226 227 a = Element("a") 228 a.text = strTest("text") 229 self.assertXML('<a>text</a>', 230 a)

231

232 - def test_tail(self):

233 ElementTree = self.etree.ElementTree 234 235 f = StringIO('<doc>This is mixed content.</doc>') 236 doc = ElementTree(file=f) 237 root = doc.getroot() 238 self.assertEquals(1, len(root)) 239 self.assertEquals('This is ', root.text) 240 self.assertEquals(None, root.tail) 241 self.assertEquals('mixed', root[0].text) 242 self.assertEquals(' content.', root[0].tail)

243

244 - def test_tail_str_subclass(self):

245 Element = self.etree.Element 246 SubElement = self.etree.SubElement 247 248 class strTest(str): 249 pass

250 251 a = Element("a") 252 SubElement(a, "t").tail = strTest("tail") 253 self.assertXML('<a><t></t>tail</a>', 254 a) 255

256 - def test_ElementTree(self):

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

265

266 - def test_attributes(self):

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

275

276 - def test_attributes2(self):

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

286

287 - def test_attributes3(self):

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

297

298 - def test_attrib_clear(self):

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

307

308 - def test_attrib_set_clear(self):

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

318

319 - def test_attribute_update_dict(self):

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

336

337 - def test_attribute_update_sequence(self):

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

354

355 - def test_attribute_update_iter(self):

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

372

373 - def test_attribute_keys(self):

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

380

381 - def test_attribute_keys2(self):

382 XML = self.etree.XML 383 384 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 385 keys = root.keys() 386 keys.sort() 387 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

388

389 - def test_attribute_items2(self):

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

398

399 - def test_attribute_keys_ns(self):

400 XML = self.etree.XML 401 402 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 403 keys = root.keys() 404 keys.sort() 405 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 406 keys)

407

408 - def test_attribute_values(self):

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

415

416 - def test_attribute_values_ns(self):

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

424

425 - def test_attribute_items(self):

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

437

438 - def test_attribute_items_ns(self):

439 XML = self.etree.XML 440 441 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 442 items = root.attrib.items() 443 items.sort() 444 self.assertEquals( 445 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 446 items)

447

448 - def test_attribute_str(self):

449 XML = self.etree.XML 450 451 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 452 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 453 454 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 455 try: 456 self.assertEquals(expected, str(root.attrib)) 457 except AssertionError: 458 self.assertEquals(alternative, str(root.attrib))

459

460 - def test_attribute_has_key(self):

461 XML = self.etree.XML 462 463 root = XML('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />') 464 self.assertEquals( 465 True, root.attrib.has_key('bar')) 466 self.assertEquals( 467 False, root.attrib.has_key('baz')) 468 self.assertEquals( 469 False, root.attrib.has_key('hah')) 470 self.assertEquals( 471 True, 472 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))

473

474 - def test_attribute_contains(self):

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

487

488 - def test_attribute_set(self):

489 Element = self.etree.Element 490 491 root = Element("root") 492 root.set("attr", "TEST") 493 self.assertEquals("TEST", root.get("attr"))

494

495 - def test_XML(self):

496 XML = self.etree.XML 497 498 root = XML('<doc>This is a text.</doc>') 499 self.assertEquals(0, len(root)) 500 self.assertEquals('This is a text.', root.text)

501

502 - def test_XMLID(self):

503 XMLID = self.etree.XMLID 504 XML = self.etree.XML 505 xml_text = ''' 506 <document> 507 <h1 id="chapter1">...</h1> 508 ... 509 Regular paragraph. 510 XML:ID paragraph. 511 ... 512 </document> 513 ''' 514 515 root, dic = XMLID(xml_text) 516 root2 = XML(xml_text) 517 self.assertEquals(self._writeElement(root), 518 self._writeElement(root2)) 519 expected = { 520 "chapter1" : root[0], 521 "note1" : root[1], 522 "warn1" : root[4] 523 } 524 self.assertEquals(dic, expected)

525

526 - def test_fromstring(self):

527 fromstring = self.etree.fromstring 528 529 root = fromstring('<doc>This is a text.</doc>') 530 self.assertEquals(0, len(root)) 531 self.assertEquals('This is a text.', root.text)

532

533 - def test_fromstringlist(self):

534 fromstringlist = self.etree.fromstringlist 535 536 root = fromstringlist(["<do", "c>T", "hi", "s is", 537 " a text.<", "/doc", ">"]) 538 self.assertEquals(0, len(root)) 539 self.assertEquals('This is a text.', root.text)

540

541 - def test_fromstringlist_characters(self):

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

547

548 - def test_fromstringlist_single(self):

549 fromstringlist = self.etree.fromstringlist 550 551 root = fromstringlist(['<doc>This is a text.</doc>']) 552 self.assertEquals(0, len(root)) 553 self.assertEquals('This is a text.', root.text)

554

555 - def test_iselement(self):

556 iselement = self.etree.iselement 557 Element = self.etree.Element 558 ElementTree = self.etree.ElementTree 559 XML = self.etree.XML 560 Comment = self.etree.Comment 561 ProcessingInstruction = self.etree.ProcessingInstruction 562 563 el = Element('hoi') 564 self.assert_(iselement(el)) 565 566 el2 = XML('<foo/>') 567 self.assert_(iselement(el2)) 568 569 tree = ElementTree(element=Element('dag')) 570 self.assert_(not iselement(tree)) 571 self.assert_(iselement(tree.getroot())) 572 573 c = Comment('test') 574 self.assert_(iselement(c)) 575 576 p = ProcessingInstruction("test", "some text") 577 self.assert_(iselement(p))

578

579 - def test_iteration(self):

580 XML = self.etree.XML 581 582 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 583 result = [] 584 for el in root: 585 result.append(el.tag) 586 self.assertEquals(['one', 'two', 'three'], result)

587

588 - def test_iteration_empty(self):

589 XML = self.etree.XML 590 591 root = XML('<doc></doc>') 592 result = [] 593 for el in root: 594 result.append(el.tag) 595 self.assertEquals([], result)

596

597 - def test_iteration_text_only(self):

598 XML = self.etree.XML 599 600 root = XML('<doc>Text</doc>') 601 result = [] 602 for el in root: 603 result.append(el.tag) 604 self.assertEquals([], result)

605

606 - def test_iteration_crash(self):

607 # this would cause a crash in the past 608 fromstring = self.etree.fromstring 609 root = etree.fromstring('<html>x</html>') 610 for elem in root: 611 elem.tail = ''

612

613 - def test_iteration_reversed(self):

614 XML = self.etree.XML 615 616 try: 617 reversed(()) 618 except NameError: 619 # before Python 2.4 620 return 621 622 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 623 result = [] 624 for el in reversed(root): 625 result.append(el.tag) 626 self.assertEquals(['three', 'two', 'one'], result)

627

628 - def test_iteration_subelement(self):

629 XML = self.etree.XML 630 631 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 632 result = [] 633 add = True 634 for el in root: 635 result.append(el.tag) 636 if add: 637 self.etree.SubElement(root, 'four') 638 add = False 639 self.assertEquals(['one', 'two', 'three', 'four'], result)

640

641 - def test_iteration_del_child(self):

642 XML = self.etree.XML 643 644 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 645 result = [] 646 for el in root: 647 result.append(el.tag) 648 del root[-1] 649 self.assertEquals(['one', 'two'], result)

650

651 - def test_iteration_double(self):

652 XML = self.etree.XML 653 654 root = XML('<doc><one/><two/></doc>') 655 result = [] 656 for el0 in root: 657 result.append(el0.tag) 658 for el1 in root: 659 result.append(el1.tag) 660 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

661

662 - def test_attribute_iterator(self):

663 XML = self.etree.XML 664 665 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />') 666 result = [] 667 for key in root.attrib: 668 result.append(key) 669 result.sort() 670 self.assertEquals(['alpha', 'beta', 'gamma'], result)

671

672 - def test_findall(self):

673 XML = self.etree.XML 674 root = XML('<a><c/><c></c></a>') 675 self.assertEquals(len(list(root.findall("c"))), 1) 676 self.assertEquals(len(list(root.findall(".//c"))), 2) 677 self.assertEquals(len(list(root.findall(".//b"))), 3) 678 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 679 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 680 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

681

682 - def test_findall_ns(self):

683 XML = self.etree.XML 684 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 685 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 686 self.assertEquals(len(list(root.findall(".//b"))), 3) 687 self.assertEquals(len(list(root.findall("b"))), 2)

688

689 - def test_element_with_attributes_keywords(self):

690 Element = self.etree.Element 691 692 el = Element('tag', foo='Foo', bar='Bar') 693 self.assertEquals('Foo', el.attrib['foo']) 694 self.assertEquals('Bar', el.attrib['bar'])

695

696 - def test_element_with_attributes(self):

697 Element = self.etree.Element 698 699 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 700 self.assertEquals('Foo', el.attrib['foo']) 701 self.assertEquals('Bar', el.attrib['bar'])

702

703 - def test_element_with_attributes_ns(self):

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

709

710 - def test_subelement_with_attributes(self):

711 Element = self.etree.Element 712 SubElement = self.etree.SubElement 713 714 el = Element('tag') 715 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 716 self.assertEquals("Baz", el[0].attrib['baz']) 717 self.assertEquals('Foo', el[0].attrib['foo'])

718

719 - def test_subelement_with_attributes_ns(self):

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

727

728 - def test_write(self):

729 ElementTree = self.etree.ElementTree 730 XML = self.etree.XML 731 732 for i in range(10): 733 f = StringIO() 734 root = XML('<doc%s>This is a test.</doc%s>' % (i, i)) 735 tree = ElementTree(element=root) 736 tree.write(f) 737 data = f.getvalue() 738 self.assertEquals( 739 '<doc%s>This is a test.</doc%s>' % (i, i), 740 canonicalize(data))

741

742 - def test_write_method_html(self):

743 ElementTree = self.etree.ElementTree 744 Element = self.etree.Element 745 SubElement = self.etree.SubElement 746 747 html = Element('html') 748 body = SubElement(html, 'body') 749 p = SubElement(body, 'p') 750 p.text = "html" 751 SubElement(p, 'br').tail = "test" 752 753 tree = ElementTree(element=html) 754 f = StringIO() 755 tree.write(f, method="html") 756 data = f.getvalue() 757 758 self.assertEquals('<html><body>html test</body></html>', 759 data)

760

761 - def test_write_method_text(self):

762 ElementTree = self.etree.ElementTree 763 Element = self.etree.Element 764 SubElement = self.etree.SubElement 765 766 a = Element('a') 767 a.text = "A" 768 a.tail = "tail" 769 b = SubElement(a, 'b') 770 b.text = "B" 771 b.tail = "TAIL" 772 c = SubElement(a, 'c') 773 c.text = "C" 774 775 tree = ElementTree(element=a) 776 f = StringIO() 777 tree.write(f, method="text") 778 data = f.getvalue() 779 780 self.assertEquals('ABTAILCtail', 781 data)

782

783 - def test_write_fail(self):

784 ElementTree = self.etree.ElementTree 785 XML = self.etree.XML 786 787 tree = ElementTree( XML('<doc>This is a test.</doc>') ) 788 self.assertRaises(IOError, tree.write, 789 "definitely////\\-\\nonexisting\\-\\////FILE")

790 791 # this could trigger a crash, apparently because the document 792 # reference was prematurely garbage collected

793 - def test_crash(self):

794 Element = self.etree.Element 795 796 element = Element('tag') 797 for i in range(10): 798 element.attrib['key'] = 'value' 799 value = element.attrib['key'] 800 self.assertEquals(value, 'value')

801 802 # from doctest; for some reason this caused crashes too

803 - def test_write_ElementTreeDoctest(self):

804 Element = self.etree.Element 805 ElementTree = self.etree.ElementTree 806 807 f = StringIO() 808 for i in range(10): 809 element = Element('tag%s' % i) 810 self._check_element(element) 811 tree = ElementTree(element) 812 tree.write(f) 813 self._check_element_tree(tree)

814

815 - def test_subelement_reference(self):

816 Element = self.etree.Element 817 SubElement = self.etree.SubElement 818 819 el = Element('foo') 820 el2 = SubElement(el, 'bar') 821 el3 = SubElement(el2, 'baz') 822 823 al = Element('foo2') 824 al2 = SubElement(al, 'bar2') 825 al3 = SubElement(al2, 'baz2') 826 827 # now move al2 into el 828 el.append(al2) 829 830 # now change al3 directly 831 al3.text = 'baz2-modified' 832 833 # it should have changed through this route too 834 self.assertEquals( 835 'baz2-modified', 836 el[1][0].text)

837

838 - def test_set_text(self):

839 Element = self.etree.Element 840 SubElement = self.etree.SubElement 841 842 a = Element('a') 843 b = SubElement(a, 'b') 844 a.text = 'hoi' 845 self.assertEquals( 846 'hoi', 847 a.text) 848 self.assertEquals( 849 'b', 850 a[0].tag)

851

852 - def test_set_text2(self):

853 Element = self.etree.Element 854 SubElement = self.etree.SubElement 855 856 a = Element('a') 857 a.text = 'hoi' 858 b = SubElement(a ,'b') 859 self.assertEquals( 860 'hoi', 861 a.text) 862 self.assertEquals( 863 'b', 864 a[0].tag)

865

866 - def test_set_text_none(self):

867 Element = self.etree.Element 868 869 a = Element('a') 870 871 a.text = 'foo' 872 a.text = None 873 874 self.assertEquals( 875 None, 876 a.text) 877 self.assertXML('<a></a>', a)

878

879 - def test_set_text_empty(self):

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

888

889 - def test_tail1(self):

890 Element = self.etree.Element 891 SubElement = self.etree.SubElement 892 893 a = Element('a') 894 a.tail = 'dag' 895 self.assertEquals('dag', 896 a.tail) 897 b = SubElement(a, 'b') 898 b.tail = 'hoi' 899 self.assertEquals('hoi', 900 b.tail) 901 self.assertEquals('dag', 902 a.tail)

903

904 - def test_tail_append(self):

905 Element = self.etree.Element 906 907 a = Element('a') 908 b = Element('b') 909 b.tail = 'b_tail' 910 a.append(b) 911 self.assertEquals('b_tail', 912 b.tail)

913

914 - def test_tail_set_twice(self):

915 Element = self.etree.Element 916 SubElement = self.etree.SubElement 917 918 a = Element('a') 919 b = SubElement(a, 'b') 920 b.tail = 'foo' 921 b.tail = 'bar' 922 self.assertEquals('bar', 923 b.tail) 924 self.assertXML('<a>bar</a>', a)

925

926 - def test_tail_set_none(self):

927 Element = self.etree.Element 928 a = Element('a') 929 a.tail = 'foo' 930 a.tail = None 931 self.assertEquals( 932 None, 933 a.tail) 934 self.assertXML('<a></a>', a)

935

936 - def test_comment(self):

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

945

946 - def test_comment_text(self):

947 Element = self.etree.Element 948 SubElement = self.etree.SubElement 949 Comment = self.etree.Comment 950 951 a = Element('a') 952 a.append(Comment('foo')) 953 self.assertEquals(a[0].text, 'foo') 954 955 a[0].text = "TEST" 956 self.assertEquals(a[0].text, 'TEST')

957

958 - def test_comment_whitespace(self):

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

966

967 - def test_comment_nonsense(self):

968 Comment = self.etree.Comment 969 c = Comment('foo') 970 self.assertEquals({}, c.attrib) 971 self.assertEquals([], c.keys()) 972 self.assertEquals([], c.items()) 973 self.assertEquals(None, c.get('hoi')) 974 self.assertEquals(0, len(c)) 975 # should not iterate 976 for i in c: 977 pass

978

979 - def test_pi(self):

980 # lxml.etree separates target and text 981 Element = self.etree.Element 982 SubElement = self.etree.SubElement 983 ProcessingInstruction = self.etree.ProcessingInstruction 984 985 a = Element('a') 986 a.append(ProcessingInstruction('foo', 'some more text')) 987 self.assertEquals(a[0].tag, ProcessingInstruction) 988 self.assertXML("<a><?foo some more text?></a>", 989 a)

990

991 - def test_processinginstruction(self):

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

1002

1003 - def test_pi_nonsense(self):

1004 ProcessingInstruction = self.etree.ProcessingInstruction 1005 pi = ProcessingInstruction('foo') 1006 self.assertEquals({}, pi.attrib) 1007 self.assertEquals([], pi.keys()) 1008 self.assertEquals([], pi.items()) 1009 self.assertEquals(None, pi.get('hoi')) 1010 self.assertEquals(0, len(pi)) 1011 # should not iterate 1012 for i in pi: 1013 pass

1014

1015 - def test_setitem(self):

1016 Element = self.etree.Element 1017 SubElement = self.etree.SubElement 1018 1019 a = Element('a') 1020 b = SubElement(a, 'b') 1021 c = Element('c') 1022 a[0] = c 1023 self.assertEquals( 1024 c, 1025 a[0]) 1026 self.assertXML('<a><c></c></a>', 1027 a) 1028 self.assertXML('', 1029 b)

1030

1031 - def test_setitem2(self):

1032 Element = self.etree.Element 1033 SubElement = self.etree.SubElement 1034 1035 a = Element('a') 1036 for i in range(5): 1037 b = SubElement(a, 'b%s' % i) 1038 c = SubElement(b, 'c') 1039 for i in range(5): 1040 d = Element('d') 1041 e = SubElement(d, 'e') 1042 a[i] = d 1043 self.assertXML( 1044 '<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>', 1045 a) 1046 self.assertXML('<c></c>', 1047 c)

1048

1049 - def test_setitem_replace(self):

1050 Element = self.etree.Element 1051 SubElement = self.etree.SubElement 1052 1053 a = Element('a') 1054 SubElement(a, 'b') 1055 d = Element('d') 1056 a[0] = d 1057 self.assertXML('<a><d></d></a>', a)

1058

1059 - def test_setitem_indexerror(self):

1060 Element = self.etree.Element 1061 SubElement = self.etree.SubElement 1062 1063 a = Element('a') 1064 b = SubElement(a, 'b') 1065 1066 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1067

1068 - def test_setitem_tail(self):

1069 Element = self.etree.Element 1070 SubElement = self.etree.SubElement 1071 1072 a = Element('a') 1073 b = SubElement(a, 'b') 1074 b.tail = 'B2' 1075 c = Element('c') 1076 c.tail = 'C2' 1077 1078 a[0] = c 1079 self.assertXML( 1080 '<a><c></c>C2</a>', 1081 a)

1082

1083 - def test_tag_write(self):

1084 Element = self.etree.Element 1085 SubElement = self.etree.SubElement 1086 1087 a = Element('a') 1088 b = SubElement(a, 'b') 1089 1090 a.tag = 'c' 1091 1092 self.assertEquals( 1093 'c', 1094 a.tag) 1095 1096 self.assertXML( 1097 '<c></c>', 1098 a)

1099

1100 - def test_tag_reset_ns(self):

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

1117

1118 - def test_tag_reset_root_ns(self):

1119 Element = self.etree.Element 1120 SubElement = self.etree.SubElement 1121 tostring = self.etree.tostring 1122 1123 a = Element('{a}a') 1124 b1 = SubElement(a, '{a}b') 1125 b2 = SubElement(a, '{b}b') 1126 1127 a.tag = 'c' 1128 1129 self.assertEquals( 1130 'c', 1131 a.tag) 1132 1133 # can't use C14N here! 1134 self.assertEquals('c', a.tag) 1135 self.assertEquals('<c', tostring(a)[:2])

1136

1137 - def test_tag_str_subclass(self):

1138 Element = self.etree.Element 1139 1140 class strTest(str): 1141 pass

1142 1143 a = Element("a") 1144 a.tag = strTest("TAG") 1145 self.assertXML('<TAG></TAG>', 1146 a) 1147

1148 - def test_delitem(self):

1149 Element = self.etree.Element 1150 SubElement = self.etree.SubElement 1151 1152 a = Element('a') 1153 b = SubElement(a, 'b') 1154 c = SubElement(a, 'c') 1155 d = SubElement(a, 'd') 1156 1157 del a[1] 1158 self.assertXML( 1159 '<a><d></d></a>', 1160 a) 1161 1162 del a[0] 1163 self.assertXML( 1164 '<a><d></d></a>', 1165 a) 1166 1167 del a[0] 1168 self.assertXML( 1169 '<a></a>', 1170 a) 1171 # move deleted element into other tree afterwards 1172 other = Element('other') 1173 other.append(c) 1174 self.assertXML( 1175 '<other><c></c></other>', 1176 other)

1177

1178 - def test_del_insert(self):

1179 Element = self.etree.Element 1180 SubElement = self.etree.SubElement 1181 1182 a = Element('a') 1183 b = SubElement(a, 'b') 1184 bs = SubElement(b, 'bs') 1185 c = SubElement(a, 'c') 1186 cs = SubElement(c, 'cs') 1187 1188 el = a[0] 1189 self.assertXML( 1190 '<a><bs></bs><c><cs></cs></c></a>', 1191 a) 1192 self.assertXML('<bs></bs>', b) 1193 self.assertXML('<c><cs></cs></c>', c) 1194 1195 del a[0] 1196 self.assertXML( 1197 '<a><c><cs></cs></c></a>', 1198 a) 1199 self.assertXML('<bs></bs>', b) 1200 self.assertXML('<c><cs></cs></c>', c) 1201 1202 a.insert(0, el) 1203 self.assertXML( 1204 '<a><bs></bs><c><cs></cs></c></a>', 1205 a) 1206 self.assertXML('<bs></bs>', b) 1207 self.assertXML('<c><cs></cs></c>', c)

1208

1209 - def test_del_setitem(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] = el 1222 self.assertXML( 1223 '<a><bs></bs></a>', 1224 a) 1225 self.assertXML('<bs></bs>', b) 1226 self.assertXML('<c><cs></cs></c>', c)

1227

1228 - def test_del_setslice(self):

1229 Element = self.etree.Element 1230 SubElement = self.etree.SubElement 1231 1232 a = Element('a') 1233 b = SubElement(a, 'b') 1234 bs = SubElement(b, 'bs') 1235 c = SubElement(a, 'c') 1236 cs = SubElement(c, 'cs') 1237 1238 el = a[0] 1239 del a[0] 1240 a[0:0] = [el] 1241 self.assertXML( 1242 '<a><bs></bs><c><cs></cs></c></a>', 1243 a) 1244 self.assertXML('<bs></bs>', b) 1245 self.assertXML('<c><cs></cs></c>', c)

1246

1247 - def test_delslice_tail(self):

1248 XML = self.etree.XML 1249 a = XML('<a>B2<c></c>C2</a>') 1250 b, c = a 1251 1252 del a[:] 1253 1254 self.assertEquals("B2", b.tail) 1255 self.assertEquals("C2", c.tail)

1256

1257 - def test_replace_slice_tail(self):

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

1266

1267 - def test_delitem_tail(self):

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

1276

1277 - def test_clear(self):

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

1289

1290 - def test_clear_sub(self):

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

1310

1311 - def test_clear_tail(self):

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

1320

1321 - def test_insert(self):

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

1347

1348 - def test_insert_beyond_index(self):

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

1363

1364 - def test_insert_negative(self):

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

1380

1381 - def test_insert_tail(self):

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

1395

1396 - def test_remove(self):

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

1411

1412 - def test_remove_ns(self):

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

1427

1428 - def test_remove_nonexisting(self):

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

1438

1439 - def test_remove_tail(self):

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

1451

1452 - def _test_getchildren(self):

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

1473

1474 - def test_makeelement(self):

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

1482

1483 - def test_getiterator(self):

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

1499

1500 - def test_getiterator_empty(self):

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

1519

1520 - def test_getiterator_filter(self):

1521 Element = self.etree.Element 1522 SubElement = self.etree.SubElement 1523 1524 a = Element('a') 1525 b = SubElement(a, 'b') 1526 c = SubElement(a, 'c') 1527 d = SubElement(b, 'd') 1528 e = SubElement(c, 'e') 1529 1530 self.assertEquals( 1531 [a], 1532 list(a.getiterator('a'))) 1533 a2 = SubElement(e, 'a') 1534 self.assertEquals( 1535 [a, a2], 1536 list(a.getiterator('a'))) 1537 self.assertEquals( 1538 [a2], 1539 list(c.getiterator('a')))

1540

1541 - def test_getiterator_filter_all(self):

1542 Element = self.etree.Element 1543 SubElement = self.etree.SubElement 1544 1545 a = Element('a') 1546 b = SubElement(a, 'b') 1547 c = SubElement(a, 'c') 1548 d = SubElement(b, 'd') 1549 e = SubElement(c, 'e') 1550 1551 self.assertEquals( 1552 [a, b, d, c, e], 1553 list(a.getiterator('*')))

1554

1555 - def test_getiterator_filter_comment(self):

1556 Element = self.etree.Element 1557 Comment = self.etree.Comment 1558 SubElement = self.etree.SubElement 1559 1560 a = Element('a') 1561 b = SubElement(a, 'b') 1562 comment_b = Comment("TEST-b") 1563 b.append(comment_b) 1564 1565 self.assertEquals( 1566 [comment_b], 1567 list(a.getiterator(Comment))) 1568 1569 comment_a = Comment("TEST-a") 1570 a.append(comment_a) 1571 1572 self.assertEquals( 1573 [comment_b, comment_a], 1574 list(a.getiterator(Comment))) 1575 1576 self.assertEquals( 1577 [comment_b], 1578 list(b.getiterator(Comment)))

1579

1580 - def test_getiterator_filter_pi(self):

1581 Element = self.etree.Element 1582 PI = self.etree.ProcessingInstruction 1583 SubElement = self.etree.SubElement 1584 1585 a = Element('a') 1586 b = SubElement(a, 'b') 1587 pi_b = PI("TEST-b") 1588 b.append(pi_b) 1589 1590 self.assertEquals( 1591 [pi_b], 1592 list(a.getiterator(PI))) 1593 1594 pi_a = PI("TEST-a") 1595 a.append(pi_a) 1596 1597 self.assertEquals( 1598 [pi_b, pi_a], 1599 list(a.getiterator(PI))) 1600 1601 self.assertEquals( 1602 [pi_b], 1603 list(b.getiterator(PI)))

1604

1605 - def test_getiterator_with_text(self):

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

1627 #self.assertEquals( 1628 # [d], 1629 # list(d.getiterator())) 1630

1631 - def test_getiterator_filter_with_text(self):

1632 Element = self.etree.Element 1633 SubElement = self.etree.SubElement 1634 1635 a = Element('a') 1636 a.text = 'a' 1637 b = SubElement(a, 'b') 1638 b.text = 'b' 1639 b.tail = 'b1' 1640 c = SubElement(a, 'c') 1641 c.text = 'c' 1642 c.tail = 'c1' 1643 d = SubElement(b, 'd') 1644 c.text = 'd' 1645 c.tail = 'd1' 1646 e = SubElement(c, 'e') 1647 e.text = 'e' 1648 e.tail = 'e1' 1649 1650 self.assertEquals( 1651 [a], 1652 list(a.getiterator('a'))) 1653 a2 = SubElement(e, 'a') 1654 self.assertEquals( 1655 [a, a2], 1656 list(a.getiterator('a'))) 1657 self.assertEquals( 1658 [a2], 1659 list(e.getiterator('a')))

1660

1661 - def test_attribute_manipulation(self):

1662 Element = self.etree.Element 1663 1664 a = Element('a') 1665 a.attrib['foo'] = 'Foo' 1666 a.attrib['bar'] = 'Bar' 1667 self.assertEquals('Foo', a.attrib['foo']) 1668 del a.attrib['foo'] 1669 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

1670

1671 - def test_getslice(self):

1672 Element = self.etree.Element 1673 SubElement = self.etree.SubElement 1674 1675 a = Element('a') 1676 b = SubElement(a, 'b') 1677 c = SubElement(a, 'c') 1678 d = SubElement(a, 'd') 1679 1680 self.assertEquals( 1681 [b, c], 1682 a[0:2]) 1683 self.assertEquals( 1684 [b, c, d], 1685 a[:]) 1686 self.assertEquals( 1687 [b, c, d], 1688 a[:10]) 1689 self.assertEquals( 1690 [b], 1691 a[0:1]) 1692 self.assertEquals( 1693 [], 1694 a[10:12])

1695

1696 - def test_getslice_negative(self):

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

1720

1721 - def test_getslice_text(self):

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

1738

1739 - def test_comment_getitem_getslice(self):

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

1762

1763 - def test_delslice(self):

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

1777

1778 - def test_delslice_negative1(self):

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

1792

1793 - def test_delslice_negative2(self):

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

1807

1808 - def test_delslice_tail(self):

1809 ElementTree = self.etree.ElementTree 1810 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1811 doc = ElementTree(file=f) 1812 a = doc.getroot() 1813 del a[1:3] 1814 self.assertXML( 1815 '<a>B2<e></e>E2</a>', 1816 a)

1817

1818 - def test_delslice_memory(self):

1819 # this could trigger a crash 1820 Element = self.etree.Element 1821 SubElement = self.etree.SubElement 1822 a = Element('a') 1823 b = SubElement(a, 'b') 1824 c = SubElement(b, 'c') 1825 del b # no more reference to b 1826 del a[:] 1827 self.assertEquals('c', c.tag)

1828

1829 - def test_setslice(self):

1830 Element = self.etree.Element 1831 SubElement = self.etree.SubElement 1832 1833 a = Element('a') 1834 b = SubElement(a, 'b') 1835 c = SubElement(a, 'c') 1836 d = SubElement(a, 'd') 1837 1838 e = Element('e') 1839 f = Element('f') 1840 g = Element('g') 1841 1842 s = [e, f, g] 1843 a[1:2] = s 1844 self.assertEquals( 1845 [b, e, f, g, d], 1846 list(a))

1847

1848 - def test_setslice_tail(self):

1849 ElementTree = self.etree.ElementTree 1850 Element = self.etree.Element 1851 f = StringIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 1852 doc = ElementTree(file=f) 1853 a = doc.getroot() 1854 x = Element('x') 1855 y = Element('y') 1856 z = Element('z') 1857 x.tail = 'X2' 1858 y.tail = 'Y2' 1859 z.tail = 'Z2' 1860 a[1:3] = [x, y, z] 1861 self.assertXML( 1862 '<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>', 1863 a)

1864

1865 - def test_setslice_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 1874 x = Element('x') 1875 y = Element('y') 1876 1877 a[1:-1] = [x, y] 1878 self.assertEquals( 1879 [b, x, y, d], 1880 list(a))

1881

1882 - def test_setslice_end(self):

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

1900

1901 - def test_setslice_empty(self):

1902 Element = self.etree.Element 1903 1904 a = Element('a') 1905 1906 b = Element('b') 1907 c = Element('c') 1908 1909 a[:] = [b, c] 1910 self.assertEquals( 1911 [b, c], 1912 list(a))

1913

1914 - def test_tail_elementtree_root(self):

1915 Element = self.etree.Element 1916 ElementTree = self.etree.ElementTree 1917 1918 a = Element('a') 1919 a.tail = 'A2' 1920 t = ElementTree(element=a) 1921 self.assertEquals('A2', 1922 a.tail)

1923

1924 - def test_elementtree_getiterator(self):

1925 Element = self.etree.Element 1926 SubElement = self.etree.SubElement 1927 ElementTree = self.etree.ElementTree 1928 1929 a = Element('a') 1930 b = SubElement(a, 'b') 1931 c = SubElement(a, 'c') 1932 d = SubElement(b, 'd') 1933 e = SubElement(c, 'e') 1934 t = ElementTree(element=a) 1935 1936 self.assertEquals( 1937 [a, b, d, c, e], 1938 list(t.getiterator()))

1939

1940 - def test_elementtree_getiterator_filter(self):

1941 Element = self.etree.Element 1942 SubElement = self.etree.SubElement 1943 ElementTree = self.etree.ElementTree 1944 a = Element('a') 1945 b = SubElement(a, 'b') 1946 c = SubElement(a, 'c') 1947 d = SubElement(b, 'd') 1948 e = SubElement(c, 'e') 1949 t = ElementTree(element=a) 1950 1951 self.assertEquals( 1952 [a], 1953 list(t.getiterator('a'))) 1954 a2 = SubElement(e, 'a') 1955 self.assertEquals( 1956 [a, a2], 1957 list(t.getiterator('a')))

1958

1959 - def test_ns_access(self):

1960 ElementTree = self.etree.ElementTree 1961 ns = 'http://xml.infrae.com/1' 1962 f = StringIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 1963 t = ElementTree(file=f) 1964 a = t.getroot() 1965 self.assertEquals('{%s}a' % ns, 1966 a.tag) 1967 self.assertEquals('{%s}b' % ns, 1968 a[0].tag)

1969

1970 - def test_ns_access2(self):

1971 ElementTree = self.etree.ElementTree 1972 ns = 'http://xml.infrae.com/1' 1973 ns2 = 'http://xml.infrae.com/2' 1974 f = StringIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 1975 t = ElementTree(file=f) 1976 a = t.getroot() 1977 self.assertEquals('{%s}a' % ns, 1978 a.tag) 1979 self.assertEquals('{%s}b' % ns, 1980 a[0].tag) 1981 self.assertEquals('{%s}b' % ns2, 1982 a[1].tag)

1983

1984 - def test_ns_setting(self):

1985 Element = self.etree.Element 1986 SubElement = self.etree.SubElement 1987 ns = 'http://xml.infrae.com/1' 1988 ns2 = 'http://xml.infrae.com/2' 1989 a = Element('{%s}a' % ns) 1990 b = SubElement(a, '{%s}b' % ns2) 1991 c = SubElement(a, '{%s}c' % ns) 1992 self.assertEquals('{%s}a' % ns, 1993 a.tag) 1994 self.assertEquals('{%s}b' % ns2, 1995 b.tag) 1996 self.assertEquals('{%s}c' % ns, 1997 c.tag) 1998 self.assertEquals('{%s}a' % ns, 1999 a.tag) 2000 self.assertEquals('{%s}b' % ns2, 2001 b.tag) 2002 self.assertEquals('{%s}c' % ns, 2003 c.tag)

2004

2005 - def test_ns_tag_parse(self):

2006 Element = self.etree.Element 2007 SubElement = self.etree.SubElement 2008 ElementTree = self.etree.ElementTree 2009 2010 ns = 'http://xml.infrae.com/1' 2011 ns2 = 'http://xml.infrae.com/2' 2012 f = StringIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2013 t = ElementTree(file=f) 2014 2015 a = t.getroot() 2016 self.assertEquals('{%s}a' % ns, 2017 a.tag) 2018 self.assertEquals('{%s}b' % ns2, 2019 a[0].tag) 2020 self.assertEquals('{%s}b' % ns, 2021 a[1].tag)

2022

2023 - def test_ns_attr(self):

2024 Element = self.etree.Element 2025 ns = 'http://xml.infrae.com/1' 2026 ns2 = 'http://xml.infrae.com/2' 2027 a = Element('a') 2028 a.set('{%s}foo' % ns, 'Foo') 2029 a.set('{%s}bar' % ns2, 'Bar') 2030 self.assertEquals( 2031 'Foo', 2032 a.get('{%s}foo' % ns)) 2033 self.assertEquals( 2034 'Bar', 2035 a.get('{%s}bar' % ns2)) 2036 try: 2037 self.assertXML( 2038 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2), 2039 a) 2040 except AssertionError: 2041 self.assertXML( 2042 '<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns), 2043 a)

2044

2045 - def test_ns_move(self):

2046 Element = self.etree.Element 2047 ElementTree = self.etree.ElementTree 2048 2049 one = self.etree.parse( 2050 StringIO('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2051 baz = one.getroot()[0][0] 2052 2053 two = ElementTree(Element('root')) 2054 two.getroot().append(baz) 2055 # removing the originating document could cause a crash/error before 2056 # as namespace is not moved along with it 2057 del one 2058 self.assertEquals('{http://a.b.c}baz', baz.tag)

2059

2060 - def test_ns_decl_tostring(self):

2061 tostring = self.etree.tostring 2062 root = self.etree.XML( 2063 '<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>') 2064 baz = root[0][0] 2065 2066 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2067 tostring(baz)) 2068 self.assertEquals(["http://a.b.c"], nsdecl)

2069

2070 - def test_ns_decl_tostring_default(self):

2071 tostring = self.etree.tostring 2072 root = self.etree.XML( 2073 '<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>') 2074 baz = root[0][0] 2075 2076 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2077 tostring(baz)) 2078 self.assertEquals(["http://a.b.c"], nsdecl)

2079

2080 - def test_ns_decl_tostring_root(self):

2081 tostring = self.etree.tostring 2082 root = self.etree.XML( 2083 '<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>') 2084 baz = root[0][0] 2085 2086 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2087 tostring(baz)) 2088 2089 self.assertEquals(["http://a.b.c"], nsdecl)

2090

2091 - def test_ns_decl_tostring_element(self):

2092 Element = self.etree.Element 2093 SubElement = self.etree.SubElement 2094 2095 root = Element("foo") 2096 bar = SubElement(root, "{http://a.b.c}bar") 2097 baz = SubElement(bar, "{http://a.b.c}baz") 2098 2099 nsdecl = re.findall("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']", 2100 self.etree.tostring(baz)) 2101 2102 self.assertEquals(["http://a.b.c"], nsdecl)

2103

2104 - def test_attribute_xmlns_move(self):

2105 Element = self.etree.Element 2106 2107 root = Element('element') 2108 2109 subelement = Element('subelement', 2110 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2111 self.assertEquals(1, len(subelement.attrib)) 2112 self.assertEquals( 2113 "foo", 2114 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2115 2116 root.append(subelement) 2117 self.assertEquals(1, len(subelement.attrib)) 2118 self.assertEquals( 2119 {"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items(), 2120 subelement.attrib.items()) 2121 self.assertEquals( 2122 "foo", 2123 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2124

2125 - def test_tostring(self):

2126 tostring = self.etree.tostring 2127 Element = self.etree.Element 2128 SubElement = self.etree.SubElement 2129 2130 a = Element('a') 2131 b = SubElement(a, 'b') 2132 c = SubElement(a, 'c') 2133 2134 self.assertEquals('<a><c></c></a>', 2135 canonicalize(tostring(a)))

2136

2137 - def test_tostring_element(self):

2138 tostring = self.etree.tostring 2139 Element = self.etree.Element 2140 SubElement = self.etree.SubElement 2141 2142 a = Element('a') 2143 b = SubElement(a, 'b') 2144 c = SubElement(a, 'c') 2145 d = SubElement(c, 'd') 2146 self.assertEquals('', 2147 canonicalize(tostring(b))) 2148 self.assertEquals('<c><d></d></c>', 2149 canonicalize(tostring(c)))

2150

2151 - def test_tostring_element_tail(self):

2152 tostring = self.etree.tostring 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(c, 'd') 2160 b.tail = 'Foo' 2161 2162 self.assert_(tostring(b) == 'Foo' or 2163 tostring(b) == 'Foo')

2164

2165 - def test_tostring_method_html(self):

2166 tostring = self.etree.tostring 2167 Element = self.etree.Element 2168 SubElement = self.etree.SubElement 2169 2170 html = Element('html') 2171 body = SubElement(html, 'body') 2172 p = SubElement(body, 'p') 2173 p.text = "html" 2174 SubElement(p, 'br').tail = "test" 2175 2176 self.assertEquals('<html><body>html test</body></html>', 2177 tostring(html, method="html"))

2178

2179 - def test_tostring_method_text(self):

2180 tostring = self.etree.tostring 2181 Element = self.etree.Element 2182 SubElement = self.etree.SubElement 2183 2184 a = Element('a') 2185 a.text = "A" 2186 a.tail = "tail" 2187 b = SubElement(a, 'b') 2188 b.text = "B" 2189 b.tail = "TAIL" 2190 c = SubElement(a, 'c') 2191 c.text = "C" 2192 2193 self.assertEquals('ABTAILCtail', 2194 tostring(a, method="text"))

2195

2196 - def test_iterparse(self):

2197 iterparse = self.etree.iterparse 2198 f = StringIO('<a><c/></a>') 2199 2200 iterator = iterparse(f) 2201 self.assertEquals(None, 2202 iterator.root) 2203 events = list(iterator) 2204 root = iterator.root 2205 self.assertEquals( 2206 [('end', root[0]), ('end', root[1]), ('end', root)], 2207 events)

2208

2209 - def test_iterparse_file(self):

2210 iterparse = self.etree.iterparse 2211 iterator = iterparse(fileInTestDir("test.xml")) 2212 self.assertEquals(None, 2213 iterator.root) 2214 events = list(iterator) 2215 root = iterator.root 2216 self.assertEquals( 2217 [('end', root[0]), ('end', root)], 2218 events)

2219

2220 - def test_iterparse_start(self):

2221 iterparse = self.etree.iterparse 2222 f = StringIO('<a><c/></a>') 2223 2224 iterator = iterparse(f, events=('start',)) 2225 events = list(iterator) 2226 root = iterator.root 2227 self.assertEquals( 2228 [('start', root), ('start', root[0]), ('start', root[1])], 2229 events)

2230

2231 - def test_iterparse_start_end(self):

2232 iterparse = self.etree.iterparse 2233 f = StringIO('<a><c/></a>') 2234 2235 iterator = iterparse(f, events=('start','end')) 2236 events = list(iterator) 2237 root = iterator.root 2238 self.assertEquals( 2239 [('start', root), ('start', root[0]), ('end', root[0]), 2240 ('start', root[1]), ('end', root[1]), ('end', root)], 2241 events)

2242

2243 - def test_iterparse_clear(self):

2244 iterparse = self.etree.iterparse 2245 f = StringIO('<a><c/></a>') 2246 2247 iterator = iterparse(f) 2248 for event, elem in iterator: 2249 elem.clear() 2250 2251 root = iterator.root 2252 self.assertEquals(0, 2253 len(root))

2254

2255 - def test_iterparse_large(self):

2256 iterparse = self.etree.iterparse 2257 CHILD_COUNT = 12345 2258 f = StringIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2259 2260 i = 0 2261 for key in iterparse(f): 2262 event, element = key 2263 i += 1 2264 self.assertEquals(i, CHILD_COUNT + 1)

2265

2266 - def test_iterparse_attrib_ns(self):

2267 iterparse = self.etree.iterparse 2268 f = StringIO('<a xmlns="ns1"><c xmlns="ns2"/></a>') 2269 2270 attr_name = '{testns}bla' 2271 events = [] 2272 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2273 for event, elem in iterator: 2274 events.append(event) 2275 if event == 'start': 2276 if elem.tag != '{ns1}a': 2277 elem.set(attr_name, 'value') 2278 2279 self.assertEquals( 2280 ['start-ns', 'start', 'start', 'start-ns', 'start', 2281 'end', 'end-ns', 'end', 'end', 'end-ns'], 2282 events) 2283 2284 root = iterator.root 2285 self.assertEquals( 2286 None, 2287 root.get(attr_name)) 2288 self.assertEquals( 2289 'value', 2290 root[0].get(attr_name))

2291

2292 - def test_iterparse_getiterator(self):

2293 iterparse = self.etree.iterparse 2294 f = StringIO('<a><d/><c/></a>') 2295 2296 counts = [] 2297 for event, elem in iterparse(f): 2298 counts.append(len(list(elem.getiterator()))) 2299 self.assertEquals( 2300 [1,2,1,4], 2301 counts)

2302

2303 - def test_parse_file(self):

2304 parse = self.etree.parse 2305 # from file 2306 tree = parse(fileInTestDir('test.xml')) 2307 self.assertXML( 2308 '<a></a>', 2309 tree.getroot())

2310

2311 - def test_parse_file_nonexistent(self):

2312 parse = self.etree.parse 2313 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2314

2315 - def test_parse_file_object(self):

2316 parse = self.etree.parse 2317 # from file object 2318 f = open(fileInTestDir('test.xml'), 'r') 2319 tree = parse(f) 2320 f.close() 2321 self.assertXML( 2322 '<a></a>', 2323 tree.getroot())

2324

2325 - def test_parse_stringio(self):

2326 parse = self.etree.parse 2327 # from StringIO 2328 f = StringIO('<a></a>') 2329 tree = parse(f) 2330 f.close() 2331 self.assertXML( 2332 '<a></a>', 2333 tree.getroot() 2334 )

2335

2336 - def test_parse_with_encoding(self):

2337 # this can fail in libxml2 <= 2.6.22 2338 parse = self.etree.parse 2339 tree = parse(StringIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2340 self.assertXML('<html></html>', 2341 tree.getroot())

2342

2343 - def test_encoding(self):

2344 Element = self.etree.Element 2345 2346 a = Element('a') 2347 a.text = u'Søk på nettet' 2348 self.assertXML( 2349 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2350 a, 'utf-8')

2351

2352 - def test_encoding_exact(self):

2353 ElementTree = self.etree.ElementTree 2354 Element = self.etree.Element 2355 2356 a = Element('a') 2357 a.text = u'Søk på nettet' 2358 2359 f = StringIO() 2360 tree = ElementTree(element=a) 2361 tree.write(f, 'utf-8') 2362 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2363 f.getvalue())

2364

2365 - def test_parse_file_encoding(self):

2366 parse = self.etree.parse 2367 # from file 2368 tree = parse(fileInTestDir('test-string.xml')) 2369 self.assertXML( 2370 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2371 tree.getroot(), 'UTF-8')

2372

2373 - def test_parse_file_object_encoding(self):

2374 parse = self.etree.parse 2375 # from file object 2376 f = open(fileInTestDir('test-string.xml'), 'r') 2377 tree = parse(f) 2378 f.close() 2379 self.assertXML( 2380 u'<a>Søk på nettet</a>'.encode('UTF-8'), 2381 tree.getroot(), 'UTF-8')

2382

2383 - def test_encoding_8bit_latin1(self):

2384 ElementTree = self.etree.ElementTree 2385 Element = self.etree.Element 2386 2387 a = Element('a') 2388 a.text = u'Søk på nettet' 2389 2390 f = StringIO() 2391 tree = ElementTree(element=a) 2392 tree.write(f, 'iso-8859-1') 2393 result = f.getvalue() 2394 declaration = "<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>" 2395 self.assertEncodingDeclaration(result,'iso-8859-1') 2396 result = result.split('?>', 1)[-1] 2397 if result[0] == '\n': 2398 result = result[1:] 2399 self.assertEquals(u'<a>Søk på nettet</a>'.encode('iso-8859-1'), 2400 result)

2401

2402 - def test_parse_encoding_8bit_explicit(self):

2403 XMLParser = self.etree.XMLParser 2404 2405 text = u'Søk på nettet' 2406 xml_latin1 = (u'<a>%s</a>' % text).encode('iso-8859-1') 2407 2408 self.assertRaises(self.etree.ParseError, 2409 self.etree.parse, 2410 StringIO(xml_latin1)) 2411 2412 tree = self.etree.parse(StringIO(xml_latin1), 2413 XMLParser(encoding="iso-8859-1")) 2414 a = tree.getroot() 2415 self.assertEquals(a.text, text)

2416

2417 - def test_parse_encoding_8bit_override(self):

2418 XMLParser = self.etree.XMLParser 2419 2420 text = u'Søk på nettet' 2421 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 2422 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 2423 ).encode('iso-8859-1') 2424 2425 self.assertRaises(self.etree.ParseError, 2426 self.etree.parse, 2427 StringIO(xml_latin1)) 2428 2429 tree = self.etree.parse(StringIO(xml_latin1), 2430 XMLParser(encoding="iso-8859-1")) 2431 a = tree.getroot() 2432 self.assertEquals(a.text, text)

2433

2434 - def _test_wrong_unicode_encoding(self):

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

2440

2441 - def test_encoding_write_default_encoding(self):

2442 ElementTree = self.etree.ElementTree 2443 Element = self.etree.Element 2444 2445 a = Element('a') 2446 a.text = u'Søk på nettet' 2447 2448 f = StringIO() 2449 tree = ElementTree(element=a) 2450 tree.write(f) 2451 data = f.getvalue() 2452 self.assertEquals( 2453 u'<a>Søk på nettet</a>'.encode('ASCII', 'xmlcharrefreplace'), 2454 data)

2455

2456 - def test_encoding_tostring(self):

2457 Element = self.etree.Element 2458 tostring = self.etree.tostring 2459 2460 a = Element('a') 2461 a.text = u'Søk på nettet' 2462 self.assertEquals(u'<a>Søk på nettet</a>'.encode('UTF-8'), 2463 tostring(a, 'utf-8'))

2464

2465 - def test_encoding_tostring_unknown(self):

2466 Element = self.etree.Element 2467 tostring = self.etree.tostring 2468 2469 a = Element('a') 2470 a.text = u'Søk på nettet' 2471 self.assertRaises(LookupError, tostring, a, 'Invalid Encoding')

2472

2473 - def test_encoding_tostring_sub(self):

2474 Element = self.etree.Element 2475 SubElement = self.etree.SubElement 2476 tostring = self.etree.tostring 2477 2478 a = Element('a') 2479 b = SubElement(a, 'b') 2480 b.text = u'Søk på nettet' 2481 self.assertEquals(u'Søk på nettet'.encode('UTF-8'), 2482 tostring(b, 'utf-8'))

2483

2484 - def test_encoding_tostring_sub_tail(self):

2485 Element = self.etree.Element 2486 SubElement = self.etree.SubElement 2487 tostring = self.etree.tostring 2488 2489 a = Element('a') 2490 b = SubElement(a, 'b') 2491 b.text = u'Søk på nettet' 2492 b.tail = u'Søk' 2493 self.assertEquals(u'Søk på nettetSøk'.encode('UTF-8'), 2494 tostring(b, 'utf-8'))

2495

2496 - def test_encoding_tostring_default_encoding(self):

2497 Element = self.etree.Element 2498 SubElement = self.etree.SubElement 2499 tostring = self.etree.tostring 2500 2501 a = Element('a') 2502 a.text = u'Søk på nettet' 2503 2504 expected = '<a>Søk på nettet</a>' 2505 self.assertEquals( 2506 expected, 2507 tostring(a))

2508

2509 - def test_encoding_sub_tostring_default_encoding(self):

2510 Element = self.etree.Element 2511 SubElement = self.etree.SubElement 2512 tostring = self.etree.tostring 2513 2514 a = Element('a') 2515 b = SubElement(a, 'b') 2516 b.text = u'Søk på nettet' 2517 2518 expected = 'Søk på nettet' 2519 self.assertEquals( 2520 expected, 2521 tostring(b))

2522

2523 - def test_encoding_8bit_xml(self):

2524 utext = u'Søk på nettet' 2525 uxml = u'%s' % utext 2526 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2527 isoxml = prologue + uxml.encode('iso-8859-1') 2528 tree = self.etree.XML(isoxml) 2529 self.assertEquals(utext, tree.text)

2530

2531 - def test_encoding_utf8_bom(self):

2532 utext = u'Søk på nettet' 2533 uxml = u'<?xml version="1.0" encoding="UTF-8"?>' + \ 2534 u'%s' % utext 2535 bom = '\xEF\xBB\xBF' 2536 xml = bom + uxml.encode("utf-8") 2537 tree = etree.XML(xml) 2538 self.assertEquals(utext, tree.text)

2539

2540 - def test_encoding_8bit_parse_stringio(self):

2541 utext = u'Søk på nettet' 2542 uxml = u'%s' % utext 2543 prologue = '<?xml version="1.0" encoding="iso-8859-1" ?>' 2544 isoxml = prologue + uxml.encode('iso-8859-1') 2545 el = self.etree.parse(StringIO(isoxml)).getroot() 2546 self.assertEquals(utext, el.text)

2547

2548 - def test_deepcopy_elementtree(self):

2549 Element = self.etree.Element 2550 ElementTree = self.etree.ElementTree 2551 2552 a = Element('a') 2553 a.text = "Foo" 2554 atree = ElementTree(a) 2555 2556 btree = copy.deepcopy(atree) 2557 self.assertEqual("Foo", atree.getroot().text) 2558 self.assertEqual("Foo", btree.getroot().text) 2559 self.assertFalse(btree is atree) 2560 self.assertFalse(btree.getroot() is atree.getroot())

2561

2562 - def test_deepcopy(self):

2563 Element = self.etree.Element 2564 2565 a = Element('a') 2566 a.text = 'Foo' 2567 2568 b = copy.deepcopy(a) 2569 self.assertEquals('Foo', b.text) 2570 2571 b.text = 'Bar' 2572 self.assertEquals('Bar', b.text) 2573 self.assertEquals('Foo', a.text) 2574 2575 del a 2576 self.assertEquals('Bar', b.text)

2577

2578 - def test_deepcopy_tail(self):

2579 Element = self.etree.Element 2580 2581 a = Element('a') 2582 a.tail = 'Foo' 2583 2584 b = copy.deepcopy(a) 2585 self.assertEquals('Foo', b.tail) 2586 2587 b.tail = 'Bar' 2588 self.assertEquals('Bar', b.tail) 2589 self.assertEquals('Foo', a.tail) 2590 2591 del a 2592 self.assertEquals('Bar', b.tail)

2593

2594 - def test_deepcopy_subelement(self):

2595 Element = self.etree.Element 2596 SubElement = self.etree.SubElement 2597 2598 root = Element('root') 2599 a = SubElement(root, 'a') 2600 a.text = 'FooText' 2601 a.tail = 'FooTail' 2602 2603 b = copy.deepcopy(a) 2604 self.assertEquals('FooText', b.text) 2605 self.assertEquals('FooTail', b.tail) 2606 2607 b.text = 'BarText' 2608 b.tail = 'BarTail' 2609 self.assertEquals('BarTail', b.tail) 2610 self.assertEquals('FooTail', a.tail) 2611 self.assertEquals('BarText', b.text) 2612 self.assertEquals('FooText', a.text) 2613 2614 del a 2615 self.assertEquals('BarTail', b.tail) 2616 self.assertEquals('BarText', b.text)

2617

2618 - def test_deepcopy_namespaces(self):

2619 root = self.etree.XML('''<doc xmlns="dns" xmlns:t="tns"> 2620 <parent><node t:foo="bar" /></parent> 2621 </doc>''') 2622 self.assertEquals( 2623 root[0][0].get('{tns}foo'), 2624 copy.deepcopy(root[0])[0].get('{tns}foo') ) 2625 self.assertEquals( 2626 root[0][0].get('{tns}foo'), 2627 copy.deepcopy(root[0][0]).get('{tns}foo') )

2628

2629 - def test_deepcopy_append(self):

2630 # previously caused a crash 2631 Element = self.etree.Element 2632 tostring = self.etree.tostring 2633 2634 a = Element('a') 2635 b = copy.deepcopy(a) 2636 a.append( Element('C') ) 2637 b.append( Element('X') ) 2638 2639 self.assertEquals('<a><C/></a>', 2640 tostring(a).replace(' ', '')) 2641 self.assertEquals('<a><X/></a>', 2642 tostring(b).replace(' ', ''))

2643

2644 - def test_shallowcopy(self):

2645 Element = self.etree.Element 2646 2647 a = Element('a') 2648 a.text = 'Foo' 2649 2650 b = copy.copy(a) 2651 self.assertEquals('Foo', b.text) 2652 2653 b.text = 'Bar' 2654 self.assertEquals('Bar', b.text) 2655 self.assertEquals('Foo', a.text)

2656 # XXX ElementTree will share nodes, but lxml.etree won't.. 2657

2658 - def test_shallowcopy_elementtree(self):

2659 Element = self.etree.Element 2660 ElementTree = self.etree.ElementTree 2661 2662 a = Element('a') 2663 a.text = 'Foo' 2664 atree = ElementTree(a) 2665 2666 btree = copy.copy(atree) 2667 self.assertFalse(btree is atree) 2668 self.assert_(btree.getroot() is atree.getroot()) 2669 self.assertEquals('Foo', atree.getroot().text)

2670

2671 - def _test_element_boolean(self):

2672 # deprecated as of ET 1.3/lxml 2.0 2673 etree = self.etree 2674 e = etree.Element('foo') 2675 self.assertEquals(False, bool(e)) 2676 etree.SubElement(e, 'bar') 2677 self.assertEquals(True, bool(e)) 2678 e = etree.Element('foo') 2679 e.text = 'hey' 2680 self.assertEquals(False, bool(e)) 2681 e = etree.Element('foo') 2682 e.tail = 'bar' 2683 self.assertEquals(False, bool(e)) 2684 e = etree.Element('foo') 2685 e.set('bar', 'Bar') 2686 self.assertEquals(False, bool(e))

2687

2688 - def test_multiple_elementrees(self):

2689 etree = self.etree 2690 2691 a = etree.Element('a') 2692 b = etree.SubElement(a, 'b') 2693 2694 t = etree.ElementTree(a) 2695 self.assertEquals(self._rootstring(t), '<a></a>') 2696 2697 t1 = etree.ElementTree(a) 2698 self.assertEquals(self._rootstring(t1), '<a></a>') 2699 self.assertEquals(self._rootstring(t), '<a></a>') 2700 2701 t2 = etree.ElementTree(b) 2702 self.assertEquals(self._rootstring(t2), '') 2703 self.assertEquals(self._rootstring(t1), '<a></a>') 2704 self.assertEquals(self._rootstring(t), '<a></a>')

2705

2706 - def test_qname(self):

2707 etree = self.etree 2708 qname = etree.QName('myns', 'a') 2709 a1 = etree.Element(qname) 2710 a2 = etree.SubElement(a1, qname) 2711 self.assertEquals(a1.tag, "{myns}a") 2712 self.assertEquals(a2.tag, "{myns}a")

2713

2714 - def test_qname_cmp(self):

2715 etree = self.etree 2716 qname1 = etree.QName('myns', 'a') 2717 qname2 = etree.QName('myns', 'a') 2718 self.assertEquals(qname1, "{myns}a") 2719 self.assertEquals("{myns}a", qname2) 2720 self.assertEquals(qname1, qname1) 2721 self.assertEquals(qname1, qname2)

2722

2723 - def test_qname_attribute_getset(self):

2724 etree = self.etree 2725 qname = etree.QName('myns', 'a') 2726 2727 a = etree.Element(qname) 2728 a.set(qname, "value") 2729 2730 self.assertEquals(a.get(qname), "value") 2731 self.assertEquals(a.get("{myns}a"), "value")

2732

2733 - def test_qname_attrib(self):

2734 etree = self.etree 2735 qname = etree.QName('myns', 'a') 2736 2737 a = etree.Element(qname) 2738 a.attrib[qname] = "value" 2739 2740 self.assertEquals(a.attrib[qname], "value") 2741 self.assertEquals(a.attrib.get(qname), "value") 2742 2743 self.assertEquals(a.attrib["{myns}a"], "value") 2744 self.assertEquals(a.attrib.get("{myns}a"), "value")

2745

2746 - def test_qname_attribute_resolve(self):

2747 etree = self.etree 2748 qname = etree.QName('http://myns', 'a') 2749 a = etree.Element(qname) 2750 a.set(qname, qname) 2751 2752 self.assertXML( 2753 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2754 a)

2755

2756 - def test_qname_attribute_resolve_new(self):

2757 etree = self.etree 2758 qname = etree.QName('http://myns', 'a') 2759 a = etree.Element('a') 2760 a.set('a', qname) 2761 2762 self.assertXML( 2763 '<a xmlns:ns0="http://myns" a="ns0:a"></a>', 2764 a)

2765

2766 - def test_qname_attrib_resolve(self):

2767 etree = self.etree 2768 qname = etree.QName('http://myns', 'a') 2769 a = etree.Element(qname) 2770 a.attrib[qname] = qname 2771 2772 self.assertXML( 2773 '<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>', 2774 a)

2775

2776 - def test_parser_version(self):

2777 etree = self.etree 2778 parser = etree.XMLParser() 2779 if hasattr(parser, "version"): 2780 # ElementTree 1.3+, cET 2781 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

2782 2783 # feed parser interface 2784

2785 - def test_feed_parser(self):

2786 parser = self.etree.XMLParser() 2787 2788 parser.feed('<?xml version=') 2789 parser.feed('"1.0"?><ro') 2790 parser.feed('ot><') 2791 parser.feed('a test="works"/') 2792 parser.feed('></root') 2793 parser.feed('>') 2794 2795 root = parser.close() 2796 2797 self.assertEquals(root.tag, "root") 2798 self.assertEquals(root[0].tag, "a") 2799 self.assertEquals(root[0].get("test"), "works")

2800

2801 - def test_feed_parser_error_close_empty(self):

2802 parser = self.etree.XMLParser() 2803 self.assertRaises(Exception, parser.close)

2804

2805 - def test_feed_parser_error_close_incomplete(self):

2806 parser = self.etree.XMLParser() 2807 2808 parser.feed('<?xml version=') 2809 parser.feed('"1.0"?><ro') 2810 2811 self.assertRaises(Exception, parser.close)

2812

2813 - def test_feed_parser_error_broken(self):

2814 parser = self.etree.XMLParser() 2815 2816 parser.feed('<?xml version=') 2817 parser.feed('"1.0"?><ro') 2818 try: 2819 parser.feed('<ro<ro<ro<ro') 2820 except: 2821 # can raise, but not required before close() 2822 pass 2823 2824 self.assertRaises(Exception, parser.close)

2825 2826 # parser target interface 2827

2828 - def test_parser_target_tag(self):

2829 assertEquals = self.assertEquals 2830 assertFalse = self.assertFalse 2831 2832 events = [] 2833 class Target(object): 2834 def start(self, tag, attrib): 2835 events.append("start") 2836 assertFalse(attrib) 2837 assertEquals("TAG", tag)

2838 def end(self, tag): 2839 events.append("end") 2840 assertEquals("TAG", tag) 2841 def close(self): 2842 return "DONE" 2843 2844 parser = self.etree.XMLParser(target=Target()) 2845 2846 parser.feed("<TAG/>") 2847 done = parser.close() 2848 2849 self.assertEquals("DONE", done) 2850 self.assertEquals(["start", "end"], events) 2851

2852 - def test_parser_target_attrib(self):

2853 assertEquals = self.assertEquals 2854 assertFalse = self.assertFalse 2855 2856 events = [] 2857 class Target(object): 2858 def start(self, tag, attrib): 2859 events.append("start-" + tag) 2860 for name, value in attrib.iteritems(): 2861 assertEquals(tag + name, value)

2862 def end(self, tag): 2863 events.append("end-" + tag) 2864 def close(self): 2865 return "DONE" 2866 2867 parser = self.etree.XMLParser(target=Target()) 2868 2869 parser.feed('<root a="roota" b="rootb"></root>') 2870 done = parser.close() 2871 2872 self.assertEquals("DONE", done) 2873 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 2874 events) 2875

2876 - def test_parser_target_data(self):

2877 assertEquals = self.assertEquals 2878 assertFalse = self.assertFalse 2879 2880 events = [] 2881 class Target(object): 2882 def start(self, tag, attrib): 2883 events.append("start-" + tag)

2884 def end(self, tag): 2885 events.append("end-" + tag) 2886 def data(self, data): 2887 events.append("data-" + data) 2888 def close(self): 2889 return "DONE" 2890 2891 parser = self.etree.XMLParser(target=Target()) 2892 2893 parser.feed('<root>AB</root>') 2894 done = parser.close() 2895 2896 self.assertEquals("DONE", done) 2897 self.assertEquals(["start-root", "data-A", "start-sub", 2898 "end-sub", "data-B", "end-root"], 2899 events) 2900 2901 # helper methods 2902

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

2904 """Write out element for comparison. 2905 """ 2906 data = self.etree.tostring(element, encoding=encoding) 2907 if encoding != 'us-ascii': 2908 data = unicode(data, encoding) 2909 return canonicalize(data)

2910

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

2912 """Write out element for comparison, using real file. 2913 """ 2914 ElementTree = self.etree.ElementTree 2915 handle, filename = tempfile.mkstemp() 2916 try: 2917 f = open(filename, 'wb') 2918 tree = ElementTree(element=element) 2919 tree.write(f, encoding) 2920 f.close() 2921 f = open(filename, 'rb') 2922 data = f.read() 2923 f.close() 2924 finally: 2925 os.close(handle) 2926 os.remove(filename) 2927 if encoding != 'us-ascii': 2928 data = unicode(data, encoding) 2929 return canonicalize(data)

2930

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

2932 """Writes element out and checks whether it is expected. 2933 2934 Does this two ways; once using StringIO, once using a real file. 2935 """ 2936 self.assertEquals(expected, self._writeElement(element, encoding)) 2937 self.assertEquals(expected, self._writeElementFile(element, encoding))

2938

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

2940 "Checks if the result XML byte string specifies the encoding." 2941 has_encoding = re.compile(r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']").match 2942 self.assert_(has_encoding(result)) 2943 result_encoding = has_encoding(result).group(1) 2944 self.assertEquals(result_encoding.upper(), encoding.upper())

2945

2946 - def _rootstring(self, tree):

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

2948

2949 - def _check_element_tree(self, tree):

2950 self._check_element(tree.getroot())

2951

2952 - def _check_element(self, element):

2953 self.assert_(hasattr(element, 'tag')) 2954 self.assert_(hasattr(element, 'attrib')) 2955 self.assert_(hasattr(element, 'text')) 2956 self.assert_(hasattr(element, 'tail')) 2957 self._check_string(element.tag) 2958 self._check_mapping(element.attrib) 2959 if element.text != None: 2960 self._check_string(element.text) 2961 if element.tail != None: 2962 self._check_string(element.tail)

2963

2964 - def _check_string(self, string):

2965 len(string) 2966 for char in string: 2967 self.assertEquals(1, len(char)) 2968 new_string = string + "" 2969 new_string = string + " " 2970 string[:0]

2971

2972 - def _check_mapping(self, mapping):

2973 len(mapping) 2974 keys = mapping.keys() 2975 items = mapping.items() 2976 for key in keys: 2977 item = mapping[key] 2978 mapping["key"] = "value" 2979 self.assertEquals("value", mapping["key"])

2980 2981 # assertFalse doesn't exist in Python 2.3 2982 try: 2983 unittest.TestCase.assertFalse 2984 except AttributeError: 2985 assertFalse = unittest.TestCase.failIf 2986 2987 2988 if etree:

2989 - class ETreeTestCase(ETreeTestCaseBase):

2990 etree = etree

2991 2992 if ElementTree:

2993 - class ElementTreeTestCase(ETreeTestCaseBase):

2994 etree = ElementTree

2995 2996 if cElementTree:

2997 - class CElementTreeTestCase(ETreeTestCaseBase):

2998 etree = cElementTree

2999

3000 -def test_suite():

3001 suite = unittest.TestSuite() 3002 if etree: 3003 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3004 if ElementTree: 3005 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3006 if cElementTree: 3007 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3008 return suite

3009 3010 if __name__ == '__main__': 3011 print 'to test use test.py %s' % __file__ 3012