lxml.tests.test_elementtree

Source Code for Module lxml.tests.test_elementtree

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests for the ElementTree API 5 6 Only test cases that apply equally well to etree and ElementTree 7 belong here. Note that there is a second test module called test_io.py 8 for IO related test cases. 9 """ 10 11 import unittest 12 import os, re, tempfile, copy, operator, gc, sys 13 14 this_dir = os.path.dirname(__file__) 15 if this_dir not in sys.path: 16 sys.path.insert(0, this_dir) # needed for Py3 17 18 from common_imports import StringIO, BytesIO, etree 19 from common_imports import ElementTree, cElementTree, ET_VERSION, CET_VERSION 20 from common_imports import filter_by_version, fileInTestDir, canonicalize, HelperTestCase 21 from common_imports import _str, _bytes, unicode 22 23 if cElementTree is not None and (CET_VERSION <= (1,0,7) or sys.version_info >= (3,3)): 24 cElementTree = None 25 26 if ElementTree is not None: 27 print("Comparing with ElementTree %s" % getattr(ElementTree, "VERSION", "?")) 28 29 if cElementTree is not None: 30 print("Comparing with cElementTree %s" % getattr(cElementTree, "VERSION", "?")) 31 32 try: 33 reversed 34 except NameError: 35 # Python 2.3

36 - def reversed(seq):

37 seq = list(seq)[::-1] 38 return seq

39

40 -class _ETreeTestCaseBase(HelperTestCase):

41 etree = None 42 required_versions_ET = {} 43 required_versions_cET = {} 44

45 - def test_element(self):

46 for i in range(10): 47 e = self.etree.Element('foo') 48 self.assertEquals(e.tag, 'foo') 49 self.assertEquals(e.text, None) 50 self.assertEquals(e.tail, None)

51

52 - def test_simple(self):

53 Element = self.etree.Element 54 55 root = Element('root') 56 root.append(Element('one')) 57 root.append(Element('two')) 58 root.append(Element('three')) 59 self.assertEquals(3, len(root)) 60 self.assertEquals('one', root[0].tag) 61 self.assertEquals('two', root[1].tag) 62 self.assertEquals('three', root[2].tag) 63 self.assertRaises(IndexError, operator.getitem, root, 3)

64 65 # test weird dictionary interaction leading to segfault previously

66 - def test_weird_dict_interaction(self):

67 root = self.etree.Element('root') 68 self.assertEquals(root.tag, "root") 69 add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>')) 70 self.assertEquals(add.getroot().tag, "foo") 71 self.assertEquals(add.getroot().text, "Foo") 72 root.append(self.etree.Element('baz')) 73 self.assertEquals(root.tag, "root") 74 self.assertEquals(root[0].tag, "baz")

75

76 - def test_subelement(self):

77 Element = self.etree.Element 78 SubElement = self.etree.SubElement 79 80 root = Element('root') 81 SubElement(root, 'one') 82 SubElement(root, 'two') 83 SubElement(root, 'three') 84 self.assertEquals(3, len(root)) 85 self.assertEquals('one', root[0].tag) 86 self.assertEquals('two', root[1].tag) 87 self.assertEquals('three', root[2].tag)

88

89 - def test_element_contains(self):

90 Element = self.etree.Element 91 SubElement = self.etree.SubElement 92 93 root1 = Element('root') 94 SubElement(root1, 'one') 95 self.assert_(root1[0] in root1) 96 97 root2 = Element('root') 98 SubElement(root2, 'two') 99 SubElement(root2, 'three') 100 self.assert_(root2[0] in root2) 101 self.assert_(root2[1] in root2) 102 103 self.assertFalse(root1[0] in root2) 104 self.assertFalse(root2[0] in root1) 105 self.assertFalse(None in root2)

106

107 - def test_element_indexing_with_text(self):

108 ElementTree = self.etree.ElementTree 109 110 f = BytesIO('<doc>Test<one>One</one></doc>') 111 doc = ElementTree(file=f) 112 root = doc.getroot() 113 self.assertEquals(1, len(root)) 114 self.assertEquals('one', root[0].tag) 115 self.assertRaises(IndexError, operator.getitem, root, 1)

116

117 - def test_element_indexing_with_text2(self):

118 ElementTree = self.etree.ElementTree 119 120 f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 121 doc = ElementTree(file=f) 122 root = doc.getroot() 123 self.assertEquals(3, len(root)) 124 self.assertEquals('one', root[0].tag) 125 self.assertEquals('two', root[1].tag) 126 self.assertEquals('three', root[2].tag)

127

128 - def test_element_indexing_only_text(self):

129 ElementTree = self.etree.ElementTree 130 131 f = BytesIO('<doc>Test</doc>') 132 doc = ElementTree(file=f) 133 root = doc.getroot() 134 self.assertEquals(0, len(root))

135

136 - def test_element_indexing_negative(self):

137 Element = self.etree.Element 138 SubElement = self.etree.SubElement 139 a = Element('a') 140 b = SubElement(a, 'b') 141 c = SubElement(a, 'c') 142 d = SubElement(a, 'd') 143 self.assertEquals(d, a[-1]) 144 self.assertEquals(c, a[-2]) 145 self.assertEquals(b, a[-3]) 146 self.assertRaises(IndexError, operator.getitem, a, -4) 147 a[-1] = e = Element('e') 148 self.assertEquals(e, a[-1]) 149 del a[-1] 150 self.assertEquals(2, len(a))

151

152 - def test_elementtree(self):

153 ElementTree = self.etree.ElementTree 154 155 f = BytesIO('<doc><one>One</one><two>Two</two></doc>') 156 doc = ElementTree(file=f) 157 root = doc.getroot() 158 self.assertEquals(2, len(root)) 159 self.assertEquals('one', root[0].tag) 160 self.assertEquals('two', root[1].tag)

161

162 - def test_text(self):

163 ElementTree = self.etree.ElementTree 164 165 f = BytesIO('<doc>This is a text</doc>') 166 doc = ElementTree(file=f) 167 root = doc.getroot() 168 self.assertEquals('This is a text', root.text)

169

170 - def test_text_empty(self):

171 ElementTree = self.etree.ElementTree 172 173 f = BytesIO('<doc></doc>') 174 doc = ElementTree(file=f) 175 root = doc.getroot() 176 self.assertEquals(None, root.text)

177

178 - def test_text_other(self):

179 ElementTree = self.etree.ElementTree 180 181 f = BytesIO('<doc><one>One</one></doc>') 182 doc = ElementTree(file=f) 183 root = doc.getroot() 184 self.assertEquals(None, root.text) 185 self.assertEquals('One', root[0].text)

186

187 - def test_text_escape_in(self):

188 ElementTree = self.etree.ElementTree 189 190 f = BytesIO('<doc>This is > than a text</doc>') 191 doc = ElementTree(file=f) 192 root = doc.getroot() 193 self.assertEquals('This is > than a text', root.text)

194

195 - def test_text_escape_out(self):

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

202

203 - def test_text_escape_tostring(self):

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

211

212 - def test_text_str_subclass(self):

213 Element = self.etree.Element 214 215 class strTest(str): 216 pass

217 218 a = Element("a") 219 a.text = strTest("text") 220 self.assertXML(_bytes('<a>text</a>'), 221 a)

222

223 - def test_tail(self):

224 ElementTree = self.etree.ElementTree 225 226 f = BytesIO('<doc>This is mixed content.</doc>') 227 doc = ElementTree(file=f) 228 root = doc.getroot() 229 self.assertEquals(1, len(root)) 230 self.assertEquals('This is ', root.text) 231 self.assertEquals(None, root.tail) 232 self.assertEquals('mixed', root[0].text) 233 self.assertEquals(' content.', root[0].tail)

234

235 - def test_tail_str_subclass(self):

236 Element = self.etree.Element 237 SubElement = self.etree.SubElement 238 239 class strTest(str): 240 pass

241 242 a = Element("a") 243 SubElement(a, "t").tail = strTest("tail") 244 self.assertXML(_bytes('<a><t></t>tail</a>'), 245 a) 246

247 - def _test_del_tail(self):

248 # this is discouraged for ET compat, should not be tested... 249 XML = self.etree.XML 250 251 root = XML(_bytes('<doc>This is mixed content.</doc>')) 252 self.assertEquals(1, len(root)) 253 self.assertEquals('This is ', root.text) 254 self.assertEquals(None, root.tail) 255 self.assertEquals('mixed', root[0].text) 256 self.assertEquals(' content.', root[0].tail) 257 258 del root[0].tail 259 260 self.assertEquals(1, len(root)) 261 self.assertEquals('This is ', root.text) 262 self.assertEquals(None, root.tail) 263 self.assertEquals('mixed', root[0].text) 264 self.assertEquals(None, root[0].tail) 265 266 root[0].tail = "TAIL" 267 268 self.assertEquals(1, len(root)) 269 self.assertEquals('This is ', root.text) 270 self.assertEquals(None, root.tail) 271 self.assertEquals('mixed', root[0].text) 272 self.assertEquals('TAIL', root[0].tail)

273

274 - def test_ElementTree(self):

275 Element = self.etree.Element 276 ElementTree = self.etree.ElementTree 277 278 el = Element('hoi') 279 doc = ElementTree(el) 280 root = doc.getroot() 281 self.assertEquals(None, root.text) 282 self.assertEquals('hoi', root.tag)

283

284 - def test_attributes(self):

285 ElementTree = self.etree.ElementTree 286 287 f = BytesIO('<doc one="One" two="Two"/>') 288 doc = ElementTree(file=f) 289 root = doc.getroot() 290 self.assertEquals('One', root.attrib['one']) 291 self.assertEquals('Two', root.attrib['two']) 292 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

293

294 - def test_attributes2(self):

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

304

305 - def test_attributes3(self):

306 ElementTree = self.etree.ElementTree 307 308 f = BytesIO('<doc one="One" two="Two"/>') 309 doc = ElementTree(file=f) 310 root = doc.getroot() 311 self.assertEquals('One', root.get('one')) 312 self.assertEquals('Two', root.get('two')) 313 self.assertEquals(None, root.get('three')) 314 self.assertEquals('foo', root.get('three', 'foo'))

315

316 - def test_attrib_clear(self):

317 XML = self.etree.XML 318 319 root = XML(_bytes('<doc one="One" two="Two"/>')) 320 self.assertEquals('One', root.get('one')) 321 self.assertEquals('Two', root.get('two')) 322 root.attrib.clear() 323 self.assertEquals(None, root.get('one')) 324 self.assertEquals(None, root.get('two'))

325

326 - def test_attrib_set_clear(self):

327 Element = self.etree.Element 328 329 root = Element("root", one="One") 330 root.set("two", "Two") 331 self.assertEquals('One', root.get('one')) 332 self.assertEquals('Two', root.get('two')) 333 root.attrib.clear() 334 self.assertEquals(None, root.get('one')) 335 self.assertEquals(None, root.get('two'))

336

337 - def test_attrib_ns_clear(self):

338 Element = self.etree.Element 339 SubElement = self.etree.SubElement 340 341 attribNS = '{http://foo/bar}x' 342 343 parent = Element('parent') 344 parent.set(attribNS, 'a') 345 child = SubElement(parent, 'child') 346 child.set(attribNS, 'b') 347 348 self.assertEquals('a', parent.get(attribNS)) 349 self.assertEquals('b', child.get(attribNS)) 350 351 parent.clear() 352 self.assertEquals(None, parent.get(attribNS)) 353 self.assertEquals('b', child.get(attribNS))

354

355 - def test_attrib_pop(self):

356 ElementTree = self.etree.ElementTree 357 358 f = BytesIO('<doc one="One" two="Two"/>') 359 doc = ElementTree(file=f) 360 root = doc.getroot() 361 self.assertEquals('One', root.attrib['one']) 362 self.assertEquals('Two', root.attrib['two']) 363 364 self.assertEquals('One', root.attrib.pop('one')) 365 366 self.assertEquals(None, root.attrib.get('one')) 367 self.assertEquals('Two', root.attrib['two'])

368

369 - def test_attrib_pop_unknown(self):

370 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 371 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 372 373 self.assertEquals('One', root.attrib['one']) 374 self.assertEquals('Two', root.attrib['two'])

375

376 - def test_attrib_pop_default(self):

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

379

380 - def test_attrib_pop_empty_default(self):

381 root = self.etree.XML(_bytes('<doc/>')) 382 self.assertEquals('Three', root.attrib.pop('three', 'Three'))

383

384 - def test_attrib_pop_invalid_args(self):

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

387

388 - def test_attribute_update_dict(self):

389 XML = self.etree.XML 390 391 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 392 items = list(root.attrib.items()) 393 items.sort() 394 self.assertEquals( 395 [('alpha', 'Alpha'), ('beta', 'Beta')], 396 items) 397 398 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 399 400 items = list(root.attrib.items()) 401 items.sort() 402 self.assertEquals( 403 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 404 items)

405

406 - def test_attribute_update_sequence(self):

407 XML = self.etree.XML 408 409 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 410 items = list(root.attrib.items()) 411 items.sort() 412 self.assertEquals( 413 [('alpha', 'Alpha'), ('beta', 'Beta')], 414 items) 415 416 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 417 418 items = list(root.attrib.items()) 419 items.sort() 420 self.assertEquals( 421 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 422 items)

423

424 - def test_attribute_update_iter(self):

425 XML = self.etree.XML 426 427 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 428 items = list(root.attrib.items()) 429 items.sort() 430 self.assertEquals( 431 [('alpha', 'Alpha'), ('beta', 'Beta')], 432 items) 433 434 root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items())) 435 436 items = list(root.attrib.items()) 437 items.sort() 438 self.assertEquals( 439 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 440 items)

441

442 - def test_attribute_update_attrib(self):

443 XML = self.etree.XML 444 445 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 446 items = list(root.attrib.items()) 447 items.sort() 448 self.assertEquals( 449 [('alpha', 'Alpha'), ('beta', 'Beta')], 450 items) 451 452 other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>')) 453 root.attrib.update(other.attrib) 454 455 items = list(root.attrib.items()) 456 items.sort() 457 self.assertEquals( 458 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 459 items)

460

461 - def test_attribute_keys(self):

462 XML = self.etree.XML 463 464 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 465 keys = list(root.attrib.keys()) 466 keys.sort() 467 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

468

469 - def test_attribute_keys2(self):

470 XML = self.etree.XML 471 472 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 473 keys = list(root.keys()) 474 keys.sort() 475 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

476

477 - def test_attribute_items2(self):

478 XML = self.etree.XML 479 480 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 481 items = list(root.items()) 482 items.sort() 483 self.assertEquals( 484 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 485 items)

486

487 - def test_attribute_keys_ns(self):

488 XML = self.etree.XML 489 490 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 491 keys = list(root.keys()) 492 keys.sort() 493 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 494 keys)

495

496 - def test_attribute_values(self):

497 XML = self.etree.XML 498 499 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 500 values = list(root.attrib.values()) 501 values.sort() 502 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)

503

504 - def test_attribute_values_ns(self):

505 XML = self.etree.XML 506 507 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 508 values = list(root.attrib.values()) 509 values.sort() 510 self.assertEquals( 511 ['Bar', 'Baz'], values)

512

513 - def test_attribute_items(self):

514 XML = self.etree.XML 515 516 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 517 items = list(root.attrib.items()) 518 items.sort() 519 self.assertEquals([ 520 ('alpha', 'Alpha'), 521 ('beta', 'Beta'), 522 ('gamma', 'Gamma'), 523 ], 524 items)

525

526 - def test_attribute_items_ns(self):

527 XML = self.etree.XML 528 529 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 530 items = list(root.attrib.items()) 531 items.sort() 532 self.assertEquals( 533 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 534 items)

535

536 - def test_attribute_str(self):

537 XML = self.etree.XML 538 539 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 540 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 541 542 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 543 try: 544 self.assertEquals(expected, str(root.attrib)) 545 except AssertionError: 546 self.assertEquals(alternative, str(root.attrib))

547

548 - def test_attribute_contains(self):

549 XML = self.etree.XML 550 551 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 552 self.assertEquals( 553 True, 'bar' in root.attrib) 554 self.assertEquals( 555 False, 'baz' in root.attrib) 556 self.assertEquals( 557 False, 'hah' in root.attrib) 558 self.assertEquals( 559 True, 560 '{http://ns.codespeak.net/test}baz' in root.attrib)

561

562 - def test_attribute_set(self):

563 Element = self.etree.Element 564 565 root = Element("root") 566 root.set("attr", "TEST") 567 self.assertEquals("TEST", root.get("attr"))

568

569 - def test_attribute_iterator(self):

570 XML = self.etree.XML 571 572 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 573 result = [] 574 for key in root.attrib: 575 result.append(key) 576 result.sort() 577 self.assertEquals(['alpha', 'beta', 'gamma'], result)

578

579 - def test_attribute_manipulation(self):

580 Element = self.etree.Element 581 582 a = Element('a') 583 a.attrib['foo'] = 'Foo' 584 a.attrib['bar'] = 'Bar' 585 self.assertEquals('Foo', a.attrib['foo']) 586 del a.attrib['foo'] 587 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

588

589 - def test_del_attribute_ns(self):

590 Element = self.etree.Element 591 592 a = Element('a') 593 a.attrib['{http://a/}foo'] = 'Foo' 594 a.attrib['{http://a/}bar'] = 'Bar' 595 self.assertEquals(None, a.get('foo')) 596 self.assertEquals('Foo', a.get('{http://a/}foo')) 597 self.assertEquals('Foo', a.attrib['{http://a/}foo']) 598 599 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 600 self.assertEquals('Foo', a.attrib['{http://a/}foo']) 601 602 del a.attrib['{http://a/}foo'] 603 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

604

605 - def test_del_attribute_ns_parsed(self):

606 XML = self.etree.XML 607 608 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 609 610 self.assertEquals('Foo', a.attrib['foo']) 611 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 612 613 del a.attrib['foo'] 614 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 615 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 616 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 617 618 del a.attrib['{http://a/}foo'] 619 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 620 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 621 622 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 623 624 self.assertEquals('Foo', a.attrib['foo']) 625 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 626 627 del a.attrib['foo'] 628 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 629 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 630 631 del a.attrib['{http://a/}foo'] 632 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 633 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

634

635 - def test_XML(self):

636 XML = self.etree.XML 637 638 root = XML(_bytes('<doc>This is a text.</doc>')) 639 self.assertEquals(0, len(root)) 640 self.assertEquals('This is a text.', root.text)

641

642 - def test_XMLID(self):

643 XMLID = self.etree.XMLID 644 XML = self.etree.XML 645 xml_text = _bytes(''' 646 <document> 647 <h1 id="chapter1">...</h1> 648 ... 649 Regular paragraph. 650 XML:ID paragraph. 651 ... 652 </document> 653 ''') 654 655 root, dic = XMLID(xml_text) 656 root2 = XML(xml_text) 657 self.assertEquals(self._writeElement(root), 658 self._writeElement(root2)) 659 expected = { 660 "chapter1" : root[0], 661 "note1" : root[1], 662 "warn1" : root[4] 663 } 664 self.assertEquals(dic, expected)

665

666 - def test_fromstring(self):

667 fromstring = self.etree.fromstring 668 669 root = fromstring('<doc>This is a text.</doc>') 670 self.assertEquals(0, len(root)) 671 self.assertEquals('This is a text.', root.text)

672 673 required_versions_ET['test_fromstringlist'] = (1,3)

674 - def test_fromstringlist(self):

675 fromstringlist = self.etree.fromstringlist 676 677 root = fromstringlist(["<do", "c>T", "hi", "s is", 678 " a text.<", "/doc", ">"]) 679 self.assertEquals(0, len(root)) 680 self.assertEquals('This is a text.', root.text)

681 682 required_versions_ET['test_fromstringlist_characters'] = (1,3)

683 - def test_fromstringlist_characters(self):

684 fromstringlist = self.etree.fromstringlist 685 686 root = fromstringlist(list('<doc>This is a text.</doc>')) 687 self.assertEquals(0, len(root)) 688 self.assertEquals('This is a text.', root.text)

689 690 required_versions_ET['test_fromstringlist_single'] = (1,3)

691 - def test_fromstringlist_single(self):

692 fromstringlist = self.etree.fromstringlist 693 694 root = fromstringlist(['<doc>This is a text.</doc>']) 695 self.assertEquals(0, len(root)) 696 self.assertEquals('This is a text.', root.text)

697

698 - def test_iselement(self):

699 iselement = self.etree.iselement 700 Element = self.etree.Element 701 ElementTree = self.etree.ElementTree 702 XML = self.etree.XML 703 Comment = self.etree.Comment 704 ProcessingInstruction = self.etree.ProcessingInstruction 705 706 el = Element('hoi') 707 self.assert_(iselement(el)) 708 709 el2 = XML(_bytes('<foo/>')) 710 self.assert_(iselement(el2)) 711 712 tree = ElementTree(element=Element('dag')) 713 self.assert_(not iselement(tree)) 714 self.assert_(iselement(tree.getroot())) 715 716 c = Comment('test') 717 self.assert_(iselement(c)) 718 719 p = ProcessingInstruction("test", "some text") 720 self.assert_(iselement(p))

721

722 - def test_iteration(self):

723 XML = self.etree.XML 724 725 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 726 result = [] 727 for el in root: 728 result.append(el.tag) 729 self.assertEquals(['one', 'two', 'three'], result)

730

731 - def test_iteration_empty(self):

732 XML = self.etree.XML 733 734 root = XML(_bytes('<doc></doc>')) 735 result = [] 736 for el in root: 737 result.append(el.tag) 738 self.assertEquals([], result)

739

740 - def test_iteration_text_only(self):

741 XML = self.etree.XML 742 743 root = XML(_bytes('<doc>Text</doc>')) 744 result = [] 745 for el in root: 746 result.append(el.tag) 747 self.assertEquals([], result)

748

749 - def test_iteration_crash(self):

750 # this would cause a crash in the past 751 fromstring = self.etree.fromstring 752 root = etree.fromstring('<html>x</html>') 753 for elem in root: 754 elem.tail = ''

755

756 - def test_iteration_reversed(self):

757 XML = self.etree.XML 758 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 759 result = [] 760 for el in reversed(root): 761 result.append(el.tag) 762 self.assertEquals(['three', 'two', 'one'], result)

763

764 - def test_iteration_subelement(self):

765 XML = self.etree.XML 766 767 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 768 result = [] 769 add = True 770 for el in root: 771 result.append(el.tag) 772 if add: 773 self.etree.SubElement(root, 'four') 774 add = False 775 self.assertEquals(['one', 'two', 'three', 'four'], result)

776

777 - def test_iteration_del_child(self):

778 XML = self.etree.XML 779 780 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 781 result = [] 782 for el in root: 783 result.append(el.tag) 784 del root[-1] 785 self.assertEquals(['one', 'two'], result)

786

787 - def test_iteration_double(self):

788 XML = self.etree.XML 789 790 root = XML(_bytes('<doc><one/><two/></doc>')) 791 result = [] 792 for el0 in root: 793 result.append(el0.tag) 794 for el1 in root: 795 result.append(el1.tag) 796 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

797 798 required_versions_ET['test_itertext'] = (1,3)

799 - def test_itertext(self):

800 # ET 1.3+ 801 XML = self.etree.XML 802 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 803 804 text = list(root.itertext()) 805 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 806 text)

807 808 required_versions_ET['test_itertext_child'] = (1,3)

809 - def test_itertext_child(self):

810 # ET 1.3+ 811 XML = self.etree.XML 812 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 813 814 text = list(root[2].itertext()) 815 self.assertEquals(["CTEXT"], 816 text)

817

818 - def test_findall(self):

819 XML = self.etree.XML 820 root = XML(_bytes('<a><c/><c></c></a>')) 821 self.assertEquals(len(list(root.findall("c"))), 1) 822 self.assertEquals(len(list(root.findall(".//c"))), 2) 823 self.assertEquals(len(list(root.findall(".//b"))), 3) 824 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 825 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 826 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

827

828 - def test_findall_ns(self):

829 XML = self.etree.XML 830 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 831 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 832 self.assertEquals(len(list(root.findall(".//b"))), 3) 833 self.assertEquals(len(list(root.findall("b"))), 2)

834

835 - def test_element_with_attributes_keywords(self):

836 Element = self.etree.Element 837 838 el = Element('tag', foo='Foo', bar='Bar') 839 self.assertEquals('Foo', el.attrib['foo']) 840 self.assertEquals('Bar', el.attrib['bar'])

841

842 - def test_element_with_attributes(self):

843 Element = self.etree.Element 844 845 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 846 self.assertEquals('Foo', el.attrib['foo']) 847 self.assertEquals('Bar', el.attrib['bar'])

848

849 - def test_element_with_attributes_ns(self):

850 Element = self.etree.Element 851 852 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 853 self.assertEquals('Foo', el.attrib['{ns1}foo']) 854 self.assertEquals('Bar', el.attrib['{ns2}bar'])

855

856 - def test_subelement_with_attributes(self):

857 Element = self.etree.Element 858 SubElement = self.etree.SubElement 859 860 el = Element('tag') 861 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 862 self.assertEquals("Baz", el[0].attrib['baz']) 863 self.assertEquals('Foo', el[0].attrib['foo'])

864

865 - def test_subelement_with_attributes_ns(self):

866 Element = self.etree.Element 867 SubElement = self.etree.SubElement 868 869 el = Element('tag') 870 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 871 self.assertEquals('Foo', el[0].attrib['{ns1}foo']) 872 self.assertEquals('Bar', el[0].attrib['{ns2}bar'])

873

874 - def test_write(self):

875 ElementTree = self.etree.ElementTree 876 XML = self.etree.XML 877 878 for i in range(10): 879 f = BytesIO() 880 root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 881 tree = ElementTree(element=root) 882 tree.write(f) 883 data = f.getvalue() 884 self.assertEquals( 885 _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 886 canonicalize(data))

887 888 required_versions_ET['test_write_method_html'] = (1,3)

889 - def test_write_method_html(self):

890 ElementTree = self.etree.ElementTree 891 Element = self.etree.Element 892 SubElement = self.etree.SubElement 893 894 html = Element('html') 895 body = SubElement(html, 'body') 896 p = SubElement(body, 'p') 897 p.text = "html" 898 SubElement(p, 'br').tail = "test" 899 900 tree = ElementTree(element=html) 901 f = BytesIO() 902 tree.write(f, method="html") 903 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 904 905 self.assertEquals(_bytes('<html><body>html test</body></html>'), 906 data)

907 908 required_versions_ET['test_write_method_text'] = (1,3)

909 - def test_write_method_text(self):

910 ElementTree = self.etree.ElementTree 911 Element = self.etree.Element 912 SubElement = self.etree.SubElement 913 914 a = Element('a') 915 a.text = "A" 916 a.tail = "tail" 917 b = SubElement(a, 'b') 918 b.text = "B" 919 b.tail = "TAIL" 920 c = SubElement(a, 'c') 921 c.text = "C" 922 923 tree = ElementTree(element=a) 924 f = BytesIO() 925 tree.write(f, method="text") 926 data = f.getvalue() 927 928 self.assertEquals(_bytes('ABTAILCtail'), 929 data)

930

931 - def test_write_fail(self):

932 ElementTree = self.etree.ElementTree 933 XML = self.etree.XML 934 935 tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 936 self.assertRaises(IOError, tree.write, 937 "definitely////\\-\\nonexisting\\-\\////FILE")

938 939 # this could trigger a crash, apparently because the document 940 # reference was prematurely garbage collected

941 - def test_crash(self):

942 Element = self.etree.Element 943 944 element = Element('tag') 945 for i in range(10): 946 element.attrib['key'] = 'value' 947 value = element.attrib['key'] 948 self.assertEquals(value, 'value')

949 950 # from doctest; for some reason this caused crashes too

951 - def test_write_ElementTreeDoctest(self):

952 Element = self.etree.Element 953 ElementTree = self.etree.ElementTree 954 955 f = BytesIO() 956 for i in range(10): 957 element = Element('tag%s' % i) 958 self._check_element(element) 959 tree = ElementTree(element) 960 tree.write(f) 961 self._check_element_tree(tree)

962

963 - def test_subelement_reference(self):

964 Element = self.etree.Element 965 SubElement = self.etree.SubElement 966 967 el = Element('foo') 968 el2 = SubElement(el, 'bar') 969 el3 = SubElement(el2, 'baz') 970 971 al = Element('foo2') 972 al2 = SubElement(al, 'bar2') 973 al3 = SubElement(al2, 'baz2') 974 975 # now move al2 into el 976 el.append(al2) 977 978 # now change al3 directly 979 al3.text = 'baz2-modified' 980 981 # it should have changed through this route too 982 self.assertEquals( 983 'baz2-modified', 984 el[1][0].text)

985

986 - def test_set_text(self):

987 Element = self.etree.Element 988 SubElement = self.etree.SubElement 989 990 a = Element('a') 991 b = SubElement(a, 'b') 992 a.text = 'hoi' 993 self.assertEquals( 994 'hoi', 995 a.text) 996 self.assertEquals( 997 'b', 998 a[0].tag)

999

1000 - def test_set_text2(self):

1001 Element = self.etree.Element 1002 SubElement = self.etree.SubElement 1003 1004 a = Element('a') 1005 a.text = 'hoi' 1006 b = SubElement(a ,'b') 1007 self.assertEquals( 1008 'hoi', 1009 a.text) 1010 self.assertEquals( 1011 'b', 1012 a[0].tag)

1013

1014 - def test_set_text_none(self):

1015 Element = self.etree.Element 1016 1017 a = Element('a') 1018 1019 a.text = 'foo' 1020 a.text = None 1021 1022 self.assertEquals( 1023 None, 1024 a.text) 1025 self.assertXML(_bytes('<a></a>'), a)

1026

1027 - def test_set_text_empty(self):

1028 Element = self.etree.Element 1029 1030 a = Element('a') 1031 self.assertEquals(None, a.text) 1032 1033 a.text = '' 1034 self.assertEquals('', a.text) 1035 self.assertXML(_bytes('<a></a>'), a)

1036

1037 - def test_tail1(self):

1038 Element = self.etree.Element 1039 SubElement = self.etree.SubElement 1040 1041 a = Element('a') 1042 a.tail = 'dag' 1043 self.assertEquals('dag', 1044 a.tail) 1045 b = SubElement(a, 'b') 1046 b.tail = 'hoi' 1047 self.assertEquals('hoi', 1048 b.tail) 1049 self.assertEquals('dag', 1050 a.tail)

1051

1052 - def test_tail_append(self):

1053 Element = self.etree.Element 1054 1055 a = Element('a') 1056 b = Element('b') 1057 b.tail = 'b_tail' 1058 a.append(b) 1059 self.assertEquals('b_tail', 1060 b.tail)

1061

1062 - def test_tail_set_twice(self):

1063 Element = self.etree.Element 1064 SubElement = self.etree.SubElement 1065 1066 a = Element('a') 1067 b = SubElement(a, 'b') 1068 b.tail = 'foo' 1069 b.tail = 'bar' 1070 self.assertEquals('bar', 1071 b.tail) 1072 self.assertXML(_bytes('<a>bar</a>'), a)

1073

1074 - def test_tail_set_none(self):

1075 Element = self.etree.Element 1076 a = Element('a') 1077 a.tail = 'foo' 1078 a.tail = None 1079 self.assertEquals( 1080 None, 1081 a.tail) 1082 self.assertXML(_bytes('<a></a>'), a)

1083 1084 required_versions_ET['test_extend'] = (1,3)

1085 - def test_extend(self):

1086 root = self.etree.Element('foo') 1087 for i in range(3): 1088 element = self.etree.SubElement(root, 'a%s' % i) 1089 element.text = "text%d" % i 1090 element.tail = "tail%d" % i 1091 1092 elements = [] 1093 for i in range(3): 1094 new_element = self.etree.Element("test%s" % i) 1095 new_element.text = "TEXT%s" % i 1096 new_element.tail = "TAIL%s" % i 1097 elements.append(new_element) 1098 1099 root.extend(elements) 1100 1101 self.assertEquals( 1102 ["a0", "a1", "a2", "test0", "test1", "test2"], 1103 [ el.tag for el in root ]) 1104 self.assertEquals( 1105 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1106 [ el.text for el in root ]) 1107 self.assertEquals( 1108 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1109 [ el.tail for el in root ])

1110

1111 - def test_comment(self):

1112 Element = self.etree.Element 1113 SubElement = self.etree.SubElement 1114 Comment = self.etree.Comment 1115 1116 a = Element('a') 1117 a.append(Comment('foo')) 1118 self.assertEquals(a[0].tag, Comment) 1119 self.assertEquals(a[0].text, 'foo')

1120 1121 # ElementTree < 1.3 adds whitespace around comments 1122 required_versions_ET['test_comment_text'] = (1,3)

1123 - def test_comment_text(self):

1124 Element = self.etree.Element 1125 SubElement = self.etree.SubElement 1126 Comment = self.etree.Comment 1127 tostring = self.etree.tostring 1128 1129 a = Element('a') 1130 a.append(Comment('foo')) 1131 self.assertEquals(a[0].text, 'foo') 1132 1133 self.assertEquals( 1134 _bytes('<a></a>'), 1135 tostring(a)) 1136 1137 a[0].text = "TEST" 1138 self.assertEquals(a[0].text, 'TEST') 1139 1140 self.assertEquals( 1141 _bytes('<a></a>'), 1142 tostring(a))

1143 1144 # ElementTree < 1.3 adds whitespace around comments 1145 required_versions_ET['test_comment_whitespace'] = (1,3)

1146 - def test_comment_whitespace(self):

1147 Element = self.etree.Element 1148 SubElement = self.etree.SubElement 1149 Comment = self.etree.Comment 1150 tostring = self.etree.tostring 1151 1152 a = Element('a') 1153 a.append(Comment(' foo ')) 1154 self.assertEquals(a[0].text, ' foo ') 1155 self.assertEquals( 1156 _bytes('<a></a>'), 1157 tostring(a))

1158

1159 - def test_comment_nonsense(self):

1160 Comment = self.etree.Comment 1161 c = Comment('foo') 1162 self.assertEquals({}, c.attrib) 1163 self.assertEquals([], list(c.keys())) 1164 self.assertEquals([], list(c.items())) 1165 self.assertEquals(None, c.get('hoi')) 1166 self.assertEquals(0, len(c)) 1167 # should not iterate 1168 for i in c: 1169 pass

1170

1171 - def test_pi(self):

1172 # lxml.etree separates target and text 1173 Element = self.etree.Element 1174 SubElement = self.etree.SubElement 1175 ProcessingInstruction = self.etree.ProcessingInstruction 1176 1177 a = Element('a') 1178 a.append(ProcessingInstruction('foo', 'some more text')) 1179 self.assertEquals(a[0].tag, ProcessingInstruction) 1180 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1181 a)

1182

1183 - def test_processinginstruction(self):

1184 # lxml.etree separates target and text 1185 Element = self.etree.Element 1186 SubElement = self.etree.SubElement 1187 ProcessingInstruction = self.etree.PI 1188 1189 a = Element('a') 1190 a.append(ProcessingInstruction('foo', 'some more text')) 1191 self.assertEquals(a[0].tag, ProcessingInstruction) 1192 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1193 a)

1194

1195 - def test_pi_nonsense(self):

1196 ProcessingInstruction = self.etree.ProcessingInstruction 1197 pi = ProcessingInstruction('foo') 1198 self.assertEquals({}, pi.attrib) 1199 self.assertEquals([], list(pi.keys())) 1200 self.assertEquals([], list(pi.items())) 1201 self.assertEquals(None, pi.get('hoi')) 1202 self.assertEquals(0, len(pi)) 1203 # should not iterate 1204 for i in pi: 1205 pass

1206

1207 - def test_setitem(self):

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

1222

1223 - def test_setitem2(self):

1224 Element = self.etree.Element 1225 SubElement = self.etree.SubElement 1226 1227 a = Element('a') 1228 for i in range(5): 1229 b = SubElement(a, 'b%s' % i) 1230 c = SubElement(b, 'c') 1231 for i in range(5): 1232 d = Element('d') 1233 e = SubElement(d, 'e') 1234 a[i] = d 1235 self.assertXML( 1236 _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 1237 a) 1238 self.assertXML(_bytes('<c></c>'), 1239 c)

1240

1241 - def test_setitem_replace(self):

1242 Element = self.etree.Element 1243 SubElement = self.etree.SubElement 1244 1245 a = Element('a') 1246 SubElement(a, 'b') 1247 d = Element('d') 1248 a[0] = d 1249 self.assertXML(_bytes('<a><d></d></a>'), a)

1250

1251 - def test_setitem_indexerror(self):

1252 Element = self.etree.Element 1253 SubElement = self.etree.SubElement 1254 1255 a = Element('a') 1256 b = SubElement(a, 'b') 1257 1258 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1259

1260 - def test_setitem_tail(self):

1261 Element = self.etree.Element 1262 SubElement = self.etree.SubElement 1263 1264 a = Element('a') 1265 b = SubElement(a, 'b') 1266 b.tail = 'B2' 1267 c = Element('c') 1268 c.tail = 'C2' 1269 1270 a[0] = c 1271 self.assertXML( 1272 _bytes('<a><c></c>C2</a>'), 1273 a)

1274

1275 - def test_tag_write(self):

1276 Element = self.etree.Element 1277 SubElement = self.etree.SubElement 1278 1279 a = Element('a') 1280 b = SubElement(a, 'b') 1281 1282 a.tag = 'c' 1283 1284 self.assertEquals( 1285 'c', 1286 a.tag) 1287 1288 self.assertXML( 1289 _bytes('<c></c>'), 1290 a)

1291

1292 - def test_tag_reset_ns(self):

1293 Element = self.etree.Element 1294 SubElement = self.etree.SubElement 1295 tostring = self.etree.tostring 1296 1297 a = Element('{a}a') 1298 b1 = SubElement(a, '{a}b') 1299 b2 = SubElement(a, '{b}b') 1300 1301 self.assertEquals('{a}b', b1.tag) 1302 1303 b1.tag = 'c' 1304 1305 # can't use C14N here! 1306 self.assertEquals('c', b1.tag) 1307 self.assertEquals(_bytes('<c'), tostring(b1)[:2]) 1308 self.assert_(_bytes('<c') in tostring(a))

1309

1310 - def test_tag_reset_root_ns(self):

1311 Element = self.etree.Element 1312 SubElement = self.etree.SubElement 1313 tostring = self.etree.tostring 1314 1315 a = Element('{a}a') 1316 b1 = SubElement(a, '{a}b') 1317 b2 = SubElement(a, '{b}b') 1318 1319 a.tag = 'c' 1320 1321 self.assertEquals( 1322 'c', 1323 a.tag) 1324 1325 # can't use C14N here! 1326 self.assertEquals('c', a.tag) 1327 self.assertEquals(_bytes('<c'), tostring(a)[:2])

1328

1329 - def test_tag_str_subclass(self):

1330 Element = self.etree.Element 1331 1332 class strTest(str): 1333 pass

1334 1335 a = Element("a") 1336 a.tag = strTest("TAG") 1337 self.assertXML(_bytes('<TAG></TAG>'), 1338 a) 1339

1340 - def test_delitem(self):

1341 Element = self.etree.Element 1342 SubElement = self.etree.SubElement 1343 1344 a = Element('a') 1345 b = SubElement(a, 'b') 1346 c = SubElement(a, 'c') 1347 d = SubElement(a, 'd') 1348 1349 del a[1] 1350 self.assertXML( 1351 _bytes('<a><d></d></a>'), 1352 a) 1353 1354 del a[0] 1355 self.assertXML( 1356 _bytes('<a><d></d></a>'), 1357 a) 1358 1359 del a[0] 1360 self.assertXML( 1361 _bytes('<a></a>'), 1362 a) 1363 # move deleted element into other tree afterwards 1364 other = Element('other') 1365 other.append(c) 1366 self.assertXML( 1367 _bytes('<other><c></c></other>'), 1368 other)

1369

1370 - def test_del_insert(self):

1371 Element = self.etree.Element 1372 SubElement = self.etree.SubElement 1373 1374 a = Element('a') 1375 b = SubElement(a, 'b') 1376 bs = SubElement(b, 'bs') 1377 c = SubElement(a, 'c') 1378 cs = SubElement(c, 'cs') 1379 1380 el = a[0] 1381 self.assertXML( 1382 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1383 a) 1384 self.assertXML(_bytes('<bs></bs>'), b) 1385 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1386 1387 del a[0] 1388 self.assertXML( 1389 _bytes('<a><c><cs></cs></c></a>'), 1390 a) 1391 self.assertXML(_bytes('<bs></bs>'), b) 1392 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1393 1394 a.insert(0, el) 1395 self.assertXML( 1396 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1397 a) 1398 self.assertXML(_bytes('<bs></bs>'), b) 1399 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1400

1401 - def test_del_setitem(self):

1402 Element = self.etree.Element 1403 SubElement = self.etree.SubElement 1404 1405 a = Element('a') 1406 b = SubElement(a, 'b') 1407 bs = SubElement(b, 'bs') 1408 c = SubElement(a, 'c') 1409 cs = SubElement(c, 'cs') 1410 1411 el = a[0] 1412 del a[0] 1413 a[0] = el 1414 self.assertXML( 1415 _bytes('<a><bs></bs></a>'), 1416 a) 1417 self.assertXML(_bytes('<bs></bs>'), b) 1418 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1419

1420 - def test_del_setslice(self):

1421 Element = self.etree.Element 1422 SubElement = self.etree.SubElement 1423 1424 a = Element('a') 1425 b = SubElement(a, 'b') 1426 bs = SubElement(b, 'bs') 1427 c = SubElement(a, 'c') 1428 cs = SubElement(c, 'cs') 1429 1430 el = a[0] 1431 del a[0] 1432 a[0:0] = [el] 1433 self.assertXML( 1434 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1435 a) 1436 self.assertXML(_bytes('<bs></bs>'), b) 1437 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1438

1439 - def test_replace_slice_tail(self):

1440 XML = self.etree.XML 1441 a = XML(_bytes('<a>B2<c></c>C2</a>')) 1442 b, c = a 1443 1444 a[:] = [] 1445 1446 self.assertEquals("B2", b.tail) 1447 self.assertEquals("C2", c.tail)

1448

1449 - def test_merge_namespaced_subtree_as_slice(self):

1450 XML = self.etree.XML 1451 root = XML(_bytes( 1452 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 1453 root[:] = root.findall('.//puh') # delete bar from hierarchy 1454 1455 # previously, this lost a namespace declaration on bump2 1456 result = self.etree.tostring(root) 1457 foo = self.etree.fromstring(result) 1458 1459 self.assertEquals('puh', foo[0].tag) 1460 self.assertEquals('{http://huhu}bump1', foo[0][0].tag) 1461 self.assertEquals('{http://huhu}bump2', foo[0][1].tag)

1462

1463 - def test_delitem_tail(self):

1464 ElementTree = self.etree.ElementTree 1465 f = BytesIO('<a>B2<c></c>C2</a>') 1466 doc = ElementTree(file=f) 1467 a = doc.getroot() 1468 del a[0] 1469 self.assertXML( 1470 _bytes('<a><c></c>C2</a>'), 1471 a)

1472

1473 - def test_clear(self):

1474 Element = self.etree.Element 1475 1476 a = Element('a') 1477 a.text = 'foo' 1478 a.tail = 'bar' 1479 a.set('hoi', 'dag') 1480 a.clear() 1481 self.assertEquals(None, a.text) 1482 self.assertEquals(None, a.tail) 1483 self.assertEquals(None, a.get('hoi')) 1484 self.assertEquals('a', a.tag)

1485

1486 - def test_clear_sub(self):

1487 Element = self.etree.Element 1488 SubElement = self.etree.SubElement 1489 1490 a = Element('a') 1491 a.text = 'foo' 1492 a.tail = 'bar' 1493 a.set('hoi', 'dag') 1494 b = SubElement(a, 'b') 1495 c = SubElement(b, 'c') 1496 a.clear() 1497 self.assertEquals(None, a.text) 1498 self.assertEquals(None, a.tail) 1499 self.assertEquals(None, a.get('hoi')) 1500 self.assertEquals('a', a.tag) 1501 self.assertEquals(0, len(a)) 1502 self.assertXML(_bytes('<a></a>'), 1503 a) 1504 self.assertXML(_bytes('<c></c>'), 1505 b)

1506

1507 - def test_clear_tail(self):

1508 ElementTree = self.etree.ElementTree 1509 f = BytesIO('<a>B2<c></c>C2</a>') 1510 doc = ElementTree(file=f) 1511 a = doc.getroot() 1512 a.clear() 1513 self.assertXML( 1514 _bytes('<a></a>'), 1515 a)

1516

1517 - def test_insert(self):

1518 Element = self.etree.Element 1519 SubElement = self.etree.SubElement 1520 1521 a = Element('a') 1522 b = SubElement(a, 'b') 1523 c = SubElement(a, 'c') 1524 d = Element('d') 1525 a.insert(0, d) 1526 1527 self.assertEquals( 1528 d, 1529 a[0]) 1530 1531 self.assertXML( 1532 _bytes('<a><d></d><c></c></a>'), 1533 a) 1534 1535 e = Element('e') 1536 a.insert(2, e) 1537 self.assertEquals( 1538 e, 1539 a[2]) 1540 self.assertXML( 1541 _bytes('<a><d></d><e></e><c></c></a>'), 1542 a)

1543

1544 - def test_insert_beyond_index(self):

1545 Element = self.etree.Element 1546 SubElement = self.etree.SubElement 1547 1548 a = Element('a') 1549 b = SubElement(a, 'b') 1550 c = Element('c') 1551 1552 a.insert(2, c) 1553 self.assertEquals( 1554 c, 1555 a[1]) 1556 self.assertXML( 1557 _bytes('<a><c></c></a>'), 1558 a)

1559

1560 - def test_insert_negative(self):

1561 Element = self.etree.Element 1562 SubElement = self.etree.SubElement 1563 1564 a = Element('a') 1565 b = SubElement(a, 'b') 1566 c = SubElement(a, 'c') 1567 1568 d = Element('d') 1569 a.insert(-1, d) 1570 self.assertEquals( 1571 d, 1572 a[-2]) 1573 self.assertXML( 1574 _bytes('<a><d></d><c></c></a>'), 1575 a)

1576

1577 - def test_insert_tail(self):

1578 Element = self.etree.Element 1579 SubElement = self.etree.SubElement 1580 1581 a = Element('a') 1582 b = SubElement(a, 'b') 1583 1584 c = Element('c') 1585 c.tail = 'C2' 1586 1587 a.insert(0, c) 1588 self.assertXML( 1589 _bytes('<a><c></c>C2</a>'), 1590 a)

1591

1592 - def test_remove(self):

1593 Element = self.etree.Element 1594 SubElement = self.etree.SubElement 1595 1596 a = Element('a') 1597 b = SubElement(a, 'b') 1598 c = SubElement(a, 'c') 1599 1600 a.remove(b) 1601 self.assertEquals( 1602 c, 1603 a[0]) 1604 self.assertXML( 1605 _bytes('<a><c></c></a>'), 1606 a)

1607

1608 - def test_remove_ns(self):

1609 Element = self.etree.Element 1610 SubElement = self.etree.SubElement 1611 1612 a = Element('{http://test}a') 1613 b = SubElement(a, '{http://test}b') 1614 c = SubElement(a, '{http://test}c') 1615 1616 a.remove(b) 1617 self.assertXML( 1618 _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 1619 a) 1620 self.assertXML( 1621 _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 1622 b)

1623

1624 - def test_remove_nonexisting(self):

1625 Element = self.etree.Element 1626 SubElement = self.etree.SubElement 1627 1628 a = Element('a') 1629 b = SubElement(a, 'b') 1630 c = SubElement(a, 'c') 1631 d = Element('d') 1632 self.assertRaises( 1633 ValueError, a.remove, d)

1634

1635 - def test_remove_tail(self):

1636 Element = self.etree.Element 1637 SubElement = self.etree.SubElement 1638 1639 a = Element('a') 1640 b = SubElement(a, 'b') 1641 b.tail = 'b2' 1642 a.remove(b) 1643 self.assertXML( 1644 _bytes('<a></a>'), 1645 a) 1646 self.assertEquals('b2', b.tail)

1647

1648 - def _test_getchildren(self):

1649 Element = self.etree.Element 1650 SubElement = self.etree.SubElement 1651 1652 a = Element('a') 1653 b = SubElement(a, 'b') 1654 c = SubElement(a, 'c') 1655 d = SubElement(b, 'd') 1656 e = SubElement(c, 'e') 1657 self.assertXML( 1658 _bytes('<a><d></d><c><e></e></c></a>'), 1659 a) 1660 self.assertEquals( 1661 [b, c], 1662 a.getchildren()) 1663 self.assertEquals( 1664 [d], 1665 b.getchildren()) 1666 self.assertEquals( 1667 [], 1668 d.getchildren())

1669

1670 - def test_makeelement(self):

1671 Element = self.etree.Element 1672 1673 a = Element('a') 1674 b = a.makeelement('c', {'hoi':'dag'}) 1675 self.assertXML( 1676 _bytes('<c hoi="dag"></c>'), 1677 b)

1678 1679 required_versions_ET['test_iter'] = (1,3)

1680 - def test_iter(self):

1681 Element = self.etree.Element 1682 SubElement = self.etree.SubElement 1683 1684 a = Element('a') 1685 b = SubElement(a, 'b') 1686 c = SubElement(a, 'c') 1687 d = SubElement(b, 'd') 1688 e = SubElement(c, 'e') 1689 1690 self.assertEquals( 1691 [a, b, d, c, e], 1692 list(a.iter())) 1693 self.assertEquals( 1694 [d], 1695 list(d.iter()))

1696

1697 - def test_getiterator(self):

1698 Element = self.etree.Element 1699 SubElement = self.etree.SubElement 1700 1701 a = Element('a') 1702 b = SubElement(a, 'b') 1703 c = SubElement(a, 'c') 1704 d = SubElement(b, 'd') 1705 e = SubElement(c, 'e') 1706 1707 self.assertEquals( 1708 [a, b, d, c, e], 1709 list(a.getiterator())) 1710 self.assertEquals( 1711 [d], 1712 list(d.getiterator()))

1713

1714 - def test_getiterator_empty(self):

1715 Element = self.etree.Element 1716 SubElement = self.etree.SubElement 1717 1718 a = Element('a') 1719 b = SubElement(a, 'b') 1720 c = SubElement(a, 'c') 1721 d = SubElement(b, 'd') 1722 e = SubElement(c, 'e') 1723 1724 self.assertEquals( 1725 [], 1726 list(a.getiterator('none'))) 1727 self.assertEquals( 1728 [], 1729 list(e.getiterator('none'))) 1730 self.assertEquals( 1731 [e], 1732 list(e.getiterator()))

1733

1734 - def test_getiterator_filter(self):

1735 Element = self.etree.Element 1736 SubElement = self.etree.SubElement 1737 1738 a = Element('a') 1739 b = SubElement(a, 'b') 1740 c = SubElement(a, 'c') 1741 d = SubElement(b, 'd') 1742 e = SubElement(c, 'e') 1743 1744 self.assertEquals( 1745 [a], 1746 list(a.getiterator('a'))) 1747 a2 = SubElement(e, 'a') 1748 self.assertEquals( 1749 [a, a2], 1750 list(a.getiterator('a'))) 1751 self.assertEquals( 1752 [a2], 1753 list(c.getiterator('a')))

1754

1755 - def test_getiterator_filter_all(self):

1756 Element = self.etree.Element 1757 SubElement = self.etree.SubElement 1758 1759 a = Element('a') 1760 b = SubElement(a, 'b') 1761 c = SubElement(a, 'c') 1762 d = SubElement(b, 'd') 1763 e = SubElement(c, 'e') 1764 1765 self.assertEquals( 1766 [a, b, d, c, e], 1767 list(a.getiterator('*')))

1768

1769 - def test_getiterator_filter_comment(self):

1770 Element = self.etree.Element 1771 Comment = self.etree.Comment 1772 SubElement = self.etree.SubElement 1773 1774 a = Element('a') 1775 b = SubElement(a, 'b') 1776 comment_b = Comment("TEST-b") 1777 b.append(comment_b) 1778 1779 self.assertEquals( 1780 [comment_b], 1781 list(a.getiterator(Comment))) 1782 1783 comment_a = Comment("TEST-a") 1784 a.append(comment_a) 1785 1786 self.assertEquals( 1787 [comment_b, comment_a], 1788 list(a.getiterator(Comment))) 1789 1790 self.assertEquals( 1791 [comment_b], 1792 list(b.getiterator(Comment)))

1793

1794 - def test_getiterator_filter_pi(self):

1795 Element = self.etree.Element 1796 PI = self.etree.ProcessingInstruction 1797 SubElement = self.etree.SubElement 1798 1799 a = Element('a') 1800 b = SubElement(a, 'b') 1801 pi_b = PI("TEST-b") 1802 b.append(pi_b) 1803 1804 self.assertEquals( 1805 [pi_b], 1806 list(a.getiterator(PI))) 1807 1808 pi_a = PI("TEST-a") 1809 a.append(pi_a) 1810 1811 self.assertEquals( 1812 [pi_b, pi_a], 1813 list(a.getiterator(PI))) 1814 1815 self.assertEquals( 1816 [pi_b], 1817 list(b.getiterator(PI)))

1818

1819 - def test_getiterator_with_text(self):

1820 Element = self.etree.Element 1821 SubElement = self.etree.SubElement 1822 1823 a = Element('a') 1824 a.text = 'a' 1825 b = SubElement(a, 'b') 1826 b.text = 'b' 1827 b.tail = 'b1' 1828 c = SubElement(a, 'c') 1829 c.text = 'c' 1830 c.tail = 'c1' 1831 d = SubElement(b, 'd') 1832 c.text = 'd' 1833 c.tail = 'd1' 1834 e = SubElement(c, 'e') 1835 e.text = 'e' 1836 e.tail = 'e1' 1837 1838 self.assertEquals( 1839 [a, b, d, c, e], 1840 list(a.getiterator()))

1841 #self.assertEquals( 1842 # [d], 1843 # list(d.getiterator())) 1844

1845 - def test_getiterator_filter_with_text(self):

1846 Element = self.etree.Element 1847 SubElement = self.etree.SubElement 1848 1849 a = Element('a') 1850 a.text = 'a' 1851 b = SubElement(a, 'b') 1852 b.text = 'b' 1853 b.tail = 'b1' 1854 c = SubElement(a, 'c') 1855 c.text = 'c' 1856 c.tail = 'c1' 1857 d = SubElement(b, 'd') 1858 c.text = 'd' 1859 c.tail = 'd1' 1860 e = SubElement(c, 'e') 1861 e.text = 'e' 1862 e.tail = 'e1' 1863 1864 self.assertEquals( 1865 [a], 1866 list(a.getiterator('a'))) 1867 a2 = SubElement(e, 'a') 1868 self.assertEquals( 1869 [a, a2], 1870 list(a.getiterator('a'))) 1871 self.assertEquals( 1872 [a2], 1873 list(e.getiterator('a')))

1874

1875 - def test_getslice(self):

1876 Element = self.etree.Element 1877 SubElement = self.etree.SubElement 1878 1879 a = Element('a') 1880 b = SubElement(a, 'b') 1881 c = SubElement(a, 'c') 1882 d = SubElement(a, 'd') 1883 1884 self.assertEquals( 1885 [b, c], 1886 a[0:2]) 1887 self.assertEquals( 1888 [b, c, d], 1889 a[:]) 1890 self.assertEquals( 1891 [b, c, d], 1892 a[:10]) 1893 self.assertEquals( 1894 [b], 1895 a[0:1]) 1896 self.assertEquals( 1897 [], 1898 a[10:12])

1899

1900 - def test_getslice_negative(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 d = SubElement(a, 'd') 1908 1909 self.assertEquals( 1910 [d], 1911 a[-1:]) 1912 self.assertEquals( 1913 [c, d], 1914 a[-2:]) 1915 self.assertEquals( 1916 [c], 1917 a[-2:-1]) 1918 self.assertEquals( 1919 [b, c], 1920 a[-3:-1]) 1921 self.assertEquals( 1922 [b, c], 1923 a[-3:2])

1924

1925 - def test_getslice_step(self):

1926 Element = self.etree.Element 1927 SubElement = self.etree.SubElement 1928 1929 a = Element('a') 1930 b = SubElement(a, 'b') 1931 c = SubElement(a, 'c') 1932 d = SubElement(a, 'd') 1933 e = SubElement(a, 'e') 1934 1935 self.assertEquals( 1936 [e,d,c,b], 1937 a[::-1]) 1938 self.assertEquals( 1939 [b,d], 1940 a[::2]) 1941 self.assertEquals( 1942 [e,c], 1943 a[::-2]) 1944 self.assertEquals( 1945 [d,c], 1946 a[-2:0:-1]) 1947 self.assertEquals( 1948 [e], 1949 a[:1:-2])

1950

1951 - def test_getslice_text(self):

1952 ElementTree = self.etree.ElementTree 1953 1954 f = BytesIO('<a>BB1<c>C</c>C1</a>') 1955 doc = ElementTree(file=f) 1956 a = doc.getroot() 1957 b = a[0] 1958 c = a[1] 1959 self.assertEquals( 1960 [b, c], 1961 a[:]) 1962 self.assertEquals( 1963 [b], 1964 a[0:1]) 1965 self.assertEquals( 1966 [c], 1967 a[1:])

1968

1969 - def test_comment_getitem_getslice(self):

1970 Element = self.etree.Element 1971 Comment = self.etree.Comment 1972 SubElement = self.etree.SubElement 1973 1974 a = Element('a') 1975 b = SubElement(a, 'b') 1976 foo = Comment('foo') 1977 a.append(foo) 1978 c = SubElement(a, 'c') 1979 self.assertEquals( 1980 [b, foo, c], 1981 a[:]) 1982 self.assertEquals( 1983 foo, 1984 a[1]) 1985 a[1] = new = Element('new') 1986 self.assertEquals( 1987 new, 1988 a[1]) 1989 self.assertXML( 1990 _bytes('<a><new></new><c></c></a>'), 1991 a)

1992

1993 - def test_delslice(self):

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

2007

2008 - def test_delslice_negative1(self):

2009 Element = self.etree.Element 2010 SubElement = self.etree.SubElement 2011 2012 a = Element('a') 2013 b = SubElement(a, 'b') 2014 c = SubElement(a, 'c') 2015 d = SubElement(a, 'd') 2016 e = SubElement(a, 'e') 2017 2018 del a[1:-1] 2019 self.assertEquals( 2020 [b, e], 2021 list(a))

2022

2023 - def test_delslice_negative2(self):

2024 Element = self.etree.Element 2025 SubElement = self.etree.SubElement 2026 2027 a = Element('a') 2028 b = SubElement(a, 'b') 2029 c = SubElement(a, 'c') 2030 d = SubElement(a, 'd') 2031 e = SubElement(a, 'e') 2032 2033 del a[-3:-1] 2034 self.assertEquals( 2035 [b, e], 2036 list(a))

2037

2038 - def test_delslice_step(self):

2039 Element = self.etree.Element 2040 SubElement = self.etree.SubElement 2041 2042 a = Element('a') 2043 b = SubElement(a, 'b') 2044 c = SubElement(a, 'c') 2045 d = SubElement(a, 'd') 2046 e = SubElement(a, 'e') 2047 2048 del a[1::2] 2049 self.assertEquals( 2050 [b, d], 2051 list(a))

2052

2053 - def test_delslice_step_negative(self):

2054 Element = self.etree.Element 2055 SubElement = self.etree.SubElement 2056 2057 a = Element('a') 2058 b = SubElement(a, 'b') 2059 c = SubElement(a, 'c') 2060 d = SubElement(a, 'd') 2061 e = SubElement(a, 'e') 2062 2063 del a[::-1] 2064 self.assertEquals( 2065 [], 2066 list(a))

2067

2068 - def test_delslice_step_negative2(self):

2069 Element = self.etree.Element 2070 SubElement = self.etree.SubElement 2071 2072 a = Element('a') 2073 b = SubElement(a, 'b') 2074 c = SubElement(a, 'c') 2075 d = SubElement(a, 'd') 2076 e = SubElement(a, 'e') 2077 2078 del a[::-2] 2079 self.assertEquals( 2080 [b, d], 2081 list(a))

2082

2083 - def test_delslice_child_tail(self):

2084 ElementTree = self.etree.ElementTree 2085 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2086 doc = ElementTree(file=f) 2087 a = doc.getroot() 2088 del a[1:3] 2089 self.assertXML( 2090 _bytes('<a>B2<e></e>E2</a>'), 2091 a)

2092

2093 - def test_delslice_tail(self):

2094 XML = self.etree.XML 2095 a = XML(_bytes('<a>B2<c></c>C2</a>')) 2096 b, c = a 2097 2098 del a[:] 2099 2100 self.assertEquals("B2", b.tail) 2101 self.assertEquals("C2", c.tail)

2102

2103 - def test_delslice_memory(self):

2104 # this could trigger a crash 2105 Element = self.etree.Element 2106 SubElement = self.etree.SubElement 2107 a = Element('a') 2108 b = SubElement(a, 'b') 2109 c = SubElement(b, 'c') 2110 del b # no more reference to b 2111 del a[:] 2112 self.assertEquals('c', c.tag)

2113

2114 - def test_setslice(self):

2115 Element = self.etree.Element 2116 SubElement = self.etree.SubElement 2117 2118 a = Element('a') 2119 b = SubElement(a, 'b') 2120 c = SubElement(a, 'c') 2121 d = SubElement(a, 'd') 2122 2123 e = Element('e') 2124 f = Element('f') 2125 g = Element('g') 2126 2127 s = [e, f, g] 2128 a[1:2] = s 2129 self.assertEquals( 2130 [b, e, f, g, d], 2131 list(a))

2132

2133 - def test_setslice_all(self):

2134 Element = self.etree.Element 2135 SubElement = self.etree.SubElement 2136 2137 a = Element('a') 2138 b = SubElement(a, 'b') 2139 c = SubElement(a, 'c') 2140 2141 e = Element('e') 2142 f = Element('f') 2143 g = Element('g') 2144 2145 s = [e, f, g] 2146 a[:] = s 2147 self.assertEquals( 2148 [e, f, g], 2149 list(a))

2150

2151 - def test_setslice_all_empty(self):

2152 Element = self.etree.Element 2153 SubElement = self.etree.SubElement 2154 2155 a = Element('a') 2156 2157 e = Element('e') 2158 f = Element('f') 2159 g = Element('g') 2160 2161 s = [e, f, g] 2162 a[:] = s 2163 self.assertEquals( 2164 [e, f, g], 2165 list(a))

2166

2167 - def test_setslice_all_replace(self):

2168 Element = self.etree.Element 2169 SubElement = self.etree.SubElement 2170 2171 a = Element('a') 2172 b = SubElement(a, 'b') 2173 c = SubElement(a, 'c') 2174 d = SubElement(a, 'd') 2175 2176 s = [b, c, d] 2177 a[:] = s 2178 self.assertEquals( 2179 [b, c, d], 2180 list(a))

2181

2182 - def test_setslice_all_replace_reversed(self):

2183 Element = self.etree.Element 2184 SubElement = self.etree.SubElement 2185 2186 a = Element('a') 2187 b = SubElement(a, 'b') 2188 c = SubElement(a, 'c') 2189 d = SubElement(a, 'd') 2190 2191 s = [d, c, b] 2192 a[:] = s 2193 self.assertEquals( 2194 [d, c, b], 2195 list(a))

2196

2197 - def test_setslice_all_replace_reversed_ns1(self):

2198 Element = self.etree.Element 2199 SubElement = self.etree.SubElement 2200 2201 a = Element('{ns}a') 2202 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2203 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2204 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2205 2206 s = [d, c, b] 2207 a[:] = s 2208 self.assertEquals( 2209 [d, c, b], 2210 list(a)) 2211 self.assertEquals( 2212 ['{ns}d', '{ns}c', '{ns}b'], 2213 [ child.tag for child in a ]) 2214 2215 self.assertEquals( 2216 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2217 [ list(child.attrib.keys()) for child in a ])

2218

2219 - def test_setslice_all_replace_reversed_ns2(self):

2220 Element = self.etree.Element 2221 SubElement = self.etree.SubElement 2222 2223 a = Element('{ns}a') 2224 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 2225 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 2226 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 2227 2228 s = [d, c, b] 2229 a[:] = s 2230 self.assertEquals( 2231 [d, c, b], 2232 list(a)) 2233 self.assertEquals( 2234 ['{ns3}d', '{ns2}c', '{ns1}b'], 2235 [ child.tag for child in a ]) 2236 2237 self.assertEquals( 2238 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 2239 [ list(child.attrib.keys()) for child in a ])

2240

2241 - def test_setslice_end(self):

2242 Element = self.etree.Element 2243 SubElement = self.etree.SubElement 2244 2245 a = Element('a') 2246 b = SubElement(a, 'b') 2247 c = SubElement(a, 'c') 2248 2249 e = Element('e') 2250 f = Element('f') 2251 g = Element('g') 2252 h = Element('h') 2253 2254 s = [e, f] 2255 a[99:] = s 2256 self.assertEquals( 2257 [a, b, e, f], 2258 list(a)) 2259 2260 s = [g, h] 2261 a[:0] = s 2262 self.assertEquals( 2263 [g, h, a, b, e, f], 2264 list(a))

2265

2266 - def test_setslice_single(self):

2267 Element = self.etree.Element 2268 SubElement = self.etree.SubElement 2269 2270 a = Element('a') 2271 b = SubElement(a, 'b') 2272 c = SubElement(a, 'c') 2273 2274 e = Element('e') 2275 f = Element('f') 2276 2277 s = [e] 2278 a[0:1] = s 2279 self.assertEquals( 2280 [e, c], 2281 list(a)) 2282 2283 s = [f] 2284 a[1:2] = s 2285 self.assertEquals( 2286 [e, f], 2287 list(a))

2288

2289 - def test_setslice_tail(self):

2290 ElementTree = self.etree.ElementTree 2291 Element = self.etree.Element 2292 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2293 doc = ElementTree(file=f) 2294 a = doc.getroot() 2295 x = Element('x') 2296 y = Element('y') 2297 z = Element('z') 2298 x.tail = 'X2' 2299 y.tail = 'Y2' 2300 z.tail = 'Z2' 2301 a[1:3] = [x, y, z] 2302 self.assertXML( 2303 _bytes('<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 2304 a)

2305

2306 - def test_setslice_negative(self):

2307 Element = self.etree.Element 2308 SubElement = self.etree.SubElement 2309 2310 a = Element('a') 2311 b = SubElement(a, 'b') 2312 c = SubElement(a, 'c') 2313 d = SubElement(a, 'd') 2314 2315 x = Element('x') 2316 y = Element('y') 2317 2318 a[1:-1] = [x, y] 2319 self.assertEquals( 2320 [b, x, y, d], 2321 list(a))

2322

2323 - def test_setslice_negative2(self):

2324 Element = self.etree.Element 2325 SubElement = self.etree.SubElement 2326 2327 a = Element('a') 2328 b = SubElement(a, 'b') 2329 c = SubElement(a, 'c') 2330 d = SubElement(a, 'd') 2331 2332 x = Element('x') 2333 y = Element('y') 2334 2335 a[1:-2] = [x, y] 2336 self.assertEquals( 2337 [b, x, y, c, d], 2338 list(a))

2339

2340 - def test_setslice_end(self):

2341 Element = self.etree.Element 2342 SubElement = self.etree.SubElement 2343 2344 a = Element('a') 2345 b = SubElement(a, 'b') 2346 c = SubElement(a, 'c') 2347 d = SubElement(a, 'd') 2348 2349 e = Element('e') 2350 f = Element('f') 2351 g = Element('g') 2352 2353 s = [e, f, g] 2354 a[3:] = s 2355 self.assertEquals( 2356 [b, c, d, e, f, g], 2357 list(a))

2358

2359 - def test_setslice_empty(self):

2360 Element = self.etree.Element 2361 2362 a = Element('a') 2363 2364 b = Element('b') 2365 c = Element('c') 2366 2367 a[:] = [b, c] 2368 self.assertEquals( 2369 [b, c], 2370 list(a))

2371

2372 - def test_tail_elementtree_root(self):

2373 Element = self.etree.Element 2374 ElementTree = self.etree.ElementTree 2375 2376 a = Element('a') 2377 a.tail = 'A2' 2378 t = ElementTree(element=a) 2379 self.assertEquals('A2', 2380 a.tail)

2381

2382 - def test_elementtree_getiterator(self):

2383 Element = self.etree.Element 2384 SubElement = self.etree.SubElement 2385 ElementTree = self.etree.ElementTree 2386 2387 a = Element('a') 2388 b = SubElement(a, 'b') 2389 c = SubElement(a, 'c') 2390 d = SubElement(b, 'd') 2391 e = SubElement(c, 'e') 2392 t = ElementTree(element=a) 2393 2394 self.assertEquals( 2395 [a, b, d, c, e], 2396 list(t.getiterator()))

2397

2398 - def test_elementtree_getiterator_filter(self):

2399 Element = self.etree.Element 2400 SubElement = self.etree.SubElement 2401 ElementTree = self.etree.ElementTree 2402 a = Element('a') 2403 b = SubElement(a, 'b') 2404 c = SubElement(a, 'c') 2405 d = SubElement(b, 'd') 2406 e = SubElement(c, 'e') 2407 t = ElementTree(element=a) 2408 2409 self.assertEquals( 2410 [a], 2411 list(t.getiterator('a'))) 2412 a2 = SubElement(e, 'a') 2413 self.assertEquals( 2414 [a, a2], 2415 list(t.getiterator('a')))

2416

2417 - def test_ns_access(self):

2418 ElementTree = self.etree.ElementTree 2419 ns = 'http://xml.infrae.com/1' 2420 f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2421 t = ElementTree(file=f) 2422 a = t.getroot() 2423 self.assertEquals('{%s}a' % ns, 2424 a.tag) 2425 self.assertEquals('{%s}b' % ns, 2426 a[0].tag)

2427

2428 - def test_ns_access2(self):

2429 ElementTree = self.etree.ElementTree 2430 ns = 'http://xml.infrae.com/1' 2431 ns2 = 'http://xml.infrae.com/2' 2432 f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2433 t = ElementTree(file=f) 2434 a = t.getroot() 2435 self.assertEquals('{%s}a' % ns, 2436 a.tag) 2437 self.assertEquals('{%s}b' % ns, 2438 a[0].tag) 2439 self.assertEquals('{%s}b' % ns2, 2440 a[1].tag)

2441

2442 - def test_ns_setting(self):

2443 Element = self.etree.Element 2444 SubElement = self.etree.SubElement 2445 ns = 'http://xml.infrae.com/1' 2446 ns2 = 'http://xml.infrae.com/2' 2447 a = Element('{%s}a' % ns) 2448 b = SubElement(a, '{%s}b' % ns2) 2449 c = SubElement(a, '{%s}c' % ns) 2450 self.assertEquals('{%s}a' % ns, 2451 a.tag) 2452 self.assertEquals('{%s}b' % ns2, 2453 b.tag) 2454 self.assertEquals('{%s}c' % ns, 2455 c.tag) 2456 self.assertEquals('{%s}a' % ns, 2457 a.tag) 2458 self.assertEquals('{%s}b' % ns2, 2459 b.tag) 2460 self.assertEquals('{%s}c' % ns, 2461 c.tag)

2462

2463 - def test_ns_tag_parse(self):

2464 Element = self.etree.Element 2465 SubElement = self.etree.SubElement 2466 ElementTree = self.etree.ElementTree 2467 2468 ns = 'http://xml.infrae.com/1' 2469 ns2 = 'http://xml.infrae.com/2' 2470 f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2471 t = ElementTree(file=f) 2472 2473 a = t.getroot() 2474 self.assertEquals('{%s}a' % ns, 2475 a.tag) 2476 self.assertEquals('{%s}b' % ns2, 2477 a[0].tag) 2478 self.assertEquals('{%s}b' % ns, 2479 a[1].tag)

2480

2481 - def test_ns_attr(self):

2482 Element = self.etree.Element 2483 ns = 'http://xml.infrae.com/1' 2484 ns2 = 'http://xml.infrae.com/2' 2485 a = Element('a') 2486 a.set('{%s}foo' % ns, 'Foo') 2487 a.set('{%s}bar' % ns2, 'Bar') 2488 self.assertEquals( 2489 'Foo', 2490 a.get('{%s}foo' % ns)) 2491 self.assertEquals( 2492 'Bar', 2493 a.get('{%s}bar' % ns2)) 2494 try: 2495 self.assertXML( 2496 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 2497 a) 2498 except AssertionError: 2499 self.assertXML( 2500 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 2501 a)

2502

2503 - def test_ns_move(self):

2504 Element = self.etree.Element 2505 one = self.etree.fromstring( 2506 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2507 baz = one[0][0] 2508 2509 two = Element('root') 2510 two.append(baz) 2511 # removing the originating document could cause a crash/error before 2512 # as namespace is not moved along with it 2513 del one, baz 2514 self.assertEquals('{http://a.b.c}baz', two[0].tag)

2515

2516 - def test_ns_decl_tostring(self):

2517 tostring = self.etree.tostring 2518 root = self.etree.XML( 2519 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2520 baz = root[0][0] 2521 2522 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2523 tostring(baz)) 2524 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2525

2526 - def test_ns_decl_tostring_default(self):

2527 tostring = self.etree.tostring 2528 root = self.etree.XML( 2529 _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 2530 baz = root[0][0] 2531 2532 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2533 tostring(baz)) 2534 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2535

2536 - def test_ns_decl_tostring_root(self):

2537 tostring = self.etree.tostring 2538 root = self.etree.XML( 2539 _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')) 2540 baz = root[0][0] 2541 2542 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2543 tostring(baz)) 2544 2545 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2546

2547 - def test_ns_decl_tostring_element(self):

2548 Element = self.etree.Element 2549 SubElement = self.etree.SubElement 2550 2551 root = Element("foo") 2552 bar = SubElement(root, "{http://a.b.c}bar") 2553 baz = SubElement(bar, "{http://a.b.c}baz") 2554 2555 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2556 self.etree.tostring(baz)) 2557 2558 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2559

2560 - def test_attribute_xmlns_move(self):

2561 Element = self.etree.Element 2562 2563 root = Element('element') 2564 2565 subelement = Element('subelement', 2566 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2567 self.assertEquals(1, len(subelement.attrib)) 2568 self.assertEquals( 2569 "foo", 2570 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2571 2572 root.append(subelement) 2573 self.assertEquals(1, len(subelement.attrib)) 2574 self.assertEquals( 2575 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 2576 list(subelement.attrib.items())) 2577 self.assertEquals( 2578 "foo", 2579 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2580

2581 - def test_namespaces_after_serialize(self):

2582 parse = self.etree.parse 2583 tostring = self.etree.tostring 2584 2585 ns_href = "http://a.b.c" 2586 one = parse( 2587 BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2588 baz = one.getroot()[0][0] 2589 2590 parsed = parse(BytesIO( tostring(baz) )).getroot() 2591 self.assertEquals('{%s}baz' % ns_href, parsed.tag)

2592

2593 - def test_attribute_namespace_roundtrip(self):

2594 fromstring = self.etree.fromstring 2595 tostring = self.etree.tostring 2596 2597 ns_href = "http://a.b.c" 2598 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2599 ns_href,ns_href)) 2600 root = fromstring(xml) 2601 self.assertEquals('test', root[0].get('{%s}a' % ns_href)) 2602 2603 xml2 = tostring(root) 2604 self.assertTrue(_bytes(':a=') in xml2, xml2) 2605 2606 root2 = fromstring(xml2) 2607 self.assertEquals('test', root2[0].get('{%s}a' % ns_href))

2608

2609 - def test_attribute_namespace_roundtrip_replaced(self):

2610 fromstring = self.etree.fromstring 2611 tostring = self.etree.tostring 2612 2613 ns_href = "http://a.b.c" 2614 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2615 ns_href,ns_href)) 2616 root = fromstring(xml) 2617 self.assertEquals('test', root[0].get('{%s}a' % ns_href)) 2618 2619 root[0].set('{%s}a' % ns_href, 'TEST') 2620 2621 xml2 = tostring(root) 2622 self.assertTrue(_bytes(':a=') in xml2, xml2) 2623 2624 root2 = fromstring(xml2) 2625 self.assertEquals('TEST', root2[0].get('{%s}a' % ns_href))

2626 2627 required_versions_ET['test_register_namespace'] = (1,3)

2628 - def test_register_namespace(self):

2629 # ET 1.3+ 2630 Element = self.etree.Element 2631 prefix = 'TESTPREFIX' 2632 namespace = 'http://seriously.unknown/namespace/URI' 2633 2634 el = Element('{%s}test' % namespace) 2635 self.assertEquals(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 2636 self._writeElement(el)) 2637 2638 self.etree.register_namespace(prefix, namespace) 2639 el = Element('{%s}test' % namespace) 2640 self.assertEquals(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 2641 prefix, prefix, namespace, prefix)), 2642 self._writeElement(el)) 2643 2644 self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace)

2645

2646 - def test_tostring(self):

2647 tostring = self.etree.tostring 2648 Element = self.etree.Element 2649 SubElement = self.etree.SubElement 2650 2651 a = Element('a') 2652 b = SubElement(a, 'b') 2653 c = SubElement(a, 'c') 2654 2655 self.assertEquals(_bytes('<a><c></c></a>'), 2656 canonicalize(tostring(a)))

2657

2658 - def test_tostring_element(self):

2659 tostring = self.etree.tostring 2660 Element = self.etree.Element 2661 SubElement = self.etree.SubElement 2662 2663 a = Element('a') 2664 b = SubElement(a, 'b') 2665 c = SubElement(a, 'c') 2666 d = SubElement(c, 'd') 2667 self.assertEquals(_bytes(''), 2668 canonicalize(tostring(b))) 2669 self.assertEquals(_bytes('<c><d></d></c>'), 2670 canonicalize(tostring(c)))

2671

2672 - def test_tostring_element_tail(self):

2673 tostring = self.etree.tostring 2674 Element = self.etree.Element 2675 SubElement = self.etree.SubElement 2676 2677 a = Element('a') 2678 b = SubElement(a, 'b') 2679 c = SubElement(a, 'c') 2680 d = SubElement(c, 'd') 2681 b.tail = 'Foo' 2682 2683 self.assert_(tostring(b) == _bytes('Foo') or 2684 tostring(b) == _bytes('Foo'))

2685 2686 required_versions_ET['test_tostring_method_html'] = (1,3)

2687 - def test_tostring_method_html(self):

2688 tostring = self.etree.tostring 2689 Element = self.etree.Element 2690 SubElement = self.etree.SubElement 2691 2692 html = Element('html') 2693 body = SubElement(html, 'body') 2694 p = SubElement(body, 'p') 2695 p.text = "html" 2696 SubElement(p, 'br').tail = "test" 2697 2698 self.assertEquals(_bytes('<html><body>html test</body></html>'), 2699 tostring(html, method="html"))

2700 2701 required_versions_ET['test_tostring_method_text'] = (1,3)

2702 - def test_tostring_method_text(self):

2703 tostring = self.etree.tostring 2704 Element = self.etree.Element 2705 SubElement = self.etree.SubElement 2706 2707 a = Element('a') 2708 a.text = "A" 2709 a.tail = "tail" 2710 b = SubElement(a, 'b') 2711 b.text = "B" 2712 b.tail = "TAIL" 2713 c = SubElement(a, 'c') 2714 c.text = "C" 2715 2716 self.assertEquals(_bytes('ABTAILCtail'), 2717 tostring(a, method="text"))

2718

2719 - def test_iterparse(self):

2720 iterparse = self.etree.iterparse 2721 f = BytesIO('<a><c/></a>') 2722 2723 iterator = iterparse(f) 2724 self.assertEquals(None, 2725 iterator.root) 2726 events = list(iterator) 2727 root = iterator.root 2728 self.assertEquals( 2729 [('end', root[0]), ('end', root[1]), ('end', root)], 2730 events)

2731

2732 - def test_iterparse_file(self):

2733 iterparse = self.etree.iterparse 2734 iterator = iterparse(fileInTestDir("test.xml")) 2735 self.assertEquals(None, 2736 iterator.root) 2737 events = list(iterator) 2738 root = iterator.root 2739 self.assertEquals( 2740 [('end', root[0]), ('end', root)], 2741 events)

2742

2743 - def test_iterparse_start(self):

2744 iterparse = self.etree.iterparse 2745 f = BytesIO('<a><c/></a>') 2746 2747 iterator = iterparse(f, events=('start',)) 2748 events = list(iterator) 2749 root = iterator.root 2750 self.assertEquals( 2751 [('start', root), ('start', root[0]), ('start', root[1])], 2752 events)

2753

2754 - def test_iterparse_start_end(self):

2755 iterparse = self.etree.iterparse 2756 f = BytesIO('<a><c/></a>') 2757 2758 iterator = iterparse(f, events=('start','end')) 2759 events = list(iterator) 2760 root = iterator.root 2761 self.assertEquals( 2762 [('start', root), ('start', root[0]), ('end', root[0]), 2763 ('start', root[1]), ('end', root[1]), ('end', root)], 2764 events)

2765

2766 - def test_iterparse_clear(self):

2767 iterparse = self.etree.iterparse 2768 f = BytesIO('<a><c/></a>') 2769 2770 iterator = iterparse(f) 2771 for event, elem in iterator: 2772 elem.clear() 2773 2774 root = iterator.root 2775 self.assertEquals(0, 2776 len(root))

2777

2778 - def test_iterparse_large(self):

2779 iterparse = self.etree.iterparse 2780 CHILD_COUNT = 12345 2781 f = BytesIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2782 2783 i = 0 2784 for key in iterparse(f): 2785 event, element = key 2786 i += 1 2787 self.assertEquals(i, CHILD_COUNT + 1)

2788

2789 - def test_iterparse_attrib_ns(self):

2790 iterparse = self.etree.iterparse 2791 f = BytesIO('<a xmlns="http://ns1/"><c xmlns="http://ns2/"/></a>') 2792 2793 attr_name = '{http://testns/}bla' 2794 events = [] 2795 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2796 for event, elem in iterator: 2797 events.append(event) 2798 if event == 'start': 2799 if elem.tag != '{http://ns1/}a': 2800 elem.set(attr_name, 'value') 2801 2802 self.assertEquals( 2803 ['start-ns', 'start', 'start', 'start-ns', 'start', 2804 'end', 'end-ns', 'end', 'end', 'end-ns'], 2805 events) 2806 2807 root = iterator.root 2808 self.assertEquals( 2809 None, 2810 root.get(attr_name)) 2811 self.assertEquals( 2812 'value', 2813 root[0].get(attr_name))

2814

2815 - def test_iterparse_getiterator(self):

2816 iterparse = self.etree.iterparse 2817 f = BytesIO('<a><d/><c/></a>') 2818 2819 counts = [] 2820 for event, elem in iterparse(f): 2821 counts.append(len(list(elem.getiterator()))) 2822 self.assertEquals( 2823 [1,2,1,4], 2824 counts)

2825

2826 - def test_iterparse_move_elements(self):

2827 iterparse = self.etree.iterparse 2828 f = BytesIO('<a><d/><c/></a>') 2829 2830 for event, node in etree.iterparse(f): pass 2831 2832 root = etree.Element('new_root', {}) 2833 root[:] = node[:] 2834 2835 self.assertEquals( 2836 ['b', 'c'], 2837 [ el.tag for el in root ])

2838

2839 - def test_iterparse_cdata(self):

2840 tostring = self.etree.tostring 2841 f = BytesIO('<root><![CDATA[test]]></root>') 2842 context = self.etree.iterparse(f) 2843 content = [ el.text for event,el in context ] 2844 2845 self.assertEquals(['test'], content) 2846 self.assertEquals(_bytes('<root>test</root>'), 2847 tostring(context.root))

2848

2849 - def test_parse_file(self):

2850 parse = self.etree.parse 2851 # from file 2852 tree = parse(fileInTestDir('test.xml')) 2853 self.assertXML( 2854 _bytes('<a></a>'), 2855 tree.getroot())

2856

2857 - def test_parse_file_nonexistent(self):

2858 parse = self.etree.parse 2859 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2860

2861 - def test_parse_error_none(self):

2862 parse = self.etree.parse 2863 self.assertRaises(TypeError, parse, None)

2864 2865 required_versions_ET['test_parse_error'] = (1,3)

2866 - def test_parse_error(self):

2867 # ET < 1.3 raises ExpatError 2868 parse = self.etree.parse 2869 f = BytesIO('<a></c></a>') 2870 self.assertRaises(SyntaxError, parse, f) 2871 f.close()

2872 2873 required_versions_ET['test_parse_error_from_file'] = (1,3)

2874 - def test_parse_error_from_file(self):

2875 parse = self.etree.parse 2876 # from file 2877 f = open(fileInTestDir('test_broken.xml'), 'rb') 2878 self.assertRaises(SyntaxError, parse, f) 2879 f.close()

2880

2881 - def test_parse_file_object(self):

2882 parse = self.etree.parse 2883 # from file object 2884 f = open(fileInTestDir('test.xml'), 'rb') 2885 tree = parse(f) 2886 f.close() 2887 self.assertXML( 2888 _bytes('<a></a>'), 2889 tree.getroot())

2890

2891 - def test_parse_stringio(self):

2892 parse = self.etree.parse 2893 f = BytesIO('<a></a>') 2894 tree = parse(f) 2895 f.close() 2896 self.assertXML( 2897 _bytes('<a></a>'), 2898 tree.getroot() 2899 )

2900

2901 - def test_parse_cdata(self):

2902 tostring = self.etree.tostring 2903 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 2904 2905 self.assertEquals('test', root.text) 2906 self.assertEquals(_bytes('<root>test</root>'), 2907 tostring(root))

2908

2909 - def test_parse_with_encoding(self):

2910 # this can fail in libxml2 <= 2.6.22 2911 parse = self.etree.parse 2912 tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2913 self.assertXML(_bytes('<html></html>'), 2914 tree.getroot())

2915

2916 - def test_encoding(self):

2917 Element = self.etree.Element 2918 2919 a = Element('a') 2920 a.text = _str('Søk på nettet') 2921 self.assertXML( 2922 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2923 a, 'utf-8')

2924

2925 - def test_encoding_exact(self):

2926 ElementTree = self.etree.ElementTree 2927 Element = self.etree.Element 2928 2929 a = Element('a') 2930 a.text = _str('Søk på nettet') 2931 2932 f = BytesIO() 2933 tree = ElementTree(element=a) 2934 tree.write(f, encoding='utf-8') 2935 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'), 2936 f.getvalue().replace(_bytes('\n'),_bytes('')))

2937

2938 - def test_parse_file_encoding(self):

2939 parse = self.etree.parse 2940 # from file 2941 tree = parse(fileInTestDir('test-string.xml')) 2942 self.assertXML( 2943 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2944 tree.getroot(), 'UTF-8')

2945

2946 - def test_parse_file_object_encoding(self):

2947 parse = self.etree.parse 2948 # from file object 2949 f = open(fileInTestDir('test-string.xml'), 'rb') 2950 tree = parse(f) 2951 f.close() 2952 self.assertXML( 2953 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2954 tree.getroot(), 'UTF-8')

2955

2956 - def test_encoding_8bit_latin1(self):

2957 ElementTree = self.etree.ElementTree 2958 Element = self.etree.Element 2959 2960 a = Element('a') 2961 a.text = _str('Søk på nettet') 2962 2963 f = BytesIO() 2964 tree = ElementTree(element=a) 2965 tree.write(f, encoding='iso-8859-1') 2966 result = f.getvalue() 2967 declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 2968 self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 2969 result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 2970 self.assertEquals(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 2971 result)

2972 2973 required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3)

2974 - def test_parse_encoding_8bit_explicit(self):

2975 XMLParser = self.etree.XMLParser 2976 2977 text = _str('Søk på nettet') 2978 xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 2979 2980 self.assertRaises(self.etree.ParseError, 2981 self.etree.parse, 2982 BytesIO(xml_latin1)) 2983 2984 tree = self.etree.parse(BytesIO(xml_latin1), 2985 XMLParser(encoding="iso-8859-1")) 2986 a = tree.getroot() 2987 self.assertEquals(a.text, text)

2988 2989 required_versions_ET['test_parse_encoding_8bit_override'] = (1,3)

2990 - def test_parse_encoding_8bit_override(self):

2991 XMLParser = self.etree.XMLParser 2992 2993 text = _str('Søk på nettet') 2994 wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>") 2995 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 2996 ).encode('iso-8859-1') 2997 2998 self.assertRaises(self.etree.ParseError, 2999 self.etree.parse, 3000 BytesIO(xml_latin1)) 3001 3002 tree = self.etree.parse(BytesIO(xml_latin1), 3003 XMLParser(encoding="iso-8859-1")) 3004 a = tree.getroot() 3005 self.assertEquals(a.text, text)

3006

3007 - def _test_wrong_unicode_encoding(self):

3008 # raise error on wrong encoding declaration in unicode strings 3009 XML = self.etree.XML 3010 test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') + 3011 _str('<a>Søk på nettet</a>')) 3012 self.assertRaises(SyntaxError, XML, test_utf)

3013

3014 - def test_encoding_write_default_encoding(self):

3015 ElementTree = self.etree.ElementTree 3016 Element = self.etree.Element 3017 3018 a = Element('a') 3019 a.text = _str('Søk på nettet') 3020 3021 f = BytesIO() 3022 tree = ElementTree(element=a) 3023 tree.write(f) 3024 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 3025 self.assertEquals( 3026 _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 3027 data)

3028

3029 - def test_encoding_tostring(self):

3030 Element = self.etree.Element 3031 tostring = self.etree.tostring 3032 3033 a = Element('a') 3034 a.text = _str('Søk på nettet') 3035 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'), 3036 tostring(a, encoding='utf-8'))

3037

3038 - def test_encoding_tostring_unknown(self):

3039 Element = self.etree.Element 3040 tostring = self.etree.tostring 3041 3042 a = Element('a') 3043 a.text = _str('Søk på nettet') 3044 self.assertRaises(LookupError, tostring, a, 3045 encoding='Invalid Encoding')

3046

3047 - def test_encoding_tostring_sub(self):

3048 Element = self.etree.Element 3049 SubElement = self.etree.SubElement 3050 tostring = self.etree.tostring 3051 3052 a = Element('a') 3053 b = SubElement(a, 'b') 3054 b.text = _str('Søk på nettet') 3055 self.assertEquals(_str('Søk på nettet').encode('UTF-8'), 3056 tostring(b, encoding='utf-8'))

3057

3058 - def test_encoding_tostring_sub_tail(self):

3059 Element = self.etree.Element 3060 SubElement = self.etree.SubElement 3061 tostring = self.etree.tostring 3062 3063 a = Element('a') 3064 b = SubElement(a, 'b') 3065 b.text = _str('Søk på nettet') 3066 b.tail = _str('Søk') 3067 self.assertEquals(_str('Søk på nettetSøk').encode('UTF-8'), 3068 tostring(b, encoding='utf-8'))

3069

3070 - def test_encoding_tostring_default_encoding(self):

3071 Element = self.etree.Element 3072 SubElement = self.etree.SubElement 3073 tostring = self.etree.tostring 3074 3075 a = Element('a') 3076 a.text = _str('Søk på nettet') 3077 3078 expected = _bytes('<a>Søk på nettet</a>') 3079 self.assertEquals( 3080 expected, 3081 tostring(a))

3082

3083 - def test_encoding_sub_tostring_default_encoding(self):

3084 Element = self.etree.Element 3085 SubElement = self.etree.SubElement 3086 tostring = self.etree.tostring 3087 3088 a = Element('a') 3089 b = SubElement(a, 'b') 3090 b.text = _str('Søk på nettet') 3091 3092 expected = _bytes('Søk på nettet') 3093 self.assertEquals( 3094 expected, 3095 tostring(b))

3096

3097 - def test_encoding_8bit_xml(self):

3098 utext = _str('Søk på nettet') 3099 uxml = _str('%s') % utext 3100 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3101 isoxml = prologue + uxml.encode('iso-8859-1') 3102 tree = self.etree.XML(isoxml) 3103 self.assertEquals(utext, tree.text)

3104

3105 - def test_encoding_utf8_bom(self):

3106 utext = _str('Søk på nettet') 3107 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 3108 _str('%s') % utext) 3109 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 3110 xml = bom + uxml.encode("utf-8") 3111 tree = etree.XML(xml) 3112 self.assertEquals(utext, tree.text)

3113

3114 - def test_encoding_8bit_parse_stringio(self):

3115 utext = _str('Søk på nettet') 3116 uxml = _str('%s') % utext 3117 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3118 isoxml = prologue + uxml.encode('iso-8859-1') 3119 el = self.etree.parse(BytesIO(isoxml)).getroot() 3120 self.assertEquals(utext, el.text)

3121

3122 - def test_deepcopy_elementtree(self):

3123 Element = self.etree.Element 3124 ElementTree = self.etree.ElementTree 3125 3126 a = Element('a') 3127 a.text = "Foo" 3128 atree = ElementTree(a) 3129 3130 btree = copy.deepcopy(atree) 3131 self.assertEqual("Foo", atree.getroot().text) 3132 self.assertEqual("Foo", btree.getroot().text) 3133 self.assertFalse(btree is atree) 3134 self.assertFalse(btree.getroot() is atree.getroot())

3135

3136 - def test_deepcopy(self):

3137 Element = self.etree.Element 3138 3139 a = Element('a') 3140 a.text = 'Foo' 3141 3142 b = copy.deepcopy(a) 3143 self.assertEquals('Foo', b.text) 3144 3145 b.text = 'Bar' 3146 self.assertEquals('Bar', b.text) 3147 self.assertEquals('Foo', a.text) 3148 3149 del a 3150 self.assertEquals('Bar', b.text)

3151

3152 - def test_deepcopy_tail(self):

3153 Element = self.etree.Element 3154 3155 a = Element('a') 3156 a.tail = 'Foo' 3157 3158 b = copy.deepcopy(a) 3159 self.assertEquals('Foo', b.tail) 3160 3161 b.tail = 'Bar' 3162 self.assertEquals('Bar', b.tail) 3163 self.assertEquals('Foo', a.tail) 3164 3165 del a 3166 self.assertEquals('Bar', b.tail)

3167

3168 - def test_deepcopy_subelement(self):

3169 Element = self.etree.Element 3170 SubElement = self.etree.SubElement 3171 3172 root = Element('root') 3173 a = SubElement(root, 'a') 3174 a.text = 'FooText' 3175 a.tail = 'FooTail' 3176 3177 b = copy.deepcopy(a) 3178 self.assertEquals('FooText', b.text) 3179 self.assertEquals('FooTail', b.tail) 3180 3181 b.text = 'BarText' 3182 b.tail = 'BarTail' 3183 self.assertEquals('BarTail', b.tail) 3184 self.assertEquals('FooTail', a.tail) 3185 self.assertEquals('BarText', b.text) 3186 self.assertEquals('FooText', a.text) 3187 3188 del a 3189 self.assertEquals('BarTail', b.tail) 3190 self.assertEquals('BarText', b.text)

3191

3192 - def test_deepcopy_namespaces(self):

3193 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 3194 <parent><node t:foo="bar" /></parent> 3195 </doc>''')) 3196 self.assertEquals( 3197 root[0][0].get('{tns}foo'), 3198 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3199 self.assertEquals( 3200 root[0][0].get('{tns}foo'), 3201 copy.deepcopy(root[0][0]).get('{tns}foo') )

3202

3203 - def test_deepcopy_append(self):

3204 # previously caused a crash 3205 Element = self.etree.Element 3206 tostring = self.etree.tostring 3207 3208 a = Element('a') 3209 b = copy.deepcopy(a) 3210 a.append( Element('C') ) 3211 b.append( Element('X') ) 3212 3213 self.assertEquals(_bytes('<a><C/></a>'), 3214 tostring(a).replace(_bytes(' '), _bytes(''))) 3215 self.assertEquals(_bytes('<a><X/></a>'), 3216 tostring(b).replace(_bytes(' '), _bytes('')))

3217

3218 - def test_deepcopy_comment(self):

3219 # previously caused a crash 3220 # not supported by ET < 1.3! 3221 Comment = self.etree.Comment 3222 3223 a = Comment("ONE") 3224 b = copy.deepcopy(a) 3225 b.text = "ANOTHER" 3226 3227 self.assertEquals('ONE', a.text) 3228 self.assertEquals('ANOTHER', b.text)

3229

3230 - def test_shallowcopy(self):

3231 Element = self.etree.Element 3232 3233 a = Element('a') 3234 a.text = 'Foo' 3235 3236 b = copy.copy(a) 3237 self.assertEquals('Foo', b.text) 3238 3239 b.text = 'Bar' 3240 self.assertEquals('Bar', b.text) 3241 self.assertEquals('Foo', a.text)

3242 # XXX ElementTree will share nodes, but lxml.etree won't.. 3243

3244 - def test_shallowcopy_elementtree(self):

3245 Element = self.etree.Element 3246 ElementTree = self.etree.ElementTree 3247 3248 a = Element('a') 3249 a.text = 'Foo' 3250 atree = ElementTree(a) 3251 3252 btree = copy.copy(atree) 3253 self.assertFalse(btree is atree) 3254 self.assert_(btree.getroot() is atree.getroot()) 3255 self.assertEquals('Foo', atree.getroot().text)

3256

3257 - def _test_element_boolean(self):

3258 # deprecated as of ET 1.3/lxml 2.0 3259 etree = self.etree 3260 e = etree.Element('foo') 3261 self.assertEquals(False, bool(e)) 3262 etree.SubElement(e, 'bar') 3263 self.assertEquals(True, bool(e)) 3264 e = etree.Element('foo') 3265 e.text = 'hey' 3266 self.assertEquals(False, bool(e)) 3267 e = etree.Element('foo') 3268 e.tail = 'bar' 3269 self.assertEquals(False, bool(e)) 3270 e = etree.Element('foo') 3271 e.set('bar', 'Bar') 3272 self.assertEquals(False, bool(e))

3273

3274 - def test_multiple_elementrees(self):

3275 etree = self.etree 3276 3277 a = etree.Element('a') 3278 b = etree.SubElement(a, 'b') 3279 3280 t = etree.ElementTree(a) 3281 self.assertEquals(self._rootstring(t), _bytes('<a></a>')) 3282 3283 t1 = etree.ElementTree(a) 3284 self.assertEquals(self._rootstring(t1), _bytes('<a></a>')) 3285 self.assertEquals(self._rootstring(t), _bytes('<a></a>')) 3286 3287 t2 = etree.ElementTree(b) 3288 self.assertEquals(self._rootstring(t2), _bytes('')) 3289 self.assertEquals(self._rootstring(t1), _bytes('<a></a>')) 3290 self.assertEquals(self._rootstring(t), _bytes('<a></a>'))

3291

3292 - def test_qname(self):

3293 etree = self.etree 3294 qname = etree.QName('myns', 'a') 3295 a1 = etree.Element(qname) 3296 a2 = etree.SubElement(a1, qname) 3297 self.assertEquals(a1.tag, "{myns}a") 3298 self.assertEquals(a2.tag, "{myns}a")

3299

3300 - def test_qname_cmp(self):

3301 etree = self.etree 3302 qname1 = etree.QName('myns', 'a') 3303 qname2 = etree.QName('myns', 'a') 3304 self.assertEquals(qname1, "{myns}a") 3305 self.assertEquals("{myns}a", qname2) 3306 self.assertEquals(qname1, qname1) 3307 self.assertEquals(qname1, qname2)

3308

3309 - def test_qname_attribute_getset(self):

3310 etree = self.etree 3311 qname = etree.QName('myns', 'a') 3312 3313 a = etree.Element(qname) 3314 a.set(qname, "value") 3315 3316 self.assertEquals(a.get(qname), "value") 3317 self.assertEquals(a.get("{myns}a"), "value")

3318

3319 - def test_qname_attrib(self):

3320 etree = self.etree 3321 qname = etree.QName('myns', 'a') 3322 3323 a = etree.Element(qname) 3324 a.attrib[qname] = "value" 3325 3326 self.assertEquals(a.attrib[qname], "value") 3327 self.assertEquals(a.attrib.get(qname), "value") 3328 3329 self.assertEquals(a.attrib["{myns}a"], "value") 3330 self.assertEquals(a.attrib.get("{myns}a"), "value")

3331

3332 - def test_qname_attribute_resolve(self):

3333 etree = self.etree 3334 qname = etree.QName('http://myns', 'a') 3335 a = etree.Element(qname) 3336 a.set(qname, qname) 3337 3338 self.assertXML( 3339 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3340 a)

3341

3342 - def test_qname_attribute_resolve_new(self):

3343 etree = self.etree 3344 qname = etree.QName('http://myns', 'a') 3345 a = etree.Element('a') 3346 a.set('a', qname) 3347 3348 self.assertXML( 3349 _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 3350 a)

3351

3352 - def test_qname_attrib_resolve(self):

3353 etree = self.etree 3354 qname = etree.QName('http://myns', 'a') 3355 a = etree.Element(qname) 3356 a.attrib[qname] = qname 3357 3358 self.assertXML( 3359 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3360 a)

3361

3362 - def test_parser_version(self):

3363 etree = self.etree 3364 parser = etree.XMLParser() 3365 if hasattr(parser, "version"): 3366 # ElementTree 1.3+, cET 3367 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

3368 3369 # feed parser interface 3370

3371 - def test_feed_parser_bytes(self):

3372 parser = self.etree.XMLParser() 3373 3374 parser.feed(_bytes('<?xml version=')) 3375 parser.feed(_bytes('"1.0"?><ro')) 3376 parser.feed(_bytes('ot><')) 3377 parser.feed(_bytes('a test="works"/')) 3378 parser.feed(_bytes('></root')) 3379 parser.feed(_bytes('>')) 3380 3381 root = parser.close() 3382 3383 self.assertEquals(root.tag, "root") 3384 self.assertEquals(root[0].tag, "a") 3385 self.assertEquals(root[0].get("test"), "works")

3386

3387 - def test_feed_parser_unicode(self):

3388 parser = self.etree.XMLParser() 3389 3390 parser.feed(_str('<ro')) 3391 parser.feed(_str('ot><')) 3392 parser.feed(_str('a test="works"/')) 3393 parser.feed(_str('></root')) 3394 parser.feed(_str('>')) 3395 3396 root = parser.close() 3397 3398 self.assertEquals(root.tag, "root") 3399 self.assertEquals(root[0].tag, "a") 3400 self.assertEquals(root[0].get("test"), "works")

3401 3402 required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)

3403 - def test_feed_parser_error_close_empty(self):

3404 ParseError = self.etree.ParseError 3405 parser = self.etree.XMLParser() 3406 self.assertRaises(ParseError, parser.close)

3407 3408 required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3)

3409 - def test_feed_parser_error_close_incomplete(self):

3410 ParseError = self.etree.ParseError 3411 parser = self.etree.XMLParser() 3412 3413 parser.feed('<?xml version=') 3414 parser.feed('"1.0"?><ro') 3415 3416 self.assertRaises(ParseError, parser.close)

3417 3418 required_versions_ET['test_feed_parser_error_broken'] = (1,3)

3419 - def test_feed_parser_error_broken(self):

3420 ParseError = self.etree.ParseError 3421 parser = self.etree.XMLParser() 3422 3423 parser.feed('<?xml version=') 3424 parser.feed('"1.0"?><ro') 3425 try: 3426 parser.feed('<><><><><><><') 3427 except ParseError: 3428 # can raise, but not required before close() 3429 pass 3430 3431 self.assertRaises(ParseError, parser.close)

3432 3433 required_versions_ET['test_feed_parser_error_position'] = (1,3)

3434 - def test_feed_parser_error_position(self):

3435 ParseError = self.etree.ParseError 3436 parser = self.etree.XMLParser() 3437 try: 3438 parser.close() 3439 except ParseError: 3440 e = sys.exc_info()[1] 3441 self.assertNotEquals(None, e.code) 3442 self.assertNotEquals(0, e.code) 3443 self.assert_(isinstance(e.position, tuple)) 3444 self.assert_(e.position >= (0, 0))

3445 3446 # parser target interface 3447 3448 required_versions_ET['test_parser_target_property'] = (1,3)

3449 - def test_parser_target_property(self):

3450 class Target(object): 3451 pass

3452 3453 target = Target() 3454 parser = self.etree.XMLParser(target=target) 3455 3456 self.assertEquals(target, parser.target) 3457

3458 - def test_parser_target_tag(self):

3459 assertEquals = self.assertEquals 3460 assertFalse = self.assertFalse 3461 3462 events = [] 3463 class Target(object): 3464 def start(self, tag, attrib): 3465 events.append("start") 3466 assertFalse(attrib) 3467 assertEquals("TAG", tag)

3468 def end(self, tag): 3469 events.append("end") 3470 assertEquals("TAG", tag) 3471 def close(self): 3472 return "DONE" 3473 3474 parser = self.etree.XMLParser(target=Target()) 3475 3476 parser.feed("<TAG/>") 3477 done = parser.close() 3478 3479 self.assertEquals("DONE", done) 3480 self.assertEquals(["start", "end"], events) 3481

3482 - def test_elementtree_parser_target(self):

3483 assertEquals = self.assertEquals 3484 assertFalse = self.assertFalse 3485 Element = self.etree.Element 3486 3487 events = [] 3488 class Target(object): 3489 def start(self, tag, attrib): 3490 events.append("start") 3491 assertFalse(attrib) 3492 assertEquals("TAG", tag)

3493 def end(self, tag): 3494 events.append("end") 3495 assertEquals("TAG", tag) 3496 def close(self): 3497 return Element("DONE") 3498 3499 parser = self.etree.XMLParser(target=Target()) 3500 tree = self.etree.ElementTree() 3501 tree.parse(BytesIO("<TAG/>"), parser=parser) 3502 3503 self.assertEquals("DONE", tree.getroot().tag) 3504 self.assertEquals(["start", "end"], events) 3505

3506 - def test_parser_target_attrib(self):

3507 assertEquals = self.assertEquals 3508 3509 events = [] 3510 class Target(object): 3511 def start(self, tag, attrib): 3512 events.append("start-" + tag) 3513 for name, value in attrib.items(): 3514 assertEquals(tag + name, value)

3515 def end(self, tag): 3516 events.append("end-" + tag) 3517 def close(self): 3518 return "DONE" 3519 3520 parser = self.etree.XMLParser(target=Target()) 3521 3522 parser.feed('<root a="roota" b="rootb"></root>') 3523 done = parser.close() 3524 3525 self.assertEquals("DONE", done) 3526 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3527 events) 3528

3529 - def test_parser_target_data(self):

3530 events = [] 3531 class Target(object): 3532 def start(self, tag, attrib): 3533 events.append("start-" + tag)

3534 def end(self, tag): 3535 events.append("end-" + tag) 3536 def data(self, data): 3537 events.append("data-" + data) 3538 def close(self): 3539 return "DONE" 3540 3541 parser = self.etree.XMLParser(target=Target()) 3542 3543 parser.feed('<root>AB</root>') 3544 done = parser.close() 3545 3546 self.assertEquals("DONE", done) 3547 self.assertEquals(["start-root", "data-A", "start-sub", 3548 "end-sub", "data-B", "end-root"], 3549 events) 3550

3551 - def test_parser_target_entity(self):

3552 events = [] 3553 class Target(object): 3554 def __init__(self): 3555 self._data = []

3556 def _flush_data(self): 3557 if self._data: 3558 events.append("data-" + ''.join(self._data)) 3559 del self._data[:] 3560 def start(self, tag, attrib): 3561 self._flush_data() 3562 events.append("start-" + tag) 3563 def end(self, tag): 3564 self._flush_data() 3565 events.append("end-" + tag) 3566 def data(self, data): 3567 self._data.append(data) 3568 def close(self): 3569 self._flush_data() 3570 return "DONE" 3571 3572 parser = self.etree.XMLParser(target=Target()) 3573 3574 dtd = ''' 3575 <!DOCTYPE root [ 3576 <!ELEMENT root (sub*)> 3577 <!ELEMENT sub (#PCDATA)> 3578 <!ENTITY ent "an entity"> 3579 ]> 3580 ''' 3581 parser.feed(dtd+'<root>this is &ent;</root>') 3582 done = parser.close() 3583 3584 self.assertEquals("DONE", done) 3585 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub", 3586 "data-this is an entity", 3587 "end-sub", "start-sub", "end-sub", "end-root"], 3588 events) 3589 3590 required_versions_ET['test_parser_target_entity_unknown'] = (1,3)

3591 - def test_parser_target_entity_unknown(self):

3592 events = [] 3593 class Target(object): 3594 def __init__(self): 3595 self._data = []

3596 def _flush_data(self): 3597 if self._data: 3598 events.append("data-" + ''.join(self._data)) 3599 del self._data[:] 3600 def start(self, tag, attrib): 3601 self._flush_data() 3602 events.append("start-" + tag) 3603 def end(self, tag): 3604 self._flush_data() 3605 events.append("end-" + tag) 3606 def data(self, data): 3607 self._data.append(data) 3608 def close(self): 3609 self._flush_data() 3610 return "DONE" 3611 3612 parser = self.etree.XMLParser(target=Target()) 3613 3614 def feed(): 3615 parser.feed('<root>some &ent;</root>') 3616 parser.close() 3617 3618 self.assertRaises(self.etree.ParseError, feed) 3619

3620 - def test_treebuilder(self):

3621 builder = self.etree.TreeBuilder() 3622 el = builder.start("root", {'a':'A', 'b':'B'}) 3623 self.assertEquals("root", el.tag) 3624 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3625 builder.data("ROOTTEXT") 3626 el = builder.start("child", {'x':'X', 'y':'Y'}) 3627 self.assertEquals("child", el.tag) 3628 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3629 builder.data("CHILDTEXT") 3630 el = builder.end("child") 3631 self.assertEquals("child", el.tag) 3632 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3633 self.assertEquals("CHILDTEXT", el.text) 3634 self.assertEquals(None, el.tail) 3635 builder.data("CHILDTAIL") 3636 root = builder.end("root") 3637 3638 self.assertEquals("root", root.tag) 3639 self.assertEquals("ROOTTEXT", root.text) 3640 self.assertEquals("CHILDTEXT", root[0].text) 3641 self.assertEquals("CHILDTAIL", root[0].tail)

3642

3643 - def test_treebuilder_target(self):

3644 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3645 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3646 root = parser.close() 3647 3648 self.assertEquals("root", root.tag) 3649 self.assertEquals("ROOTTEXT", root.text) 3650 self.assertEquals("CHILDTEXT", root[0].text) 3651 self.assertEquals("CHILDTAIL", root[0].tail)

3652 3653 # helper methods 3654

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

3656 """Write out element for comparison. 3657 """ 3658 data = self.etree.tostring(element, encoding=encoding) 3659 return canonicalize(data)

3660

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

3662 """Write out element for comparison, using real file. 3663 """ 3664 ElementTree = self.etree.ElementTree 3665 handle, filename = tempfile.mkstemp() 3666 try: 3667 f = open(filename, 'wb') 3668 tree = ElementTree(element=element) 3669 tree.write(f, encoding=encoding) 3670 f.close() 3671 f = open(filename, 'rb') 3672 data = f.read() 3673 f.close() 3674 finally: 3675 os.close(handle) 3676 os.remove(filename) 3677 return canonicalize(data)

3678

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

3680 """Writes element out and checks whether it is expected. 3681 3682 Does this two ways; once using BytesIO, once using a real file. 3683 """ 3684 if isinstance(expected, unicode): 3685 expected = expected.encode(encoding) 3686 self.assertEquals(expected, self._writeElement(element, encoding)) 3687 self.assertEquals(expected, self._writeElementFile(element, encoding))

3688

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

3690 "Checks if the result XML byte string specifies the encoding." 3691 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 3692 if isinstance(result, str): 3693 has_encoding = re.compile(enc_re).match 3694 else: 3695 has_encoding = re.compile(_bytes(enc_re)).match 3696 self.assert_(has_encoding(result)) 3697 result_encoding = has_encoding(result).group(1) 3698 self.assertEquals(result_encoding.upper(), encoding.upper())

3699

3700 - def _rootstring(self, tree):

3701 return self.etree.tostring(tree.getroot()).replace( 3702 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))

3703

3704 - def _check_element_tree(self, tree):

3705 self._check_element(tree.getroot())

3706

3707 - def _check_element(self, element):

3708 self.assert_(hasattr(element, 'tag')) 3709 self.assert_(hasattr(element, 'attrib')) 3710 self.assert_(hasattr(element, 'text')) 3711 self.assert_(hasattr(element, 'tail')) 3712 self._check_string(element.tag) 3713 self._check_mapping(element.attrib) 3714 if element.text != None: 3715 self._check_string(element.text) 3716 if element.tail != None: 3717 self._check_string(element.tail)

3718

3719 - def _check_string(self, string):

3720 len(string) 3721 for char in string: 3722 self.assertEquals(1, len(char)) 3723 new_string = string + "" 3724 new_string = string + " " 3725 string[:0]

3726

3727 - def _check_mapping(self, mapping):

3728 len(mapping) 3729 keys = mapping.keys() 3730 values = mapping.values() 3731 items = mapping.items() 3732 for key in keys: 3733 item = mapping[key] 3734 mapping["key"] = "value" 3735 self.assertEquals("value", mapping["key"])

3736 3737 3738 if etree:

3739 - class ETreeTestCase(_ETreeTestCaseBase):

3740 etree = etree

3741 3742 if ElementTree:

3743 - class ElementTreeTestCase(_ETreeTestCaseBase):

3744 etree = ElementTree

3745 3746 filter_by_version( 3747 ElementTreeTestCase, 3748 ElementTreeTestCase.required_versions_ET, ET_VERSION) 3749 3750 if cElementTree:

3751 - class CElementTreeTestCase(_ETreeTestCaseBase):

3752 etree = cElementTree

3753 3754 filter_by_version( 3755 CElementTreeTestCase, 3756 CElementTreeTestCase.required_versions_cET, CET_VERSION) 3757

3758 -def test_suite():

3759 suite = unittest.TestSuite() 3760 if etree: 3761 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3762 if ElementTree: 3763 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3764 if cElementTree: 3765 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3766 return suite

3767 3768 if __name__ == '__main__': 3769 print('to test use test.py %s' % __file__) 3770