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.assertEqual(e.tag, 'foo') 49 self.assertEqual(e.text, None) 50 self.assertEqual(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.assertEqual(3, len(root)) 60 self.assertEqual('one', root[0].tag) 61 self.assertEqual('two', root[1].tag) 62 self.assertEqual('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.assertEqual(root.tag, "root") 69 add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>')) 70 self.assertEqual(add.getroot().tag, "foo") 71 self.assertEqual(add.getroot().text, "Foo") 72 root.append(self.etree.Element('baz')) 73 self.assertEqual(root.tag, "root") 74 self.assertEqual(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.assertEqual(3, len(root)) 85 self.assertEqual('one', root[0].tag) 86 self.assertEqual('two', root[1].tag) 87 self.assertEqual('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.assertTrue(root1[0] in root1) 96 97 root2 = Element('root') 98 SubElement(root2, 'two') 99 SubElement(root2, 'three') 100 self.assertTrue(root2[0] in root2) 101 self.assertTrue(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.assertEqual(1, len(root)) 114 self.assertEqual('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.assertEqual(3, len(root)) 124 self.assertEqual('one', root[0].tag) 125 self.assertEqual('two', root[1].tag) 126 self.assertEqual('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.assertEqual(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.assertEqual(d, a[-1]) 144 self.assertEqual(c, a[-2]) 145 self.assertEqual(b, a[-3]) 146 self.assertRaises(IndexError, operator.getitem, a, -4) 147 a[-1] = e = Element('e') 148 self.assertEqual(e, a[-1]) 149 del a[-1] 150 self.assertEqual(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.assertEqual(2, len(root)) 159 self.assertEqual('one', root[0].tag) 160 self.assertEqual('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.assertEqual('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.assertEqual(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.assertEqual(None, root.text) 185 self.assertEqual('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.assertEqual('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.assertEqual(_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.assertEqual(1, len(root)) 230 self.assertEqual('This is ', root.text) 231 self.assertEqual(None, root.tail) 232 self.assertEqual('mixed', root[0].text) 233 self.assertEqual(' 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.assertEqual(1, len(root)) 253 self.assertEqual('This is ', root.text) 254 self.assertEqual(None, root.tail) 255 self.assertEqual('mixed', root[0].text) 256 self.assertEqual(' content.', root[0].tail) 257 258 del root[0].tail 259 260 self.assertEqual(1, len(root)) 261 self.assertEqual('This is ', root.text) 262 self.assertEqual(None, root.tail) 263 self.assertEqual('mixed', root[0].text) 264 self.assertEqual(None, root[0].tail) 265 266 root[0].tail = "TAIL" 267 268 self.assertEqual(1, len(root)) 269 self.assertEqual('This is ', root.text) 270 self.assertEqual(None, root.tail) 271 self.assertEqual('mixed', root[0].text) 272 self.assertEqual('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.assertEqual(None, root.text) 282 self.assertEqual('hoi', root.tag)

283

284 - def test_attrib(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.assertEqual('One', root.attrib['one']) 291 self.assertEqual('Two', root.attrib['two']) 292 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

293

294 - def test_attrib_get(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.assertEqual('One', root.attrib.get('one')) 301 self.assertEqual('Two', root.attrib.get('two')) 302 self.assertEqual(None, root.attrib.get('three')) 303 self.assertEqual('foo', root.attrib.get('three', 'foo'))

304

305 - def test_attrib_dict(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 attrib = dict(root.attrib) 312 self.assertEqual('One', attrib['one']) 313 self.assertEqual('Two', attrib['two']) 314 self.assertRaises(KeyError, operator.getitem, attrib, 'three')

315

316 - def test_attrib_copy(self):

317 ElementTree = self.etree.ElementTree 318 319 f = BytesIO('<doc one="One" two="Two"/>') 320 doc = ElementTree(file=f) 321 root = doc.getroot() 322 attrib = copy.copy(root.attrib) 323 self.assertEqual('One', attrib['one']) 324 self.assertEqual('Two', attrib['two']) 325 self.assertRaises(KeyError, operator.getitem, attrib, 'three')

326

327 - def test_attrib_deepcopy(self):

328 ElementTree = self.etree.ElementTree 329 330 f = BytesIO('<doc one="One" two="Two"/>') 331 doc = ElementTree(file=f) 332 root = doc.getroot() 333 attrib = copy.deepcopy(root.attrib) 334 self.assertEqual('One', attrib['one']) 335 self.assertEqual('Two', attrib['two']) 336 self.assertRaises(KeyError, operator.getitem, attrib, 'three')

337

338 - def test_attributes_get(self):

339 ElementTree = self.etree.ElementTree 340 341 f = BytesIO('<doc one="One" two="Two"/>') 342 doc = ElementTree(file=f) 343 root = doc.getroot() 344 self.assertEqual('One', root.get('one')) 345 self.assertEqual('Two', root.get('two')) 346 self.assertEqual(None, root.get('three')) 347 self.assertEqual('foo', root.get('three', 'foo'))

348

349 - def test_attrib_clear(self):

350 XML = self.etree.XML 351 352 root = XML(_bytes('<doc one="One" two="Two"/>')) 353 self.assertEqual('One', root.get('one')) 354 self.assertEqual('Two', root.get('two')) 355 root.attrib.clear() 356 self.assertEqual(None, root.get('one')) 357 self.assertEqual(None, root.get('two'))

358

359 - def test_attrib_set_clear(self):

360 Element = self.etree.Element 361 362 root = Element("root", one="One") 363 root.set("two", "Two") 364 self.assertEqual('One', root.get('one')) 365 self.assertEqual('Two', root.get('two')) 366 root.attrib.clear() 367 self.assertEqual(None, root.get('one')) 368 self.assertEqual(None, root.get('two'))

369

370 - def test_attrib_ns_clear(self):

371 Element = self.etree.Element 372 SubElement = self.etree.SubElement 373 374 attribNS = '{http://foo/bar}x' 375 376 parent = Element('parent') 377 parent.set(attribNS, 'a') 378 child = SubElement(parent, 'child') 379 child.set(attribNS, 'b') 380 381 self.assertEqual('a', parent.get(attribNS)) 382 self.assertEqual('b', child.get(attribNS)) 383 384 parent.clear() 385 self.assertEqual(None, parent.get(attribNS)) 386 self.assertEqual('b', child.get(attribNS))

387

388 - def test_attrib_pop(self):

389 ElementTree = self.etree.ElementTree 390 391 f = BytesIO('<doc one="One" two="Two"/>') 392 doc = ElementTree(file=f) 393 root = doc.getroot() 394 self.assertEqual('One', root.attrib['one']) 395 self.assertEqual('Two', root.attrib['two']) 396 397 self.assertEqual('One', root.attrib.pop('one')) 398 399 self.assertEqual(None, root.attrib.get('one')) 400 self.assertEqual('Two', root.attrib['two'])

401

402 - def test_attrib_pop_unknown(self):

403 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 404 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 405 406 self.assertEqual('One', root.attrib['one']) 407 self.assertEqual('Two', root.attrib['two'])

408

409 - def test_attrib_pop_default(self):

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

412

413 - def test_attrib_pop_empty_default(self):

414 root = self.etree.XML(_bytes('<doc/>')) 415 self.assertEqual('Three', root.attrib.pop('three', 'Three'))

416

417 - def test_attrib_pop_invalid_args(self):

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

420

421 - def test_attribute_update_dict(self):

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

438

439 - def test_attribute_update_sequence(self):

440 XML = self.etree.XML 441 442 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 443 items = list(root.attrib.items()) 444 items.sort() 445 self.assertEqual( 446 [('alpha', 'Alpha'), ('beta', 'Beta')], 447 items) 448 449 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 450 451 items = list(root.attrib.items()) 452 items.sort() 453 self.assertEqual( 454 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 455 items)

456

457 - def test_attribute_update_iter(self):

458 XML = self.etree.XML 459 460 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 461 items = list(root.attrib.items()) 462 items.sort() 463 self.assertEqual( 464 [('alpha', 'Alpha'), ('beta', 'Beta')], 465 items) 466 467 root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items())) 468 469 items = list(root.attrib.items()) 470 items.sort() 471 self.assertEqual( 472 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 473 items)

474

475 - def test_attribute_update_attrib(self):

476 XML = self.etree.XML 477 478 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 479 items = list(root.attrib.items()) 480 items.sort() 481 self.assertEqual( 482 [('alpha', 'Alpha'), ('beta', 'Beta')], 483 items) 484 485 other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>')) 486 root.attrib.update(other.attrib) 487 488 items = list(root.attrib.items()) 489 items.sort() 490 self.assertEqual( 491 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 492 items)

493

494 - def test_attribute_keys(self):

495 XML = self.etree.XML 496 497 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 498 keys = list(root.attrib.keys()) 499 keys.sort() 500 self.assertEqual(['alpha', 'beta', 'gamma'], keys)

501

502 - def test_attribute_keys2(self):

503 XML = self.etree.XML 504 505 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 506 keys = list(root.keys()) 507 keys.sort() 508 self.assertEqual(['alpha', 'beta', 'gamma'], keys)

509

510 - def test_attribute_items2(self):

511 XML = self.etree.XML 512 513 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 514 items = list(root.items()) 515 items.sort() 516 self.assertEqual( 517 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 518 items)

519

520 - def test_attribute_keys_ns(self):

521 XML = self.etree.XML 522 523 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 524 keys = list(root.keys()) 525 keys.sort() 526 self.assertEqual(['bar', '{http://ns.codespeak.net/test}baz'], 527 keys)

528

529 - def test_attribute_values(self):

530 XML = self.etree.XML 531 532 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 533 values = list(root.attrib.values()) 534 values.sort() 535 self.assertEqual(['Alpha', 'Beta', 'Gamma'], values)

536

537 - def test_attribute_values_ns(self):

538 XML = self.etree.XML 539 540 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 541 values = list(root.attrib.values()) 542 values.sort() 543 self.assertEqual( 544 ['Bar', 'Baz'], values)

545

546 - def test_attribute_items(self):

547 XML = self.etree.XML 548 549 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 550 items = list(root.attrib.items()) 551 items.sort() 552 self.assertEqual([ 553 ('alpha', 'Alpha'), 554 ('beta', 'Beta'), 555 ('gamma', 'Gamma'), 556 ], 557 items)

558

559 - def test_attribute_items_ns(self):

560 XML = self.etree.XML 561 562 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 563 items = list(root.attrib.items()) 564 items.sort() 565 self.assertEqual( 566 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 567 items)

568

569 - def test_attribute_str(self):

570 XML = self.etree.XML 571 572 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 573 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 574 575 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 576 try: 577 self.assertEqual(expected, str(root.attrib)) 578 except AssertionError: 579 self.assertEqual(alternative, str(root.attrib))

580

581 - def test_attribute_contains(self):

582 XML = self.etree.XML 583 584 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 585 self.assertEqual( 586 True, 'bar' in root.attrib) 587 self.assertEqual( 588 False, 'baz' in root.attrib) 589 self.assertEqual( 590 False, 'hah' in root.attrib) 591 self.assertEqual( 592 True, 593 '{http://ns.codespeak.net/test}baz' in root.attrib)

594

595 - def test_attribute_set(self):

596 Element = self.etree.Element 597 598 root = Element("root") 599 root.set("attr", "TEST") 600 self.assertEqual("TEST", root.get("attr"))

601

602 - def test_attribute_iterator(self):

603 XML = self.etree.XML 604 605 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 606 result = [] 607 for key in root.attrib: 608 result.append(key) 609 result.sort() 610 self.assertEqual(['alpha', 'beta', 'gamma'], result)

611

612 - def test_attribute_manipulation(self):

613 Element = self.etree.Element 614 615 a = Element('a') 616 a.attrib['foo'] = 'Foo' 617 a.attrib['bar'] = 'Bar' 618 self.assertEqual('Foo', a.attrib['foo']) 619 del a.attrib['foo'] 620 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

621

622 - def test_del_attribute_ns(self):

623 Element = self.etree.Element 624 625 a = Element('a') 626 a.attrib['{http://a/}foo'] = 'Foo' 627 a.attrib['{http://a/}bar'] = 'Bar' 628 self.assertEqual(None, a.get('foo')) 629 self.assertEqual('Foo', a.get('{http://a/}foo')) 630 self.assertEqual('Foo', a.attrib['{http://a/}foo']) 631 632 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 633 self.assertEqual('Foo', a.attrib['{http://a/}foo']) 634 635 del a.attrib['{http://a/}foo'] 636 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

637

638 - def test_del_attribute_ns_parsed(self):

639 XML = self.etree.XML 640 641 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 642 643 self.assertEqual('Foo', a.attrib['foo']) 644 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 645 646 del a.attrib['foo'] 647 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 648 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 649 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 650 651 del a.attrib['{http://a/}foo'] 652 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 653 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 654 655 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 656 657 self.assertEqual('Foo', a.attrib['foo']) 658 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 659 660 del a.attrib['foo'] 661 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 662 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 663 664 del a.attrib['{http://a/}foo'] 665 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 666 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

667

668 - def test_XML(self):

669 XML = self.etree.XML 670 671 root = XML(_bytes('<doc>This is a text.</doc>')) 672 self.assertEqual(0, len(root)) 673 self.assertEqual('This is a text.', root.text)

674

675 - def test_XMLID(self):

676 XMLID = self.etree.XMLID 677 XML = self.etree.XML 678 xml_text = _bytes(''' 679 <document> 680 <h1 id="chapter1">...</h1> 681 ... 682 Regular paragraph. 683 XML:ID paragraph. 684 ... 685 </document> 686 ''') 687 688 root, dic = XMLID(xml_text) 689 root2 = XML(xml_text) 690 self.assertEqual(self._writeElement(root), 691 self._writeElement(root2)) 692 expected = { 693 "chapter1" : root[0], 694 "note1" : root[1], 695 "warn1" : root[4] 696 } 697 self.assertEqual(dic, expected)

698

699 - def test_fromstring(self):

700 fromstring = self.etree.fromstring 701 702 root = fromstring('<doc>This is a text.</doc>') 703 self.assertEqual(0, len(root)) 704 self.assertEqual('This is a text.', root.text)

705 706 required_versions_ET['test_fromstringlist'] = (1,3)

707 - def test_fromstringlist(self):

708 fromstringlist = self.etree.fromstringlist 709 710 root = fromstringlist(["<do", "c>T", "hi", "s is", 711 " a text.<", "/doc", ">"]) 712 self.assertEqual(0, len(root)) 713 self.assertEqual('This is a text.', root.text)

714 715 required_versions_ET['test_fromstringlist_characters'] = (1,3)

716 - def test_fromstringlist_characters(self):

717 fromstringlist = self.etree.fromstringlist 718 719 root = fromstringlist(list('<doc>This is a text.</doc>')) 720 self.assertEqual(0, len(root)) 721 self.assertEqual('This is a text.', root.text)

722 723 required_versions_ET['test_fromstringlist_single'] = (1,3)

724 - def test_fromstringlist_single(self):

725 fromstringlist = self.etree.fromstringlist 726 727 root = fromstringlist(['<doc>This is a text.</doc>']) 728 self.assertEqual(0, len(root)) 729 self.assertEqual('This is a text.', root.text)

730

731 - def test_iselement(self):

732 iselement = self.etree.iselement 733 Element = self.etree.Element 734 ElementTree = self.etree.ElementTree 735 XML = self.etree.XML 736 Comment = self.etree.Comment 737 ProcessingInstruction = self.etree.ProcessingInstruction 738 739 el = Element('hoi') 740 self.assertTrue(iselement(el)) 741 742 el2 = XML(_bytes('<foo/>')) 743 self.assertTrue(iselement(el2)) 744 745 tree = ElementTree(element=Element('dag')) 746 self.assertTrue(not iselement(tree)) 747 self.assertTrue(iselement(tree.getroot())) 748 749 c = Comment('test') 750 self.assertTrue(iselement(c)) 751 752 p = ProcessingInstruction("test", "some text") 753 self.assertTrue(iselement(p))

754

755 - def test_iteration(self):

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

763

764 - def test_iteration_empty(self):

765 XML = self.etree.XML 766 767 root = XML(_bytes('<doc></doc>')) 768 result = [] 769 for el in root: 770 result.append(el.tag) 771 self.assertEqual([], result)

772

773 - def test_iteration_text_only(self):

774 XML = self.etree.XML 775 776 root = XML(_bytes('<doc>Text</doc>')) 777 result = [] 778 for el in root: 779 result.append(el.tag) 780 self.assertEqual([], result)

781

782 - def test_iteration_crash(self):

783 # this would cause a crash in the past 784 fromstring = self.etree.fromstring 785 root = etree.fromstring('<html>x</html>') 786 for elem in root: 787 elem.tail = ''

788

789 - def test_iteration_reversed(self):

790 XML = self.etree.XML 791 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 792 result = [] 793 for el in reversed(root): 794 result.append(el.tag) 795 self.assertEqual(['three', 'two', 'one'], result)

796

797 - def test_iteration_subelement(self):

798 XML = self.etree.XML 799 800 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 801 result = [] 802 add = True 803 for el in root: 804 result.append(el.tag) 805 if add: 806 self.etree.SubElement(root, 'four') 807 add = False 808 self.assertEqual(['one', 'two', 'three', 'four'], result)

809

810 - def test_iteration_del_child(self):

811 XML = self.etree.XML 812 813 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 814 result = [] 815 for el in root: 816 result.append(el.tag) 817 del root[-1] 818 self.assertEqual(['one', 'two'], result)

819

820 - def test_iteration_double(self):

821 XML = self.etree.XML 822 823 root = XML(_bytes('<doc><one/><two/></doc>')) 824 result = [] 825 for el0 in root: 826 result.append(el0.tag) 827 for el1 in root: 828 result.append(el1.tag) 829 self.assertEqual(['one','one', 'two', 'two', 'one', 'two'], result)

830 831 required_versions_ET['test_itertext'] = (1,3)

832 - def test_itertext(self):

833 # ET 1.3+ 834 XML = self.etree.XML 835 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 836 837 text = list(root.itertext()) 838 self.assertEqual(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 839 text)

840 841 required_versions_ET['test_itertext_child'] = (1,3)

842 - def test_itertext_child(self):

843 # ET 1.3+ 844 XML = self.etree.XML 845 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 846 847 text = list(root[2].itertext()) 848 self.assertEqual(["CTEXT"], 849 text)

850

851 - def test_findall(self):

852 XML = self.etree.XML 853 root = XML(_bytes('<a><c/><c></c></a>')) 854 self.assertEqual(len(list(root.findall("c"))), 1) 855 self.assertEqual(len(list(root.findall(".//c"))), 2) 856 self.assertEqual(len(list(root.findall(".//b"))), 3) 857 self.assertEqual(len(list(root.findall(".//b"))[0]), 1) 858 self.assertEqual(len(list(root.findall(".//b"))[1]), 0) 859 self.assertEqual(len(list(root.findall(".//b"))[2]), 0)

860

861 - def test_findall_ns(self):

862 XML = self.etree.XML 863 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 864 self.assertEqual(len(list(root.findall(".//{X}b"))), 2) 865 self.assertEqual(len(list(root.findall(".//b"))), 3) 866 self.assertEqual(len(list(root.findall("b"))), 2)

867

868 - def test_element_with_attributes_keywords(self):

869 Element = self.etree.Element 870 871 el = Element('tag', foo='Foo', bar='Bar') 872 self.assertEqual('Foo', el.attrib['foo']) 873 self.assertEqual('Bar', el.attrib['bar'])

874

875 - def test_element_with_attributes(self):

876 Element = self.etree.Element 877 878 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 879 self.assertEqual('Foo', el.attrib['foo']) 880 self.assertEqual('Bar', el.attrib['bar'])

881

882 - def test_element_with_attributes_ns(self):

883 Element = self.etree.Element 884 885 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 886 self.assertEqual('Foo', el.attrib['{ns1}foo']) 887 self.assertEqual('Bar', el.attrib['{ns2}bar'])

888

889 - def test_subelement_with_attributes(self):

890 Element = self.etree.Element 891 SubElement = self.etree.SubElement 892 893 el = Element('tag') 894 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 895 self.assertEqual("Baz", el[0].attrib['baz']) 896 self.assertEqual('Foo', el[0].attrib['foo'])

897

898 - def test_subelement_with_attributes_ns(self):

899 Element = self.etree.Element 900 SubElement = self.etree.SubElement 901 902 el = Element('tag') 903 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 904 self.assertEqual('Foo', el[0].attrib['{ns1}foo']) 905 self.assertEqual('Bar', el[0].attrib['{ns2}bar'])

906

907 - def test_write(self):

908 ElementTree = self.etree.ElementTree 909 XML = self.etree.XML 910 911 for i in range(10): 912 f = BytesIO() 913 root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 914 tree = ElementTree(element=root) 915 tree.write(f) 916 data = f.getvalue() 917 self.assertEqual( 918 _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 919 canonicalize(data))

920 921 required_versions_ET['test_write_method_html'] = (1,3)

922 - def test_write_method_html(self):

923 ElementTree = self.etree.ElementTree 924 Element = self.etree.Element 925 SubElement = self.etree.SubElement 926 927 html = Element('html') 928 body = SubElement(html, 'body') 929 p = SubElement(body, 'p') 930 p.text = "html" 931 SubElement(p, 'br').tail = "test" 932 933 tree = ElementTree(element=html) 934 f = BytesIO() 935 tree.write(f, method="html") 936 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 937 938 self.assertEqual(_bytes('<html><body>html test</body></html>'), 939 data)

940 941 required_versions_ET['test_write_method_text'] = (1,3)

942 - def test_write_method_text(self):

943 ElementTree = self.etree.ElementTree 944 Element = self.etree.Element 945 SubElement = self.etree.SubElement 946 947 a = Element('a') 948 a.text = "A" 949 a.tail = "tail" 950 b = SubElement(a, 'b') 951 b.text = "B" 952 b.tail = "TAIL" 953 c = SubElement(a, 'c') 954 c.text = "C" 955 956 tree = ElementTree(element=a) 957 f = BytesIO() 958 tree.write(f, method="text") 959 data = f.getvalue() 960 961 self.assertEqual(_bytes('ABTAILCtail'), 962 data)

963

964 - def test_write_fail(self):

965 ElementTree = self.etree.ElementTree 966 XML = self.etree.XML 967 968 tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 969 self.assertRaises(IOError, tree.write, 970 "definitely////\\-\\nonexisting\\-\\////FILE")

971 972 # this could trigger a crash, apparently because the document 973 # reference was prematurely garbage collected

974 - def test_crash(self):

975 Element = self.etree.Element 976 977 element = Element('tag') 978 for i in range(10): 979 element.attrib['key'] = 'value' 980 value = element.attrib['key'] 981 self.assertEqual(value, 'value')

982 983 # from doctest; for some reason this caused crashes too

984 - def test_write_ElementTreeDoctest(self):

985 Element = self.etree.Element 986 ElementTree = self.etree.ElementTree 987 988 f = BytesIO() 989 for i in range(10): 990 element = Element('tag%s' % i) 991 self._check_element(element) 992 tree = ElementTree(element) 993 tree.write(f) 994 self._check_element_tree(tree)

995

996 - def test_subelement_reference(self):

997 Element = self.etree.Element 998 SubElement = self.etree.SubElement 999 1000 el = Element('foo') 1001 el2 = SubElement(el, 'bar') 1002 el3 = SubElement(el2, 'baz') 1003 1004 al = Element('foo2') 1005 al2 = SubElement(al, 'bar2') 1006 al3 = SubElement(al2, 'baz2') 1007 1008 # now move al2 into el 1009 el.append(al2) 1010 1011 # now change al3 directly 1012 al3.text = 'baz2-modified' 1013 1014 # it should have changed through this route too 1015 self.assertEqual( 1016 'baz2-modified', 1017 el[1][0].text)

1018

1019 - def test_set_text(self):

1020 Element = self.etree.Element 1021 SubElement = self.etree.SubElement 1022 1023 a = Element('a') 1024 b = SubElement(a, 'b') 1025 a.text = 'hoi' 1026 self.assertEqual( 1027 'hoi', 1028 a.text) 1029 self.assertEqual( 1030 'b', 1031 a[0].tag)

1032

1033 - def test_set_text2(self):

1034 Element = self.etree.Element 1035 SubElement = self.etree.SubElement 1036 1037 a = Element('a') 1038 a.text = 'hoi' 1039 b = SubElement(a ,'b') 1040 self.assertEqual( 1041 'hoi', 1042 a.text) 1043 self.assertEqual( 1044 'b', 1045 a[0].tag)

1046

1047 - def test_set_text_none(self):

1048 Element = self.etree.Element 1049 1050 a = Element('a') 1051 1052 a.text = 'foo' 1053 a.text = None 1054 1055 self.assertEqual( 1056 None, 1057 a.text) 1058 self.assertXML(_bytes('<a></a>'), a)

1059

1060 - def test_set_text_empty(self):

1061 Element = self.etree.Element 1062 1063 a = Element('a') 1064 self.assertEqual(None, a.text) 1065 1066 a.text = '' 1067 self.assertEqual('', a.text) 1068 self.assertXML(_bytes('<a></a>'), a)

1069

1070 - def test_tail1(self):

1071 Element = self.etree.Element 1072 SubElement = self.etree.SubElement 1073 1074 a = Element('a') 1075 a.tail = 'dag' 1076 self.assertEqual('dag', 1077 a.tail) 1078 b = SubElement(a, 'b') 1079 b.tail = 'hoi' 1080 self.assertEqual('hoi', 1081 b.tail) 1082 self.assertEqual('dag', 1083 a.tail)

1084

1085 - def test_tail_append(self):

1086 Element = self.etree.Element 1087 1088 a = Element('a') 1089 b = Element('b') 1090 b.tail = 'b_tail' 1091 a.append(b) 1092 self.assertEqual('b_tail', 1093 b.tail)

1094

1095 - def test_tail_set_twice(self):

1096 Element = self.etree.Element 1097 SubElement = self.etree.SubElement 1098 1099 a = Element('a') 1100 b = SubElement(a, 'b') 1101 b.tail = 'foo' 1102 b.tail = 'bar' 1103 self.assertEqual('bar', 1104 b.tail) 1105 self.assertXML(_bytes('<a>bar</a>'), a)

1106

1107 - def test_tail_set_none(self):

1108 Element = self.etree.Element 1109 a = Element('a') 1110 a.tail = 'foo' 1111 a.tail = None 1112 self.assertEqual( 1113 None, 1114 a.tail) 1115 self.assertXML(_bytes('<a></a>'), a)

1116 1117 required_versions_ET['test_extend'] = (1,3)

1118 - def test_extend(self):

1119 root = self.etree.Element('foo') 1120 for i in range(3): 1121 element = self.etree.SubElement(root, 'a%s' % i) 1122 element.text = "text%d" % i 1123 element.tail = "tail%d" % i 1124 1125 elements = [] 1126 for i in range(3): 1127 new_element = self.etree.Element("test%s" % i) 1128 new_element.text = "TEXT%s" % i 1129 new_element.tail = "TAIL%s" % i 1130 elements.append(new_element) 1131 1132 root.extend(elements) 1133 1134 self.assertEqual( 1135 ["a0", "a1", "a2", "test0", "test1", "test2"], 1136 [ el.tag for el in root ]) 1137 self.assertEqual( 1138 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1139 [ el.text for el in root ]) 1140 self.assertEqual( 1141 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1142 [ el.tail for el in root ])

1143

1144 - def test_comment(self):

1145 Element = self.etree.Element 1146 SubElement = self.etree.SubElement 1147 Comment = self.etree.Comment 1148 1149 a = Element('a') 1150 a.append(Comment('foo')) 1151 self.assertEqual(a[0].tag, Comment) 1152 self.assertEqual(a[0].text, 'foo')

1153 1154 # ElementTree < 1.3 adds whitespace around comments 1155 required_versions_ET['test_comment_text'] = (1,3)

1156 - def test_comment_text(self):

1157 Element = self.etree.Element 1158 SubElement = self.etree.SubElement 1159 Comment = self.etree.Comment 1160 tostring = self.etree.tostring 1161 1162 a = Element('a') 1163 a.append(Comment('foo')) 1164 self.assertEqual(a[0].text, 'foo') 1165 1166 self.assertEqual( 1167 _bytes('<a></a>'), 1168 tostring(a)) 1169 1170 a[0].text = "TEST" 1171 self.assertEqual(a[0].text, 'TEST') 1172 1173 self.assertEqual( 1174 _bytes('<a></a>'), 1175 tostring(a))

1176 1177 # ElementTree < 1.3 adds whitespace around comments 1178 required_versions_ET['test_comment_whitespace'] = (1,3)

1179 - def test_comment_whitespace(self):

1180 Element = self.etree.Element 1181 SubElement = self.etree.SubElement 1182 Comment = self.etree.Comment 1183 tostring = self.etree.tostring 1184 1185 a = Element('a') 1186 a.append(Comment(' foo ')) 1187 self.assertEqual(a[0].text, ' foo ') 1188 self.assertEqual( 1189 _bytes('<a></a>'), 1190 tostring(a))

1191

1192 - def test_comment_nonsense(self):

1193 Comment = self.etree.Comment 1194 c = Comment('foo') 1195 self.assertEqual({}, c.attrib) 1196 self.assertEqual([], list(c.keys())) 1197 self.assertEqual([], list(c.items())) 1198 self.assertEqual(None, c.get('hoi')) 1199 self.assertEqual(0, len(c)) 1200 # should not iterate 1201 for i in c: 1202 pass

1203

1204 - def test_pi(self):

1205 # lxml.etree separates target and text 1206 Element = self.etree.Element 1207 SubElement = self.etree.SubElement 1208 ProcessingInstruction = self.etree.ProcessingInstruction 1209 1210 a = Element('a') 1211 a.append(ProcessingInstruction('foo', 'some more text')) 1212 self.assertEqual(a[0].tag, ProcessingInstruction) 1213 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1214 a)

1215

1216 - def test_processinginstruction(self):

1217 # lxml.etree separates target and text 1218 Element = self.etree.Element 1219 SubElement = self.etree.SubElement 1220 ProcessingInstruction = self.etree.PI 1221 1222 a = Element('a') 1223 a.append(ProcessingInstruction('foo', 'some more text')) 1224 self.assertEqual(a[0].tag, ProcessingInstruction) 1225 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1226 a)

1227

1228 - def test_pi_nonsense(self):

1229 ProcessingInstruction = self.etree.ProcessingInstruction 1230 pi = ProcessingInstruction('foo') 1231 self.assertEqual({}, pi.attrib) 1232 self.assertEqual([], list(pi.keys())) 1233 self.assertEqual([], list(pi.items())) 1234 self.assertEqual(None, pi.get('hoi')) 1235 self.assertEqual(0, len(pi)) 1236 # should not iterate 1237 for i in pi: 1238 pass

1239

1240 - def test_setitem(self):

1241 Element = self.etree.Element 1242 SubElement = self.etree.SubElement 1243 1244 a = Element('a') 1245 b = SubElement(a, 'b') 1246 c = Element('c') 1247 a[0] = c 1248 self.assertEqual( 1249 c, 1250 a[0]) 1251 self.assertXML(_bytes('<a><c></c></a>'), 1252 a) 1253 self.assertXML(_bytes(''), 1254 b)

1255

1256 - def test_setitem2(self):

1257 Element = self.etree.Element 1258 SubElement = self.etree.SubElement 1259 1260 a = Element('a') 1261 for i in range(5): 1262 b = SubElement(a, 'b%s' % i) 1263 c = SubElement(b, 'c') 1264 for i in range(5): 1265 d = Element('d') 1266 e = SubElement(d, 'e') 1267 a[i] = d 1268 self.assertXML( 1269 _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 1270 a) 1271 self.assertXML(_bytes('<c></c>'), 1272 c)

1273

1274 - def test_setitem_replace(self):

1275 Element = self.etree.Element 1276 SubElement = self.etree.SubElement 1277 1278 a = Element('a') 1279 SubElement(a, 'b') 1280 d = Element('d') 1281 a[0] = d 1282 self.assertXML(_bytes('<a><d></d></a>'), a)

1283

1284 - def test_setitem_indexerror(self):

1285 Element = self.etree.Element 1286 SubElement = self.etree.SubElement 1287 1288 a = Element('a') 1289 b = SubElement(a, 'b') 1290 1291 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1292

1293 - def test_setitem_tail(self):

1294 Element = self.etree.Element 1295 SubElement = self.etree.SubElement 1296 1297 a = Element('a') 1298 b = SubElement(a, 'b') 1299 b.tail = 'B2' 1300 c = Element('c') 1301 c.tail = 'C2' 1302 1303 a[0] = c 1304 self.assertXML( 1305 _bytes('<a><c></c>C2</a>'), 1306 a)

1307

1308 - def test_tag_write(self):

1309 Element = self.etree.Element 1310 SubElement = self.etree.SubElement 1311 1312 a = Element('a') 1313 b = SubElement(a, 'b') 1314 1315 a.tag = 'c' 1316 1317 self.assertEqual( 1318 'c', 1319 a.tag) 1320 1321 self.assertXML( 1322 _bytes('<c></c>'), 1323 a)

1324

1325 - def test_tag_reset_ns(self):

1326 Element = self.etree.Element 1327 SubElement = self.etree.SubElement 1328 tostring = self.etree.tostring 1329 1330 a = Element('{a}a') 1331 b1 = SubElement(a, '{a}b') 1332 b2 = SubElement(a, '{b}b') 1333 1334 self.assertEqual('{a}b', b1.tag) 1335 1336 b1.tag = 'c' 1337 1338 # can't use C14N here! 1339 self.assertEqual('c', b1.tag) 1340 self.assertEqual(_bytes('<c'), tostring(b1)[:2]) 1341 self.assertTrue(_bytes('<c') in tostring(a))

1342

1343 - def test_tag_reset_root_ns(self):

1344 Element = self.etree.Element 1345 SubElement = self.etree.SubElement 1346 tostring = self.etree.tostring 1347 1348 a = Element('{a}a') 1349 b1 = SubElement(a, '{a}b') 1350 b2 = SubElement(a, '{b}b') 1351 1352 a.tag = 'c' 1353 1354 self.assertEqual( 1355 'c', 1356 a.tag) 1357 1358 # can't use C14N here! 1359 self.assertEqual('c', a.tag) 1360 self.assertEqual(_bytes('<c'), tostring(a)[:2])

1361

1362 - def test_tag_str_subclass(self):

1363 Element = self.etree.Element 1364 1365 class strTest(str): 1366 pass

1367 1368 a = Element("a") 1369 a.tag = strTest("TAG") 1370 self.assertXML(_bytes('<TAG></TAG>'), 1371 a) 1372

1373 - def test_delitem(self):

1374 Element = self.etree.Element 1375 SubElement = self.etree.SubElement 1376 1377 a = Element('a') 1378 b = SubElement(a, 'b') 1379 c = SubElement(a, 'c') 1380 d = SubElement(a, 'd') 1381 1382 del a[1] 1383 self.assertXML( 1384 _bytes('<a><d></d></a>'), 1385 a) 1386 1387 del a[0] 1388 self.assertXML( 1389 _bytes('<a><d></d></a>'), 1390 a) 1391 1392 del a[0] 1393 self.assertXML( 1394 _bytes('<a></a>'), 1395 a) 1396 # move deleted element into other tree afterwards 1397 other = Element('other') 1398 other.append(c) 1399 self.assertXML( 1400 _bytes('<other><c></c></other>'), 1401 other)

1402

1403 - def test_del_insert(self):

1404 Element = self.etree.Element 1405 SubElement = self.etree.SubElement 1406 1407 a = Element('a') 1408 b = SubElement(a, 'b') 1409 bs = SubElement(b, 'bs') 1410 c = SubElement(a, 'c') 1411 cs = SubElement(c, 'cs') 1412 1413 el = a[0] 1414 self.assertXML( 1415 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1416 a) 1417 self.assertXML(_bytes('<bs></bs>'), b) 1418 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1419 1420 del a[0] 1421 self.assertXML( 1422 _bytes('<a><c><cs></cs></c></a>'), 1423 a) 1424 self.assertXML(_bytes('<bs></bs>'), b) 1425 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1426 1427 a.insert(0, el) 1428 self.assertXML( 1429 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1430 a) 1431 self.assertXML(_bytes('<bs></bs>'), b) 1432 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1433

1434 - def test_del_setitem(self):

1435 Element = self.etree.Element 1436 SubElement = self.etree.SubElement 1437 1438 a = Element('a') 1439 b = SubElement(a, 'b') 1440 bs = SubElement(b, 'bs') 1441 c = SubElement(a, 'c') 1442 cs = SubElement(c, 'cs') 1443 1444 el = a[0] 1445 del a[0] 1446 a[0] = el 1447 self.assertXML( 1448 _bytes('<a><bs></bs></a>'), 1449 a) 1450 self.assertXML(_bytes('<bs></bs>'), b) 1451 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1452

1453 - def test_del_setslice(self):

1454 Element = self.etree.Element 1455 SubElement = self.etree.SubElement 1456 1457 a = Element('a') 1458 b = SubElement(a, 'b') 1459 bs = SubElement(b, 'bs') 1460 c = SubElement(a, 'c') 1461 cs = SubElement(c, 'cs') 1462 1463 el = a[0] 1464 del a[0] 1465 a[0:0] = [el] 1466 self.assertXML( 1467 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1468 a) 1469 self.assertXML(_bytes('<bs></bs>'), b) 1470 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1471

1472 - def test_replace_slice_tail(self):

1473 XML = self.etree.XML 1474 a = XML(_bytes('<a>B2<c></c>C2</a>')) 1475 b, c = a 1476 1477 a[:] = [] 1478 1479 self.assertEqual("B2", b.tail) 1480 self.assertEqual("C2", c.tail)

1481

1482 - def test_merge_namespaced_subtree_as_slice(self):

1483 XML = self.etree.XML 1484 root = XML(_bytes( 1485 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 1486 root[:] = root.findall('.//puh') # delete bar from hierarchy 1487 1488 # previously, this lost a namespace declaration on bump2 1489 result = self.etree.tostring(root) 1490 foo = self.etree.fromstring(result) 1491 1492 self.assertEqual('puh', foo[0].tag) 1493 self.assertEqual('{http://huhu}bump1', foo[0][0].tag) 1494 self.assertEqual('{http://huhu}bump2', foo[0][1].tag)

1495

1496 - def test_delitem_tail(self):

1497 ElementTree = self.etree.ElementTree 1498 f = BytesIO('<a>B2<c></c>C2</a>') 1499 doc = ElementTree(file=f) 1500 a = doc.getroot() 1501 del a[0] 1502 self.assertXML( 1503 _bytes('<a><c></c>C2</a>'), 1504 a)

1505

1506 - def test_clear(self):

1507 Element = self.etree.Element 1508 1509 a = Element('a') 1510 a.text = 'foo' 1511 a.tail = 'bar' 1512 a.set('hoi', 'dag') 1513 a.clear() 1514 self.assertEqual(None, a.text) 1515 self.assertEqual(None, a.tail) 1516 self.assertEqual(None, a.get('hoi')) 1517 self.assertEqual('a', a.tag)

1518

1519 - def test_clear_sub(self):

1520 Element = self.etree.Element 1521 SubElement = self.etree.SubElement 1522 1523 a = Element('a') 1524 a.text = 'foo' 1525 a.tail = 'bar' 1526 a.set('hoi', 'dag') 1527 b = SubElement(a, 'b') 1528 c = SubElement(b, 'c') 1529 a.clear() 1530 self.assertEqual(None, a.text) 1531 self.assertEqual(None, a.tail) 1532 self.assertEqual(None, a.get('hoi')) 1533 self.assertEqual('a', a.tag) 1534 self.assertEqual(0, len(a)) 1535 self.assertXML(_bytes('<a></a>'), 1536 a) 1537 self.assertXML(_bytes('<c></c>'), 1538 b)

1539

1540 - def test_clear_tail(self):

1541 ElementTree = self.etree.ElementTree 1542 f = BytesIO('<a>B2<c></c>C2</a>') 1543 doc = ElementTree(file=f) 1544 a = doc.getroot() 1545 a.clear() 1546 self.assertXML( 1547 _bytes('<a></a>'), 1548 a)

1549

1550 - def test_insert(self):

1551 Element = self.etree.Element 1552 SubElement = self.etree.SubElement 1553 1554 a = Element('a') 1555 b = SubElement(a, 'b') 1556 c = SubElement(a, 'c') 1557 d = Element('d') 1558 a.insert(0, d) 1559 1560 self.assertEqual( 1561 d, 1562 a[0]) 1563 1564 self.assertXML( 1565 _bytes('<a><d></d><c></c></a>'), 1566 a) 1567 1568 e = Element('e') 1569 a.insert(2, e) 1570 self.assertEqual( 1571 e, 1572 a[2]) 1573 self.assertXML( 1574 _bytes('<a><d></d><e></e><c></c></a>'), 1575 a)

1576

1577 - def test_insert_beyond_index(self):

1578 Element = self.etree.Element 1579 SubElement = self.etree.SubElement 1580 1581 a = Element('a') 1582 b = SubElement(a, 'b') 1583 c = Element('c') 1584 1585 a.insert(2, c) 1586 self.assertEqual( 1587 c, 1588 a[1]) 1589 self.assertXML( 1590 _bytes('<a><c></c></a>'), 1591 a)

1592

1593 - def test_insert_negative(self):

1594 Element = self.etree.Element 1595 SubElement = self.etree.SubElement 1596 1597 a = Element('a') 1598 b = SubElement(a, 'b') 1599 c = SubElement(a, 'c') 1600 1601 d = Element('d') 1602 a.insert(-1, d) 1603 self.assertEqual( 1604 d, 1605 a[-2]) 1606 self.assertXML( 1607 _bytes('<a><d></d><c></c></a>'), 1608 a)

1609

1610 - def test_insert_tail(self):

1611 Element = self.etree.Element 1612 SubElement = self.etree.SubElement 1613 1614 a = Element('a') 1615 b = SubElement(a, 'b') 1616 1617 c = Element('c') 1618 c.tail = 'C2' 1619 1620 a.insert(0, c) 1621 self.assertXML( 1622 _bytes('<a><c></c>C2</a>'), 1623 a)

1624

1625 - def test_remove(self):

1626 Element = self.etree.Element 1627 SubElement = self.etree.SubElement 1628 1629 a = Element('a') 1630 b = SubElement(a, 'b') 1631 c = SubElement(a, 'c') 1632 1633 a.remove(b) 1634 self.assertEqual( 1635 c, 1636 a[0]) 1637 self.assertXML( 1638 _bytes('<a><c></c></a>'), 1639 a)

1640

1641 - def test_remove_ns(self):

1642 Element = self.etree.Element 1643 SubElement = self.etree.SubElement 1644 1645 a = Element('{http://test}a') 1646 b = SubElement(a, '{http://test}b') 1647 c = SubElement(a, '{http://test}c') 1648 1649 a.remove(b) 1650 self.assertXML( 1651 _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 1652 a) 1653 self.assertXML( 1654 _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 1655 b)

1656

1657 - def test_remove_nonexisting(self):

1658 Element = self.etree.Element 1659 SubElement = self.etree.SubElement 1660 1661 a = Element('a') 1662 b = SubElement(a, 'b') 1663 c = SubElement(a, 'c') 1664 d = Element('d') 1665 self.assertRaises( 1666 ValueError, a.remove, d)

1667

1668 - def test_remove_tail(self):

1669 Element = self.etree.Element 1670 SubElement = self.etree.SubElement 1671 1672 a = Element('a') 1673 b = SubElement(a, 'b') 1674 b.tail = 'b2' 1675 a.remove(b) 1676 self.assertXML( 1677 _bytes('<a></a>'), 1678 a) 1679 self.assertEqual('b2', b.tail)

1680

1681 - def _test_getchildren(self):

1682 Element = self.etree.Element 1683 SubElement = self.etree.SubElement 1684 1685 a = Element('a') 1686 b = SubElement(a, 'b') 1687 c = SubElement(a, 'c') 1688 d = SubElement(b, 'd') 1689 e = SubElement(c, 'e') 1690 self.assertXML( 1691 _bytes('<a><d></d><c><e></e></c></a>'), 1692 a) 1693 self.assertEqual( 1694 [b, c], 1695 a.getchildren()) 1696 self.assertEqual( 1697 [d], 1698 b.getchildren()) 1699 self.assertEqual( 1700 [], 1701 d.getchildren())

1702

1703 - def test_makeelement(self):

1704 Element = self.etree.Element 1705 1706 a = Element('a') 1707 b = a.makeelement('c', {'hoi':'dag'}) 1708 self.assertXML( 1709 _bytes('<c hoi="dag"></c>'), 1710 b)

1711 1712 required_versions_ET['test_iter'] = (1,3)

1713 - def test_iter(self):

1714 Element = self.etree.Element 1715 SubElement = self.etree.SubElement 1716 1717 a = Element('a') 1718 b = SubElement(a, 'b') 1719 c = SubElement(a, 'c') 1720 d = SubElement(b, 'd') 1721 e = SubElement(c, 'e') 1722 1723 self.assertEqual( 1724 [a, b, d, c, e], 1725 list(a.iter())) 1726 self.assertEqual( 1727 [d], 1728 list(d.iter()))

1729

1730 - def test_getiterator(self):

1731 Element = self.etree.Element 1732 SubElement = self.etree.SubElement 1733 1734 a = Element('a') 1735 b = SubElement(a, 'b') 1736 c = SubElement(a, 'c') 1737 d = SubElement(b, 'd') 1738 e = SubElement(c, 'e') 1739 1740 self.assertEqual( 1741 [a, b, d, c, e], 1742 list(a.getiterator())) 1743 self.assertEqual( 1744 [d], 1745 list(d.getiterator()))

1746

1747 - def test_getiterator_empty(self):

1748 Element = self.etree.Element 1749 SubElement = self.etree.SubElement 1750 1751 a = Element('a') 1752 b = SubElement(a, 'b') 1753 c = SubElement(a, 'c') 1754 d = SubElement(b, 'd') 1755 e = SubElement(c, 'e') 1756 1757 self.assertEqual( 1758 [], 1759 list(a.getiterator('none'))) 1760 self.assertEqual( 1761 [], 1762 list(e.getiterator('none'))) 1763 self.assertEqual( 1764 [e], 1765 list(e.getiterator()))

1766

1767 - def test_getiterator_filter(self):

1768 Element = self.etree.Element 1769 SubElement = self.etree.SubElement 1770 1771 a = Element('a') 1772 b = SubElement(a, 'b') 1773 c = SubElement(a, 'c') 1774 d = SubElement(b, 'd') 1775 e = SubElement(c, 'e') 1776 1777 self.assertEqual( 1778 [a], 1779 list(a.getiterator('a'))) 1780 a2 = SubElement(e, 'a') 1781 self.assertEqual( 1782 [a, a2], 1783 list(a.getiterator('a'))) 1784 self.assertEqual( 1785 [a2], 1786 list(c.getiterator('a')))

1787

1788 - def test_getiterator_filter_all(self):

1789 Element = self.etree.Element 1790 SubElement = self.etree.SubElement 1791 1792 a = Element('a') 1793 b = SubElement(a, 'b') 1794 c = SubElement(a, 'c') 1795 d = SubElement(b, 'd') 1796 e = SubElement(c, 'e') 1797 1798 self.assertEqual( 1799 [a, b, d, c, e], 1800 list(a.getiterator('*')))

1801

1802 - def test_getiterator_filter_comment(self):

1803 Element = self.etree.Element 1804 Comment = self.etree.Comment 1805 SubElement = self.etree.SubElement 1806 1807 a = Element('a') 1808 b = SubElement(a, 'b') 1809 comment_b = Comment("TEST-b") 1810 b.append(comment_b) 1811 1812 self.assertEqual( 1813 [comment_b], 1814 list(a.getiterator(Comment))) 1815 1816 comment_a = Comment("TEST-a") 1817 a.append(comment_a) 1818 1819 self.assertEqual( 1820 [comment_b, comment_a], 1821 list(a.getiterator(Comment))) 1822 1823 self.assertEqual( 1824 [comment_b], 1825 list(b.getiterator(Comment)))

1826

1827 - def test_getiterator_filter_pi(self):

1828 Element = self.etree.Element 1829 PI = self.etree.ProcessingInstruction 1830 SubElement = self.etree.SubElement 1831 1832 a = Element('a') 1833 b = SubElement(a, 'b') 1834 pi_b = PI("TEST-b") 1835 b.append(pi_b) 1836 1837 self.assertEqual( 1838 [pi_b], 1839 list(a.getiterator(PI))) 1840 1841 pi_a = PI("TEST-a") 1842 a.append(pi_a) 1843 1844 self.assertEqual( 1845 [pi_b, pi_a], 1846 list(a.getiterator(PI))) 1847 1848 self.assertEqual( 1849 [pi_b], 1850 list(b.getiterator(PI)))

1851

1852 - def test_getiterator_with_text(self):

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

1874 #self.assertEqual( 1875 # [d], 1876 # list(d.getiterator())) 1877

1878 - def test_getiterator_filter_with_text(self):

1879 Element = self.etree.Element 1880 SubElement = self.etree.SubElement 1881 1882 a = Element('a') 1883 a.text = 'a' 1884 b = SubElement(a, 'b') 1885 b.text = 'b' 1886 b.tail = 'b1' 1887 c = SubElement(a, 'c') 1888 c.text = 'c' 1889 c.tail = 'c1' 1890 d = SubElement(b, 'd') 1891 c.text = 'd' 1892 c.tail = 'd1' 1893 e = SubElement(c, 'e') 1894 e.text = 'e' 1895 e.tail = 'e1' 1896 1897 self.assertEqual( 1898 [a], 1899 list(a.getiterator('a'))) 1900 a2 = SubElement(e, 'a') 1901 self.assertEqual( 1902 [a, a2], 1903 list(a.getiterator('a'))) 1904 self.assertEqual( 1905 [a2], 1906 list(e.getiterator('a')))

1907

1908 - def test_getslice(self):

1909 Element = self.etree.Element 1910 SubElement = self.etree.SubElement 1911 1912 a = Element('a') 1913 b = SubElement(a, 'b') 1914 c = SubElement(a, 'c') 1915 d = SubElement(a, 'd') 1916 1917 self.assertEqual( 1918 [b, c], 1919 a[0:2]) 1920 self.assertEqual( 1921 [b, c, d], 1922 a[:]) 1923 self.assertEqual( 1924 [b, c, d], 1925 a[:10]) 1926 self.assertEqual( 1927 [b], 1928 a[0:1]) 1929 self.assertEqual( 1930 [], 1931 a[10:12])

1932

1933 - def test_getslice_negative(self):

1934 Element = self.etree.Element 1935 SubElement = self.etree.SubElement 1936 1937 a = Element('a') 1938 b = SubElement(a, 'b') 1939 c = SubElement(a, 'c') 1940 d = SubElement(a, 'd') 1941 1942 self.assertEqual( 1943 [d], 1944 a[-1:]) 1945 self.assertEqual( 1946 [c, d], 1947 a[-2:]) 1948 self.assertEqual( 1949 [c], 1950 a[-2:-1]) 1951 self.assertEqual( 1952 [b, c], 1953 a[-3:-1]) 1954 self.assertEqual( 1955 [b, c], 1956 a[-3:2])

1957

1958 - def test_getslice_step(self):

1959 Element = self.etree.Element 1960 SubElement = self.etree.SubElement 1961 1962 a = Element('a') 1963 b = SubElement(a, 'b') 1964 c = SubElement(a, 'c') 1965 d = SubElement(a, 'd') 1966 e = SubElement(a, 'e') 1967 1968 self.assertEqual( 1969 [e,d,c,b], 1970 a[::-1]) 1971 self.assertEqual( 1972 [b,d], 1973 a[::2]) 1974 self.assertEqual( 1975 [e,c], 1976 a[::-2]) 1977 self.assertEqual( 1978 [d,c], 1979 a[-2:0:-1]) 1980 self.assertEqual( 1981 [e], 1982 a[:1:-2])

1983

1984 - def test_getslice_text(self):

1985 ElementTree = self.etree.ElementTree 1986 1987 f = BytesIO('<a>BB1<c>C</c>C1</a>') 1988 doc = ElementTree(file=f) 1989 a = doc.getroot() 1990 b = a[0] 1991 c = a[1] 1992 self.assertEqual( 1993 [b, c], 1994 a[:]) 1995 self.assertEqual( 1996 [b], 1997 a[0:1]) 1998 self.assertEqual( 1999 [c], 2000 a[1:])

2001

2002 - def test_comment_getitem_getslice(self):

2003 Element = self.etree.Element 2004 Comment = self.etree.Comment 2005 SubElement = self.etree.SubElement 2006 2007 a = Element('a') 2008 b = SubElement(a, 'b') 2009 foo = Comment('foo') 2010 a.append(foo) 2011 c = SubElement(a, 'c') 2012 self.assertEqual( 2013 [b, foo, c], 2014 a[:]) 2015 self.assertEqual( 2016 foo, 2017 a[1]) 2018 a[1] = new = Element('new') 2019 self.assertEqual( 2020 new, 2021 a[1]) 2022 self.assertXML( 2023 _bytes('<a><new></new><c></c></a>'), 2024 a)

2025

2026 - def test_delslice(self):

2027 Element = self.etree.Element 2028 SubElement = self.etree.SubElement 2029 2030 a = Element('a') 2031 b = SubElement(a, 'b') 2032 c = SubElement(a, 'c') 2033 d = SubElement(a, 'd') 2034 e = SubElement(a, 'e') 2035 2036 del a[1:3] 2037 self.assertEqual( 2038 [b, e], 2039 list(a))

2040

2041 - def test_delslice_negative1(self):

2042 Element = self.etree.Element 2043 SubElement = self.etree.SubElement 2044 2045 a = Element('a') 2046 b = SubElement(a, 'b') 2047 c = SubElement(a, 'c') 2048 d = SubElement(a, 'd') 2049 e = SubElement(a, 'e') 2050 2051 del a[1:-1] 2052 self.assertEqual( 2053 [b, e], 2054 list(a))

2055

2056 - def test_delslice_negative2(self):

2057 Element = self.etree.Element 2058 SubElement = self.etree.SubElement 2059 2060 a = Element('a') 2061 b = SubElement(a, 'b') 2062 c = SubElement(a, 'c') 2063 d = SubElement(a, 'd') 2064 e = SubElement(a, 'e') 2065 2066 del a[-3:-1] 2067 self.assertEqual( 2068 [b, e], 2069 list(a))

2070

2071 - def test_delslice_step(self):

2072 Element = self.etree.Element 2073 SubElement = self.etree.SubElement 2074 2075 a = Element('a') 2076 b = SubElement(a, 'b') 2077 c = SubElement(a, 'c') 2078 d = SubElement(a, 'd') 2079 e = SubElement(a, 'e') 2080 2081 del a[1::2] 2082 self.assertEqual( 2083 [b, d], 2084 list(a))

2085

2086 - def test_delslice_step_negative(self):

2087 Element = self.etree.Element 2088 SubElement = self.etree.SubElement 2089 2090 a = Element('a') 2091 b = SubElement(a, 'b') 2092 c = SubElement(a, 'c') 2093 d = SubElement(a, 'd') 2094 e = SubElement(a, 'e') 2095 2096 del a[::-1] 2097 self.assertEqual( 2098 [], 2099 list(a))

2100

2101 - def test_delslice_step_negative2(self):

2102 Element = self.etree.Element 2103 SubElement = self.etree.SubElement 2104 2105 a = Element('a') 2106 b = SubElement(a, 'b') 2107 c = SubElement(a, 'c') 2108 d = SubElement(a, 'd') 2109 e = SubElement(a, 'e') 2110 2111 del a[::-2] 2112 self.assertEqual( 2113 [b, d], 2114 list(a))

2115

2116 - def test_delslice_child_tail(self):

2117 ElementTree = self.etree.ElementTree 2118 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2119 doc = ElementTree(file=f) 2120 a = doc.getroot() 2121 del a[1:3] 2122 self.assertXML( 2123 _bytes('<a>B2<e></e>E2</a>'), 2124 a)

2125

2126 - def test_delslice_tail(self):

2127 XML = self.etree.XML 2128 a = XML(_bytes('<a>B2<c></c>C2</a>')) 2129 b, c = a 2130 2131 del a[:] 2132 2133 self.assertEqual("B2", b.tail) 2134 self.assertEqual("C2", c.tail)

2135

2136 - def test_delslice_memory(self):

2137 # this could trigger a crash 2138 Element = self.etree.Element 2139 SubElement = self.etree.SubElement 2140 a = Element('a') 2141 b = SubElement(a, 'b') 2142 c = SubElement(b, 'c') 2143 del b # no more reference to b 2144 del a[:] 2145 self.assertEqual('c', c.tag)

2146

2147 - def test_setslice(self):

2148 Element = self.etree.Element 2149 SubElement = self.etree.SubElement 2150 2151 a = Element('a') 2152 b = SubElement(a, 'b') 2153 c = SubElement(a, 'c') 2154 d = SubElement(a, 'd') 2155 2156 e = Element('e') 2157 f = Element('f') 2158 g = Element('g') 2159 2160 s = [e, f, g] 2161 a[1:2] = s 2162 self.assertEqual( 2163 [b, e, f, g, d], 2164 list(a))

2165

2166 - def test_setslice_all(self):

2167 Element = self.etree.Element 2168 SubElement = self.etree.SubElement 2169 2170 a = Element('a') 2171 b = SubElement(a, 'b') 2172 c = SubElement(a, 'c') 2173 2174 e = Element('e') 2175 f = Element('f') 2176 g = Element('g') 2177 2178 s = [e, f, g] 2179 a[:] = s 2180 self.assertEqual( 2181 [e, f, g], 2182 list(a))

2183

2184 - def test_setslice_all_empty(self):

2185 Element = self.etree.Element 2186 SubElement = self.etree.SubElement 2187 2188 a = Element('a') 2189 2190 e = Element('e') 2191 f = Element('f') 2192 g = Element('g') 2193 2194 s = [e, f, g] 2195 a[:] = s 2196 self.assertEqual( 2197 [e, f, g], 2198 list(a))

2199

2200 - def test_setslice_all_replace(self):

2201 Element = self.etree.Element 2202 SubElement = self.etree.SubElement 2203 2204 a = Element('a') 2205 b = SubElement(a, 'b') 2206 c = SubElement(a, 'c') 2207 d = SubElement(a, 'd') 2208 2209 s = [b, c, d] 2210 a[:] = s 2211 self.assertEqual( 2212 [b, c, d], 2213 list(a))

2214

2215 - def test_setslice_all_replace_reversed(self):

2216 Element = self.etree.Element 2217 SubElement = self.etree.SubElement 2218 2219 a = Element('a') 2220 b = SubElement(a, 'b') 2221 c = SubElement(a, 'c') 2222 d = SubElement(a, 'd') 2223 2224 s = [d, c, b] 2225 a[:] = s 2226 self.assertEqual( 2227 [d, c, b], 2228 list(a))

2229

2230 - def test_setslice_all_replace_reversed_ns1(self):

2231 Element = self.etree.Element 2232 SubElement = self.etree.SubElement 2233 2234 a = Element('{ns}a') 2235 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2236 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2237 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2238 2239 s = [d, c, b] 2240 a[:] = s 2241 self.assertEqual( 2242 [d, c, b], 2243 list(a)) 2244 self.assertEqual( 2245 ['{ns}d', '{ns}c', '{ns}b'], 2246 [ child.tag for child in a ]) 2247 2248 self.assertEqual( 2249 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2250 [ list(child.attrib.keys()) for child in a ])

2251

2252 - def test_setslice_all_replace_reversed_ns2(self):

2253 Element = self.etree.Element 2254 SubElement = self.etree.SubElement 2255 2256 a = Element('{ns}a') 2257 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 2258 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 2259 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 2260 2261 s = [d, c, b] 2262 a[:] = s 2263 self.assertEqual( 2264 [d, c, b], 2265 list(a)) 2266 self.assertEqual( 2267 ['{ns3}d', '{ns2}c', '{ns1}b'], 2268 [ child.tag for child in a ]) 2269 2270 self.assertEqual( 2271 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 2272 [ list(child.attrib.keys()) for child in a ])

2273

2274 - def test_setslice_end(self):

2275 Element = self.etree.Element 2276 SubElement = self.etree.SubElement 2277 2278 a = Element('a') 2279 b = SubElement(a, 'b') 2280 c = SubElement(a, 'c') 2281 2282 e = Element('e') 2283 f = Element('f') 2284 g = Element('g') 2285 h = Element('h') 2286 2287 s = [e, f] 2288 a[99:] = s 2289 self.assertEqual( 2290 [a, b, e, f], 2291 list(a)) 2292 2293 s = [g, h] 2294 a[:0] = s 2295 self.assertEqual( 2296 [g, h, a, b, e, f], 2297 list(a))

2298

2299 - def test_setslice_single(self):

2300 Element = self.etree.Element 2301 SubElement = self.etree.SubElement 2302 2303 a = Element('a') 2304 b = SubElement(a, 'b') 2305 c = SubElement(a, 'c') 2306 2307 e = Element('e') 2308 f = Element('f') 2309 2310 s = [e] 2311 a[0:1] = s 2312 self.assertEqual( 2313 [e, c], 2314 list(a)) 2315 2316 s = [f] 2317 a[1:2] = s 2318 self.assertEqual( 2319 [e, f], 2320 list(a))

2321

2322 - def test_setslice_tail(self):

2323 ElementTree = self.etree.ElementTree 2324 Element = self.etree.Element 2325 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2326 doc = ElementTree(file=f) 2327 a = doc.getroot() 2328 x = Element('x') 2329 y = Element('y') 2330 z = Element('z') 2331 x.tail = 'X2' 2332 y.tail = 'Y2' 2333 z.tail = 'Z2' 2334 a[1:3] = [x, y, z] 2335 self.assertXML( 2336 _bytes('<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 2337 a)

2338

2339 - def test_setslice_negative(self):

2340 Element = self.etree.Element 2341 SubElement = self.etree.SubElement 2342 2343 a = Element('a') 2344 b = SubElement(a, 'b') 2345 c = SubElement(a, 'c') 2346 d = SubElement(a, 'd') 2347 2348 x = Element('x') 2349 y = Element('y') 2350 2351 a[1:-1] = [x, y] 2352 self.assertEqual( 2353 [b, x, y, d], 2354 list(a))

2355

2356 - def test_setslice_negative2(self):

2357 Element = self.etree.Element 2358 SubElement = self.etree.SubElement 2359 2360 a = Element('a') 2361 b = SubElement(a, 'b') 2362 c = SubElement(a, 'c') 2363 d = SubElement(a, 'd') 2364 2365 x = Element('x') 2366 y = Element('y') 2367 2368 a[1:-2] = [x, y] 2369 self.assertEqual( 2370 [b, x, y, c, d], 2371 list(a))

2372

2373 - def test_setslice_end(self):

2374 Element = self.etree.Element 2375 SubElement = self.etree.SubElement 2376 2377 a = Element('a') 2378 b = SubElement(a, 'b') 2379 c = SubElement(a, 'c') 2380 d = SubElement(a, 'd') 2381 2382 e = Element('e') 2383 f = Element('f') 2384 g = Element('g') 2385 2386 s = [e, f, g] 2387 a[3:] = s 2388 self.assertEqual( 2389 [b, c, d, e, f, g], 2390 list(a))

2391

2392 - def test_setslice_empty(self):

2393 Element = self.etree.Element 2394 2395 a = Element('a') 2396 2397 b = Element('b') 2398 c = Element('c') 2399 2400 a[:] = [b, c] 2401 self.assertEqual( 2402 [b, c], 2403 list(a))

2404

2405 - def test_tail_elementtree_root(self):

2406 Element = self.etree.Element 2407 ElementTree = self.etree.ElementTree 2408 2409 a = Element('a') 2410 a.tail = 'A2' 2411 t = ElementTree(element=a) 2412 self.assertEqual('A2', 2413 a.tail)

2414

2415 - def test_elementtree_getiterator(self):

2416 Element = self.etree.Element 2417 SubElement = self.etree.SubElement 2418 ElementTree = self.etree.ElementTree 2419 2420 a = Element('a') 2421 b = SubElement(a, 'b') 2422 c = SubElement(a, 'c') 2423 d = SubElement(b, 'd') 2424 e = SubElement(c, 'e') 2425 t = ElementTree(element=a) 2426 2427 self.assertEqual( 2428 [a, b, d, c, e], 2429 list(t.getiterator()))

2430

2431 - def test_elementtree_getiterator_filter(self):

2432 Element = self.etree.Element 2433 SubElement = self.etree.SubElement 2434 ElementTree = self.etree.ElementTree 2435 a = Element('a') 2436 b = SubElement(a, 'b') 2437 c = SubElement(a, 'c') 2438 d = SubElement(b, 'd') 2439 e = SubElement(c, 'e') 2440 t = ElementTree(element=a) 2441 2442 self.assertEqual( 2443 [a], 2444 list(t.getiterator('a'))) 2445 a2 = SubElement(e, 'a') 2446 self.assertEqual( 2447 [a, a2], 2448 list(t.getiterator('a')))

2449

2450 - def test_ns_access(self):

2451 ElementTree = self.etree.ElementTree 2452 ns = 'http://xml.infrae.com/1' 2453 f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2454 t = ElementTree(file=f) 2455 a = t.getroot() 2456 self.assertEqual('{%s}a' % ns, 2457 a.tag) 2458 self.assertEqual('{%s}b' % ns, 2459 a[0].tag)

2460

2461 - def test_ns_access2(self):

2462 ElementTree = self.etree.ElementTree 2463 ns = 'http://xml.infrae.com/1' 2464 ns2 = 'http://xml.infrae.com/2' 2465 f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2466 t = ElementTree(file=f) 2467 a = t.getroot() 2468 self.assertEqual('{%s}a' % ns, 2469 a.tag) 2470 self.assertEqual('{%s}b' % ns, 2471 a[0].tag) 2472 self.assertEqual('{%s}b' % ns2, 2473 a[1].tag)

2474

2475 - def test_ns_setting(self):

2476 Element = self.etree.Element 2477 SubElement = self.etree.SubElement 2478 ns = 'http://xml.infrae.com/1' 2479 ns2 = 'http://xml.infrae.com/2' 2480 a = Element('{%s}a' % ns) 2481 b = SubElement(a, '{%s}b' % ns2) 2482 c = SubElement(a, '{%s}c' % ns) 2483 self.assertEqual('{%s}a' % ns, 2484 a.tag) 2485 self.assertEqual('{%s}b' % ns2, 2486 b.tag) 2487 self.assertEqual('{%s}c' % ns, 2488 c.tag) 2489 self.assertEqual('{%s}a' % ns, 2490 a.tag) 2491 self.assertEqual('{%s}b' % ns2, 2492 b.tag) 2493 self.assertEqual('{%s}c' % ns, 2494 c.tag)

2495

2496 - def test_ns_tag_parse(self):

2497 Element = self.etree.Element 2498 SubElement = self.etree.SubElement 2499 ElementTree = self.etree.ElementTree 2500 2501 ns = 'http://xml.infrae.com/1' 2502 ns2 = 'http://xml.infrae.com/2' 2503 f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2504 t = ElementTree(file=f) 2505 2506 a = t.getroot() 2507 self.assertEqual('{%s}a' % ns, 2508 a.tag) 2509 self.assertEqual('{%s}b' % ns2, 2510 a[0].tag) 2511 self.assertEqual('{%s}b' % ns, 2512 a[1].tag)

2513

2514 - def test_ns_attr(self):

2515 Element = self.etree.Element 2516 ns = 'http://xml.infrae.com/1' 2517 ns2 = 'http://xml.infrae.com/2' 2518 a = Element('a') 2519 a.set('{%s}foo' % ns, 'Foo') 2520 a.set('{%s}bar' % ns2, 'Bar') 2521 self.assertEqual( 2522 'Foo', 2523 a.get('{%s}foo' % ns)) 2524 self.assertEqual( 2525 'Bar', 2526 a.get('{%s}bar' % ns2)) 2527 try: 2528 self.assertXML( 2529 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 2530 a) 2531 except AssertionError: 2532 self.assertXML( 2533 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 2534 a)

2535

2536 - def test_ns_move(self):

2537 Element = self.etree.Element 2538 one = self.etree.fromstring( 2539 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2540 baz = one[0][0] 2541 2542 two = Element('root') 2543 two.append(baz) 2544 # removing the originating document could cause a crash/error before 2545 # as namespace is not moved along with it 2546 del one, baz 2547 self.assertEqual('{http://a.b.c}baz', two[0].tag)

2548

2549 - def test_ns_decl_tostring(self):

2550 tostring = self.etree.tostring 2551 root = self.etree.XML( 2552 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2553 baz = root[0][0] 2554 2555 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2556 tostring(baz)) 2557 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2558

2559 - def test_ns_decl_tostring_default(self):

2560 tostring = self.etree.tostring 2561 root = self.etree.XML( 2562 _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 2563 baz = root[0][0] 2564 2565 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2566 tostring(baz)) 2567 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2568

2569 - def test_ns_decl_tostring_root(self):

2570 tostring = self.etree.tostring 2571 root = self.etree.XML( 2572 _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')) 2573 baz = root[0][0] 2574 2575 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2576 tostring(baz)) 2577 2578 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2579

2580 - def test_ns_decl_tostring_element(self):

2581 Element = self.etree.Element 2582 SubElement = self.etree.SubElement 2583 2584 root = Element("foo") 2585 bar = SubElement(root, "{http://a.b.c}bar") 2586 baz = SubElement(bar, "{http://a.b.c}baz") 2587 2588 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2589 self.etree.tostring(baz)) 2590 2591 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2592

2593 - def test_attribute_xmlns_move(self):

2594 Element = self.etree.Element 2595 2596 root = Element('element') 2597 2598 subelement = Element('subelement', 2599 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2600 self.assertEqual(1, len(subelement.attrib)) 2601 self.assertEqual( 2602 "foo", 2603 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2604 2605 root.append(subelement) 2606 self.assertEqual(1, len(subelement.attrib)) 2607 self.assertEqual( 2608 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 2609 list(subelement.attrib.items())) 2610 self.assertEqual( 2611 "foo", 2612 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2613

2614 - def test_namespaces_after_serialize(self):

2615 parse = self.etree.parse 2616 tostring = self.etree.tostring 2617 2618 ns_href = "http://a.b.c" 2619 one = parse( 2620 BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2621 baz = one.getroot()[0][0] 2622 2623 parsed = parse(BytesIO( tostring(baz) )).getroot() 2624 self.assertEqual('{%s}baz' % ns_href, parsed.tag)

2625

2626 - def test_attribute_namespace_roundtrip(self):

2627 fromstring = self.etree.fromstring 2628 tostring = self.etree.tostring 2629 2630 ns_href = "http://a.b.c" 2631 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2632 ns_href,ns_href)) 2633 root = fromstring(xml) 2634 self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 2635 2636 xml2 = tostring(root) 2637 self.assertTrue(_bytes(':a=') in xml2, xml2) 2638 2639 root2 = fromstring(xml2) 2640 self.assertEqual('test', root2[0].get('{%s}a' % ns_href))

2641

2642 - def test_attribute_namespace_roundtrip_replaced(self):

2643 fromstring = self.etree.fromstring 2644 tostring = self.etree.tostring 2645 2646 ns_href = "http://a.b.c" 2647 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2648 ns_href,ns_href)) 2649 root = fromstring(xml) 2650 self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 2651 2652 root[0].set('{%s}a' % ns_href, 'TEST') 2653 2654 xml2 = tostring(root) 2655 self.assertTrue(_bytes(':a=') in xml2, xml2) 2656 2657 root2 = fromstring(xml2) 2658 self.assertEqual('TEST', root2[0].get('{%s}a' % ns_href))

2659 2660 required_versions_ET['test_register_namespace'] = (1,3)

2661 - def test_register_namespace(self):

2662 # ET 1.3+ 2663 Element = self.etree.Element 2664 prefix = 'TESTPREFIX' 2665 namespace = 'http://seriously.unknown/namespace/URI' 2666 2667 el = Element('{%s}test' % namespace) 2668 self.assertEqual(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 2669 self._writeElement(el)) 2670 2671 self.etree.register_namespace(prefix, namespace) 2672 el = Element('{%s}test' % namespace) 2673 self.assertEqual(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 2674 prefix, prefix, namespace, prefix)), 2675 self._writeElement(el)) 2676 2677 self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace)

2678

2679 - def test_tostring(self):

2680 tostring = self.etree.tostring 2681 Element = self.etree.Element 2682 SubElement = self.etree.SubElement 2683 2684 a = Element('a') 2685 b = SubElement(a, 'b') 2686 c = SubElement(a, 'c') 2687 2688 self.assertEqual(_bytes('<a><c></c></a>'), 2689 canonicalize(tostring(a)))

2690

2691 - def test_tostring_element(self):

2692 tostring = self.etree.tostring 2693 Element = self.etree.Element 2694 SubElement = self.etree.SubElement 2695 2696 a = Element('a') 2697 b = SubElement(a, 'b') 2698 c = SubElement(a, 'c') 2699 d = SubElement(c, 'd') 2700 self.assertEqual(_bytes(''), 2701 canonicalize(tostring(b))) 2702 self.assertEqual(_bytes('<c><d></d></c>'), 2703 canonicalize(tostring(c)))

2704

2705 - def test_tostring_element_tail(self):

2706 tostring = self.etree.tostring 2707 Element = self.etree.Element 2708 SubElement = self.etree.SubElement 2709 2710 a = Element('a') 2711 b = SubElement(a, 'b') 2712 c = SubElement(a, 'c') 2713 d = SubElement(c, 'd') 2714 b.tail = 'Foo' 2715 2716 self.assertTrue(tostring(b) == _bytes('Foo') or 2717 tostring(b) == _bytes('Foo'))

2718 2719 required_versions_ET['test_tostring_method_html'] = (1,3)

2720 - def test_tostring_method_html(self):

2721 tostring = self.etree.tostring 2722 Element = self.etree.Element 2723 SubElement = self.etree.SubElement 2724 2725 html = Element('html') 2726 body = SubElement(html, 'body') 2727 p = SubElement(body, 'p') 2728 p.text = "html" 2729 SubElement(p, 'br').tail = "test" 2730 2731 self.assertEqual(_bytes('<html><body>html test</body></html>'), 2732 tostring(html, method="html"))

2733 2734 required_versions_ET['test_tostring_method_text'] = (1,3)

2735 - def test_tostring_method_text(self):

2736 tostring = self.etree.tostring 2737 Element = self.etree.Element 2738 SubElement = self.etree.SubElement 2739 2740 a = Element('a') 2741 a.text = "A" 2742 a.tail = "tail" 2743 b = SubElement(a, 'b') 2744 b.text = "B" 2745 b.tail = "TAIL" 2746 c = SubElement(a, 'c') 2747 c.text = "C" 2748 2749 self.assertEqual(_bytes('ABTAILCtail'), 2750 tostring(a, method="text"))

2751

2752 - def test_iterparse(self):

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

2764

2765 - def test_iterparse_file(self):

2766 iterparse = self.etree.iterparse 2767 iterator = iterparse(fileInTestDir("test.xml")) 2768 self.assertEqual(None, 2769 iterator.root) 2770 events = list(iterator) 2771 root = iterator.root 2772 self.assertEqual( 2773 [('end', root[0]), ('end', root)], 2774 events)

2775

2776 - def test_iterparse_start(self):

2777 iterparse = self.etree.iterparse 2778 f = BytesIO('<a><c/></a>') 2779 2780 iterator = iterparse(f, events=('start',)) 2781 events = list(iterator) 2782 root = iterator.root 2783 self.assertEqual( 2784 [('start', root), ('start', root[0]), ('start', root[1])], 2785 events)

2786

2787 - def test_iterparse_start_end(self):

2788 iterparse = self.etree.iterparse 2789 f = BytesIO('<a><c/></a>') 2790 2791 iterator = iterparse(f, events=('start','end')) 2792 events = list(iterator) 2793 root = iterator.root 2794 self.assertEqual( 2795 [('start', root), ('start', root[0]), ('end', root[0]), 2796 ('start', root[1]), ('end', root[1]), ('end', root)], 2797 events)

2798

2799 - def test_iterparse_clear(self):

2800 iterparse = self.etree.iterparse 2801 f = BytesIO('<a><c/></a>') 2802 2803 iterator = iterparse(f) 2804 for event, elem in iterator: 2805 elem.clear() 2806 2807 root = iterator.root 2808 self.assertEqual(0, 2809 len(root))

2810

2811 - def test_iterparse_large(self):

2812 iterparse = self.etree.iterparse 2813 CHILD_COUNT = 12345 2814 f = BytesIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2815 2816 i = 0 2817 for key in iterparse(f): 2818 event, element = key 2819 i += 1 2820 self.assertEqual(i, CHILD_COUNT + 1)

2821

2822 - def test_iterparse_attrib_ns(self):

2823 iterparse = self.etree.iterparse 2824 f = BytesIO('<a xmlns="http://ns1/"><c xmlns="http://ns2/"/></a>') 2825 2826 attr_name = '{http://testns/}bla' 2827 events = [] 2828 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2829 for event, elem in iterator: 2830 events.append(event) 2831 if event == 'start': 2832 if elem.tag != '{http://ns1/}a': 2833 elem.set(attr_name, 'value') 2834 2835 self.assertEqual( 2836 ['start-ns', 'start', 'start', 'start-ns', 'start', 2837 'end', 'end-ns', 'end', 'end', 'end-ns'], 2838 events) 2839 2840 root = iterator.root 2841 self.assertEqual( 2842 None, 2843 root.get(attr_name)) 2844 self.assertEqual( 2845 'value', 2846 root[0].get(attr_name))

2847

2848 - def test_iterparse_getiterator(self):

2849 iterparse = self.etree.iterparse 2850 f = BytesIO('<a><d/><c/></a>') 2851 2852 counts = [] 2853 for event, elem in iterparse(f): 2854 counts.append(len(list(elem.getiterator()))) 2855 self.assertEqual( 2856 [1,2,1,4], 2857 counts)

2858

2859 - def test_iterparse_move_elements(self):

2860 iterparse = self.etree.iterparse 2861 f = BytesIO('<a><d/><c/></a>') 2862 2863 for event, node in etree.iterparse(f): pass 2864 2865 root = etree.Element('new_root', {}) 2866 root[:] = node[:] 2867 2868 self.assertEqual( 2869 ['b', 'c'], 2870 [ el.tag for el in root ])

2871

2872 - def test_iterparse_cdata(self):

2873 tostring = self.etree.tostring 2874 f = BytesIO('<root><![CDATA[test]]></root>') 2875 context = self.etree.iterparse(f) 2876 content = [ el.text for event,el in context ] 2877 2878 self.assertEqual(['test'], content) 2879 self.assertEqual(_bytes('<root>test</root>'), 2880 tostring(context.root))

2881

2882 - def test_parse_file(self):

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

2889

2890 - def test_parse_file_nonexistent(self):

2891 parse = self.etree.parse 2892 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2893

2894 - def test_parse_error_none(self):

2895 parse = self.etree.parse 2896 self.assertRaises(TypeError, parse, None)

2897 2898 required_versions_ET['test_parse_error'] = (1,3)

2899 - def test_parse_error(self):

2900 # ET < 1.3 raises ExpatError 2901 parse = self.etree.parse 2902 f = BytesIO('<a></c></a>') 2903 self.assertRaises(SyntaxError, parse, f) 2904 f.close()

2905 2906 required_versions_ET['test_parse_error_from_file'] = (1,3)

2907 - def test_parse_error_from_file(self):

2908 parse = self.etree.parse 2909 # from file 2910 f = open(fileInTestDir('test_broken.xml'), 'rb') 2911 self.assertRaises(SyntaxError, parse, f) 2912 f.close()

2913

2914 - def test_parse_file_object(self):

2915 parse = self.etree.parse 2916 # from file object 2917 f = open(fileInTestDir('test.xml'), 'rb') 2918 tree = parse(f) 2919 f.close() 2920 self.assertXML( 2921 _bytes('<a></a>'), 2922 tree.getroot())

2923

2924 - def test_parse_stringio(self):

2925 parse = self.etree.parse 2926 f = BytesIO('<a></a>') 2927 tree = parse(f) 2928 f.close() 2929 self.assertXML( 2930 _bytes('<a></a>'), 2931 tree.getroot() 2932 )

2933

2934 - def test_parse_cdata(self):

2935 tostring = self.etree.tostring 2936 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 2937 2938 self.assertEqual('test', root.text) 2939 self.assertEqual(_bytes('<root>test</root>'), 2940 tostring(root))

2941

2942 - def test_parse_with_encoding(self):

2943 # this can fail in libxml2 <= 2.6.22 2944 parse = self.etree.parse 2945 tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2946 self.assertXML(_bytes('<html></html>'), 2947 tree.getroot())

2948

2949 - def test_encoding(self):

2950 Element = self.etree.Element 2951 2952 a = Element('a') 2953 a.text = _str('Søk på nettet') 2954 self.assertXML( 2955 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2956 a, 'utf-8')

2957

2958 - def test_encoding_exact(self):

2959 ElementTree = self.etree.ElementTree 2960 Element = self.etree.Element 2961 2962 a = Element('a') 2963 a.text = _str('Søk på nettet') 2964 2965 f = BytesIO() 2966 tree = ElementTree(element=a) 2967 tree.write(f, encoding='utf-8') 2968 self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 2969 f.getvalue().replace(_bytes('\n'),_bytes('')))

2970

2971 - def test_parse_file_encoding(self):

2972 parse = self.etree.parse 2973 # from file 2974 tree = parse(fileInTestDir('test-string.xml')) 2975 self.assertXML( 2976 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2977 tree.getroot(), 'UTF-8')

2978

2979 - def test_parse_file_object_encoding(self):

2980 parse = self.etree.parse 2981 # from file object 2982 f = open(fileInTestDir('test-string.xml'), 'rb') 2983 tree = parse(f) 2984 f.close() 2985 self.assertXML( 2986 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2987 tree.getroot(), 'UTF-8')

2988

2989 - def test_encoding_8bit_latin1(self):

2990 ElementTree = self.etree.ElementTree 2991 Element = self.etree.Element 2992 2993 a = Element('a') 2994 a.text = _str('Søk på nettet') 2995 2996 f = BytesIO() 2997 tree = ElementTree(element=a) 2998 tree.write(f, encoding='iso-8859-1') 2999 result = f.getvalue() 3000 declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 3001 self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 3002 result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 3003 self.assertEqual(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 3004 result)

3005 3006 required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3)

3007 - def test_parse_encoding_8bit_explicit(self):

3008 XMLParser = self.etree.XMLParser 3009 3010 text = _str('Søk på nettet') 3011 xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 3012 3013 self.assertRaises(self.etree.ParseError, 3014 self.etree.parse, 3015 BytesIO(xml_latin1)) 3016 3017 tree = self.etree.parse(BytesIO(xml_latin1), 3018 XMLParser(encoding="iso-8859-1")) 3019 a = tree.getroot() 3020 self.assertEqual(a.text, text)

3021 3022 required_versions_ET['test_parse_encoding_8bit_override'] = (1,3)

3023 - def test_parse_encoding_8bit_override(self):

3024 XMLParser = self.etree.XMLParser 3025 3026 text = _str('Søk på nettet') 3027 wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>") 3028 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 3029 ).encode('iso-8859-1') 3030 3031 self.assertRaises(self.etree.ParseError, 3032 self.etree.parse, 3033 BytesIO(xml_latin1)) 3034 3035 tree = self.etree.parse(BytesIO(xml_latin1), 3036 XMLParser(encoding="iso-8859-1")) 3037 a = tree.getroot() 3038 self.assertEqual(a.text, text)

3039

3040 - def _test_wrong_unicode_encoding(self):

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

3046

3047 - def test_encoding_write_default_encoding(self):

3048 ElementTree = self.etree.ElementTree 3049 Element = self.etree.Element 3050 3051 a = Element('a') 3052 a.text = _str('Søk på nettet') 3053 3054 f = BytesIO() 3055 tree = ElementTree(element=a) 3056 tree.write(f) 3057 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 3058 self.assertEqual( 3059 _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 3060 data)

3061

3062 - def test_encoding_tostring(self):

3063 Element = self.etree.Element 3064 tostring = self.etree.tostring 3065 3066 a = Element('a') 3067 a.text = _str('Søk på nettet') 3068 self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 3069 tostring(a, encoding='utf-8'))

3070

3071 - def test_encoding_tostring_unknown(self):

3072 Element = self.etree.Element 3073 tostring = self.etree.tostring 3074 3075 a = Element('a') 3076 a.text = _str('Søk på nettet') 3077 self.assertRaises(LookupError, tostring, a, 3078 encoding='Invalid Encoding')

3079

3080 - def test_encoding_tostring_sub(self):

3081 Element = self.etree.Element 3082 SubElement = self.etree.SubElement 3083 tostring = self.etree.tostring 3084 3085 a = Element('a') 3086 b = SubElement(a, 'b') 3087 b.text = _str('Søk på nettet') 3088 self.assertEqual(_str('Søk på nettet').encode('UTF-8'), 3089 tostring(b, encoding='utf-8'))

3090

3091 - def test_encoding_tostring_sub_tail(self):

3092 Element = self.etree.Element 3093 SubElement = self.etree.SubElement 3094 tostring = self.etree.tostring 3095 3096 a = Element('a') 3097 b = SubElement(a, 'b') 3098 b.text = _str('Søk på nettet') 3099 b.tail = _str('Søk') 3100 self.assertEqual(_str('Søk på nettetSøk').encode('UTF-8'), 3101 tostring(b, encoding='utf-8'))

3102

3103 - def test_encoding_tostring_default_encoding(self):

3104 Element = self.etree.Element 3105 SubElement = self.etree.SubElement 3106 tostring = self.etree.tostring 3107 3108 a = Element('a') 3109 a.text = _str('Søk på nettet') 3110 3111 expected = _bytes('<a>Søk på nettet</a>') 3112 self.assertEqual( 3113 expected, 3114 tostring(a))

3115

3116 - def test_encoding_sub_tostring_default_encoding(self):

3117 Element = self.etree.Element 3118 SubElement = self.etree.SubElement 3119 tostring = self.etree.tostring 3120 3121 a = Element('a') 3122 b = SubElement(a, 'b') 3123 b.text = _str('Søk på nettet') 3124 3125 expected = _bytes('Søk på nettet') 3126 self.assertEqual( 3127 expected, 3128 tostring(b))

3129

3130 - def test_encoding_8bit_xml(self):

3131 utext = _str('Søk på nettet') 3132 uxml = _str('%s') % utext 3133 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3134 isoxml = prologue + uxml.encode('iso-8859-1') 3135 tree = self.etree.XML(isoxml) 3136 self.assertEqual(utext, tree.text)

3137

3138 - def test_encoding_utf8_bom(self):

3139 utext = _str('Søk på nettet') 3140 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 3141 _str('%s') % utext) 3142 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 3143 xml = bom + uxml.encode("utf-8") 3144 tree = etree.XML(xml) 3145 self.assertEqual(utext, tree.text)

3146

3147 - def test_encoding_8bit_parse_stringio(self):

3148 utext = _str('Søk på nettet') 3149 uxml = _str('%s') % utext 3150 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3151 isoxml = prologue + uxml.encode('iso-8859-1') 3152 el = self.etree.parse(BytesIO(isoxml)).getroot() 3153 self.assertEqual(utext, el.text)

3154

3155 - def test_deepcopy_elementtree(self):

3156 Element = self.etree.Element 3157 ElementTree = self.etree.ElementTree 3158 3159 a = Element('a') 3160 a.text = "Foo" 3161 atree = ElementTree(a) 3162 3163 btree = copy.deepcopy(atree) 3164 self.assertEqual("Foo", atree.getroot().text) 3165 self.assertEqual("Foo", btree.getroot().text) 3166 self.assertFalse(btree is atree) 3167 self.assertFalse(btree.getroot() is atree.getroot())

3168

3169 - def test_deepcopy(self):

3170 Element = self.etree.Element 3171 3172 a = Element('a') 3173 a.text = 'Foo' 3174 3175 b = copy.deepcopy(a) 3176 self.assertEqual('Foo', b.text) 3177 3178 b.text = 'Bar' 3179 self.assertEqual('Bar', b.text) 3180 self.assertEqual('Foo', a.text) 3181 3182 del a 3183 self.assertEqual('Bar', b.text)

3184

3185 - def test_deepcopy_tail(self):

3186 Element = self.etree.Element 3187 3188 a = Element('a') 3189 a.tail = 'Foo' 3190 3191 b = copy.deepcopy(a) 3192 self.assertEqual('Foo', b.tail) 3193 3194 b.tail = 'Bar' 3195 self.assertEqual('Bar', b.tail) 3196 self.assertEqual('Foo', a.tail) 3197 3198 del a 3199 self.assertEqual('Bar', b.tail)

3200

3201 - def test_deepcopy_subelement(self):

3202 Element = self.etree.Element 3203 SubElement = self.etree.SubElement 3204 3205 root = Element('root') 3206 a = SubElement(root, 'a') 3207 a.text = 'FooText' 3208 a.tail = 'FooTail' 3209 3210 b = copy.deepcopy(a) 3211 self.assertEqual('FooText', b.text) 3212 self.assertEqual('FooTail', b.tail) 3213 3214 b.text = 'BarText' 3215 b.tail = 'BarTail' 3216 self.assertEqual('BarTail', b.tail) 3217 self.assertEqual('FooTail', a.tail) 3218 self.assertEqual('BarText', b.text) 3219 self.assertEqual('FooText', a.text) 3220 3221 del a 3222 self.assertEqual('BarTail', b.tail) 3223 self.assertEqual('BarText', b.text)

3224

3225 - def test_deepcopy_namespaces(self):

3226 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 3227 <parent><node t:foo="bar" /></parent> 3228 </doc>''')) 3229 self.assertEqual( 3230 root[0][0].get('{tns}foo'), 3231 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3232 self.assertEqual( 3233 root[0][0].get('{tns}foo'), 3234 copy.deepcopy(root[0][0]).get('{tns}foo') )

3235

3236 - def test_deepcopy_append(self):

3237 # previously caused a crash 3238 Element = self.etree.Element 3239 tostring = self.etree.tostring 3240 3241 a = Element('a') 3242 b = copy.deepcopy(a) 3243 a.append( Element('C') ) 3244 b.append( Element('X') ) 3245 3246 self.assertEqual(_bytes('<a><C/></a>'), 3247 tostring(a).replace(_bytes(' '), _bytes(''))) 3248 self.assertEqual(_bytes('<a><X/></a>'), 3249 tostring(b).replace(_bytes(' '), _bytes('')))

3250

3251 - def test_deepcopy_comment(self):

3252 # previously caused a crash 3253 # not supported by ET < 1.3! 3254 Comment = self.etree.Comment 3255 3256 a = Comment("ONE") 3257 b = copy.deepcopy(a) 3258 b.text = "ANOTHER" 3259 3260 self.assertEqual('ONE', a.text) 3261 self.assertEqual('ANOTHER', b.text)

3262

3263 - def test_shallowcopy(self):

3264 Element = self.etree.Element 3265 3266 a = Element('a') 3267 a.text = 'Foo' 3268 3269 b = copy.copy(a) 3270 self.assertEqual('Foo', b.text) 3271 3272 b.text = 'Bar' 3273 self.assertEqual('Bar', b.text) 3274 self.assertEqual('Foo', a.text)

3275 # XXX ElementTree will share nodes, but lxml.etree won't.. 3276

3277 - def test_shallowcopy_elementtree(self):

3278 Element = self.etree.Element 3279 ElementTree = self.etree.ElementTree 3280 3281 a = Element('a') 3282 a.text = 'Foo' 3283 atree = ElementTree(a) 3284 3285 btree = copy.copy(atree) 3286 self.assertFalse(btree is atree) 3287 self.assertTrue(btree.getroot() is atree.getroot()) 3288 self.assertEqual('Foo', atree.getroot().text)

3289

3290 - def _test_element_boolean(self):

3291 # deprecated as of ET 1.3/lxml 2.0 3292 etree = self.etree 3293 e = etree.Element('foo') 3294 self.assertEqual(False, bool(e)) 3295 etree.SubElement(e, 'bar') 3296 self.assertEqual(True, bool(e)) 3297 e = etree.Element('foo') 3298 e.text = 'hey' 3299 self.assertEqual(False, bool(e)) 3300 e = etree.Element('foo') 3301 e.tail = 'bar' 3302 self.assertEqual(False, bool(e)) 3303 e = etree.Element('foo') 3304 e.set('bar', 'Bar') 3305 self.assertEqual(False, bool(e))

3306

3307 - def test_multiple_elementrees(self):

3308 etree = self.etree 3309 3310 a = etree.Element('a') 3311 b = etree.SubElement(a, 'b') 3312 3313 t = etree.ElementTree(a) 3314 self.assertEqual(self._rootstring(t), _bytes('<a></a>')) 3315 3316 t1 = etree.ElementTree(a) 3317 self.assertEqual(self._rootstring(t1), _bytes('<a></a>')) 3318 self.assertEqual(self._rootstring(t), _bytes('<a></a>')) 3319 3320 t2 = etree.ElementTree(b) 3321 self.assertEqual(self._rootstring(t2), _bytes('')) 3322 self.assertEqual(self._rootstring(t1), _bytes('<a></a>')) 3323 self.assertEqual(self._rootstring(t), _bytes('<a></a>'))

3324

3325 - def test_qname(self):

3326 etree = self.etree 3327 qname = etree.QName('myns', 'a') 3328 a1 = etree.Element(qname) 3329 a2 = etree.SubElement(a1, qname) 3330 self.assertEqual(a1.tag, "{myns}a") 3331 self.assertEqual(a2.tag, "{myns}a")

3332

3333 - def test_qname_cmp(self):

3334 etree = self.etree 3335 qname1 = etree.QName('myns', 'a') 3336 qname2 = etree.QName('myns', 'a') 3337 self.assertEqual(qname1, "{myns}a") 3338 self.assertEqual("{myns}a", qname2) 3339 self.assertEqual(qname1, qname1) 3340 self.assertEqual(qname1, qname2)

3341

3342 - def test_qname_attribute_getset(self):

3343 etree = self.etree 3344 qname = etree.QName('myns', 'a') 3345 3346 a = etree.Element(qname) 3347 a.set(qname, "value") 3348 3349 self.assertEqual(a.get(qname), "value") 3350 self.assertEqual(a.get("{myns}a"), "value")

3351

3352 - def test_qname_attrib(self):

3353 etree = self.etree 3354 qname = etree.QName('myns', 'a') 3355 3356 a = etree.Element(qname) 3357 a.attrib[qname] = "value" 3358 3359 self.assertEqual(a.attrib[qname], "value") 3360 self.assertEqual(a.attrib.get(qname), "value") 3361 3362 self.assertEqual(a.attrib["{myns}a"], "value") 3363 self.assertEqual(a.attrib.get("{myns}a"), "value")

3364

3365 - def test_qname_attribute_resolve(self):

3366 etree = self.etree 3367 qname = etree.QName('http://myns', 'a') 3368 a = etree.Element(qname) 3369 a.set(qname, qname) 3370 3371 self.assertXML( 3372 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3373 a)

3374

3375 - def test_qname_attribute_resolve_new(self):

3376 etree = self.etree 3377 qname = etree.QName('http://myns', 'a') 3378 a = etree.Element('a') 3379 a.set('a', qname) 3380 3381 self.assertXML( 3382 _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 3383 a)

3384

3385 - def test_qname_attrib_resolve(self):

3386 etree = self.etree 3387 qname = etree.QName('http://myns', 'a') 3388 a = etree.Element(qname) 3389 a.attrib[qname] = qname 3390 3391 self.assertXML( 3392 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3393 a)

3394

3395 - def test_parser_version(self):

3396 etree = self.etree 3397 parser = etree.XMLParser() 3398 if hasattr(parser, "version"): 3399 # ElementTree 1.3+, cET 3400 self.assertTrue(re.match("[^ ]+ [0-9.]+", parser.version))

3401 3402 # feed parser interface 3403

3404 - def test_feed_parser_bytes(self):

3405 parser = self.etree.XMLParser() 3406 3407 parser.feed(_bytes('<?xml version=')) 3408 parser.feed(_bytes('"1.0"?><ro')) 3409 parser.feed(_bytes('ot><')) 3410 parser.feed(_bytes('a test="works"/')) 3411 parser.feed(_bytes('></root')) 3412 parser.feed(_bytes('>')) 3413 3414 root = parser.close() 3415 3416 self.assertEqual(root.tag, "root") 3417 self.assertEqual(root[0].tag, "a") 3418 self.assertEqual(root[0].get("test"), "works")

3419

3420 - def test_feed_parser_unicode(self):

3421 parser = self.etree.XMLParser() 3422 3423 parser.feed(_str('<ro')) 3424 parser.feed(_str('ot><')) 3425 parser.feed(_str('a test="works"/')) 3426 parser.feed(_str('></root')) 3427 parser.feed(_str('>')) 3428 3429 root = parser.close() 3430 3431 self.assertEqual(root.tag, "root") 3432 self.assertEqual(root[0].tag, "a") 3433 self.assertEqual(root[0].get("test"), "works")

3434 3435 required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)

3436 - def test_feed_parser_error_close_empty(self):

3437 ParseError = self.etree.ParseError 3438 parser = self.etree.XMLParser() 3439 self.assertRaises(ParseError, parser.close)

3440 3441 required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3)

3442 - def test_feed_parser_error_close_incomplete(self):

3443 ParseError = self.etree.ParseError 3444 parser = self.etree.XMLParser() 3445 3446 parser.feed('<?xml version=') 3447 parser.feed('"1.0"?><ro') 3448 3449 self.assertRaises(ParseError, parser.close)

3450 3451 required_versions_ET['test_feed_parser_error_broken'] = (1,3)

3452 - def test_feed_parser_error_broken(self):

3453 ParseError = self.etree.ParseError 3454 parser = self.etree.XMLParser() 3455 3456 parser.feed('<?xml version=') 3457 parser.feed('"1.0"?><ro') 3458 try: 3459 parser.feed('<><><><><><><') 3460 except ParseError: 3461 # can raise, but not required before close() 3462 pass 3463 3464 self.assertRaises(ParseError, parser.close)

3465 3466 required_versions_ET['test_feed_parser_error_position'] = (1,3)

3467 - def test_feed_parser_error_position(self):

3468 ParseError = self.etree.ParseError 3469 parser = self.etree.XMLParser() 3470 try: 3471 parser.close() 3472 except ParseError: 3473 e = sys.exc_info()[1] 3474 self.assertNotEqual(None, e.code) 3475 self.assertNotEqual(0, e.code) 3476 self.assertTrue(isinstance(e.position, tuple)) 3477 self.assertTrue(e.position >= (0, 0))

3478 3479 # parser target interface 3480 3481 required_versions_ET['test_parser_target_property'] = (1,3)

3482 - def test_parser_target_property(self):

3483 class Target(object): 3484 pass

3485 3486 target = Target() 3487 parser = self.etree.XMLParser(target=target) 3488 3489 self.assertEqual(target, parser.target) 3490

3491 - def test_parser_target_tag(self):

3492 assertEqual = self.assertEqual 3493 assertFalse = self.assertFalse 3494 3495 events = [] 3496 class Target(object): 3497 def start(self, tag, attrib): 3498 events.append("start") 3499 assertFalse(attrib) 3500 assertEqual("TAG", tag)

3501 def end(self, tag): 3502 events.append("end") 3503 assertEqual("TAG", tag) 3504 def close(self): 3505 return "DONE" 3506 3507 parser = self.etree.XMLParser(target=Target()) 3508 3509 parser.feed("<TAG/>") 3510 done = parser.close() 3511 3512 self.assertEqual("DONE", done) 3513 self.assertEqual(["start", "end"], events) 3514

3515 - def test_parser_target_error_in_start(self):

3516 assertEqual = self.assertEqual 3517 3518 events = [] 3519 class Target(object): 3520 def start(self, tag, attrib): 3521 events.append("start") 3522 assertEqual("TAG", tag) 3523 raise ValueError("TEST")

3524 def end(self, tag): 3525 events.append("end") 3526 assertEqual("TAG", tag) 3527 def close(self): 3528 return "DONE" 3529 3530 parser = self.etree.XMLParser(target=Target()) 3531 3532 try: 3533 parser.feed("<TAG/>") 3534 except ValueError: 3535 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3536 else: 3537 self.assertTrue(False) 3538 if 'lxml' in self.etree.__name__: 3539 self.assertEqual(["start"], events) 3540 else: 3541 # cElementTree calls end() as well 3542 self.assertTrue("start" in events) 3543

3544 - def test_parser_target_error_in_end(self):

3545 assertEqual = self.assertEqual 3546 3547 events = [] 3548 class Target(object): 3549 def start(self, tag, attrib): 3550 events.append("start") 3551 assertEqual("TAG", tag)

3552 def end(self, tag): 3553 events.append("end") 3554 assertEqual("TAG", tag) 3555 raise ValueError("TEST") 3556 def close(self): 3557 return "DONE" 3558 3559 parser = self.etree.XMLParser(target=Target()) 3560 3561 try: 3562 parser.feed("<TAG/>") 3563 except ValueError: 3564 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3565 else: 3566 self.assertTrue(False) 3567 self.assertEqual(["start", "end"], events) 3568

3569 - def test_parser_target_error_in_close(self):

3570 assertEqual = self.assertEqual 3571 3572 events = [] 3573 class Target(object): 3574 def start(self, tag, attrib): 3575 events.append("start") 3576 assertEqual("TAG", tag)

3577 def end(self, tag): 3578 events.append("end") 3579 assertEqual("TAG", tag) 3580 def close(self): 3581 raise ValueError("TEST") 3582 3583 parser = self.etree.XMLParser(target=Target()) 3584 3585 try: 3586 parser.feed("<TAG/>") 3587 parser.close() 3588 except ValueError: 3589 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3590 else: 3591 self.assertTrue(False) 3592 self.assertEqual(["start", "end"], events) 3593

3594 - def test_parser_target_error_in_start_and_close(self):

3595 assertEqual = self.assertEqual 3596 3597 events = [] 3598 class Target(object): 3599 def start(self, tag, attrib): 3600 events.append("start") 3601 assertEqual("TAG", tag) 3602 raise IndexError("TEST-IE")

3603 def end(self, tag): 3604 events.append("end") 3605 assertEqual("TAG", tag) 3606 def close(self): 3607 raise ValueError("TEST-VE") 3608 3609 parser = self.etree.XMLParser(target=Target()) 3610 3611 try: 3612 parser.feed("<TAG/>") 3613 parser.close() 3614 except IndexError: 3615 if 'lxml' in self.etree.__name__: 3616 # we try not to swallow the initial exception in Py2 3617 self.assertTrue(sys.version_info[0] < 3) 3618 self.assertTrue('TEST-IE' in str(sys.exc_info()[1])) 3619 except ValueError: 3620 if 'lxml' in self.etree.__name__: 3621 self.assertTrue(sys.version_info[0] >= 3) 3622 self.assertTrue('TEST-VE' in str(sys.exc_info()[1])) 3623 else: 3624 self.assertTrue(False) 3625 3626 if 'lxml' in self.etree.__name__: 3627 self.assertEqual(["start"], events) 3628 else: 3629 # cElementTree calls end() as well 3630 self.assertTrue("start" in events) 3631

3632 - def test_elementtree_parser_target(self):

3633 assertEqual = self.assertEqual 3634 assertFalse = self.assertFalse 3635 Element = self.etree.Element 3636 3637 events = [] 3638 class Target(object): 3639 def start(self, tag, attrib): 3640 events.append("start") 3641 assertFalse(attrib) 3642 assertEqual("TAG", tag)

3643 def end(self, tag): 3644 events.append("end") 3645 assertEqual("TAG", tag) 3646 def close(self): 3647 return Element("DONE") 3648 3649 parser = self.etree.XMLParser(target=Target()) 3650 tree = self.etree.ElementTree() 3651 tree.parse(BytesIO("<TAG/>"), parser=parser) 3652 3653 self.assertEqual("DONE", tree.getroot().tag) 3654 self.assertEqual(["start", "end"], events) 3655

3656 - def test_parser_target_attrib(self):

3657 assertEqual = self.assertEqual 3658 3659 events = [] 3660 class Target(object): 3661 def start(self, tag, attrib): 3662 events.append("start-" + tag) 3663 for name, value in attrib.items(): 3664 assertEqual(tag + name, value)

3665 def end(self, tag): 3666 events.append("end-" + tag) 3667 def close(self): 3668 return "DONE" 3669 3670 parser = self.etree.XMLParser(target=Target()) 3671 3672 parser.feed('<root a="roota" b="rootb"></root>') 3673 done = parser.close() 3674 3675 self.assertEqual("DONE", done) 3676 self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"], 3677 events) 3678

3679 - def test_parser_target_data(self):

3680 events = [] 3681 class Target(object): 3682 def start(self, tag, attrib): 3683 events.append("start-" + tag)

3684 def end(self, tag): 3685 events.append("end-" + tag) 3686 def data(self, data): 3687 events.append("data-" + data) 3688 def close(self): 3689 return "DONE" 3690 3691 parser = self.etree.XMLParser(target=Target()) 3692 3693 parser.feed('<root>AB</root>') 3694 done = parser.close() 3695 3696 self.assertEqual("DONE", done) 3697 self.assertEqual(["start-root", "data-A", "start-sub", 3698 "end-sub", "data-B", "end-root"], 3699 events) 3700

3701 - def test_parser_target_entity(self):

3702 events = [] 3703 class Target(object): 3704 def __init__(self): 3705 self._data = []

3706 def _flush_data(self): 3707 if self._data: 3708 events.append("data-" + ''.join(self._data)) 3709 del self._data[:] 3710 def start(self, tag, attrib): 3711 self._flush_data() 3712 events.append("start-" + tag) 3713 def end(self, tag): 3714 self._flush_data() 3715 events.append("end-" + tag) 3716 def data(self, data): 3717 self._data.append(data) 3718 def close(self): 3719 self._flush_data() 3720 return "DONE" 3721 3722 parser = self.etree.XMLParser(target=Target()) 3723 3724 dtd = ''' 3725 <!DOCTYPE root [ 3726 <!ELEMENT root (sub*)> 3727 <!ELEMENT sub (#PCDATA)> 3728 <!ENTITY ent "an entity"> 3729 ]> 3730 ''' 3731 parser.feed(dtd+'<root>this is &ent;</root>') 3732 done = parser.close() 3733 3734 self.assertEqual("DONE", done) 3735 self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub", 3736 "data-this is an entity", 3737 "end-sub", "start-sub", "end-sub", "end-root"], 3738 events) 3739 3740 required_versions_ET['test_parser_target_entity_unknown'] = (1,3)

3741 - def test_parser_target_entity_unknown(self):

3742 events = [] 3743 class Target(object): 3744 def __init__(self): 3745 self._data = []

3746 def _flush_data(self): 3747 if self._data: 3748 events.append("data-" + ''.join(self._data)) 3749 del self._data[:] 3750 def start(self, tag, attrib): 3751 self._flush_data() 3752 events.append("start-" + tag) 3753 def end(self, tag): 3754 self._flush_data() 3755 events.append("end-" + tag) 3756 def data(self, data): 3757 self._data.append(data) 3758 def close(self): 3759 self._flush_data() 3760 return "DONE" 3761 3762 parser = self.etree.XMLParser(target=Target()) 3763 3764 def feed(): 3765 parser.feed('<root>some &ent;</root>') 3766 parser.close() 3767 3768 self.assertRaises(self.etree.ParseError, feed) 3769

3770 - def test_treebuilder(self):

3771 builder = self.etree.TreeBuilder() 3772 el = builder.start("root", {'a':'A', 'b':'B'}) 3773 self.assertEqual("root", el.tag) 3774 self.assertEqual({'a':'A', 'b':'B'}, el.attrib) 3775 builder.data("ROOTTEXT") 3776 el = builder.start("child", {'x':'X', 'y':'Y'}) 3777 self.assertEqual("child", el.tag) 3778 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 3779 builder.data("CHILDTEXT") 3780 el = builder.end("child") 3781 self.assertEqual("child", el.tag) 3782 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 3783 self.assertEqual("CHILDTEXT", el.text) 3784 self.assertEqual(None, el.tail) 3785 builder.data("CHILDTAIL") 3786 root = builder.end("root") 3787 3788 self.assertEqual("root", root.tag) 3789 self.assertEqual("ROOTTEXT", root.text) 3790 self.assertEqual("CHILDTEXT", root[0].text) 3791 self.assertEqual("CHILDTAIL", root[0].tail)

3792

3793 - def test_treebuilder_target(self):

3794 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3795 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3796 root = parser.close() 3797 3798 self.assertEqual("root", root.tag) 3799 self.assertEqual("ROOTTEXT", root.text) 3800 self.assertEqual("CHILDTEXT", root[0].text) 3801 self.assertEqual("CHILDTAIL", root[0].tail)

3802 3803 # helper methods 3804

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

3806 """Write out element for comparison. 3807 """ 3808 data = self.etree.tostring(element, encoding=encoding) 3809 return canonicalize(data)

3810

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

3812 """Write out element for comparison, using real file. 3813 """ 3814 ElementTree = self.etree.ElementTree 3815 handle, filename = tempfile.mkstemp() 3816 try: 3817 f = open(filename, 'wb') 3818 tree = ElementTree(element=element) 3819 tree.write(f, encoding=encoding) 3820 f.close() 3821 f = open(filename, 'rb') 3822 data = f.read() 3823 f.close() 3824 finally: 3825 os.close(handle) 3826 os.remove(filename) 3827 return canonicalize(data)

3828

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

3830 """Writes element out and checks whether it is expected. 3831 3832 Does this two ways; once using BytesIO, once using a real file. 3833 """ 3834 if isinstance(expected, unicode): 3835 expected = expected.encode(encoding) 3836 self.assertEqual(expected, self._writeElement(element, encoding)) 3837 self.assertEqual(expected, self._writeElementFile(element, encoding))

3838

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

3840 "Checks if the result XML byte string specifies the encoding." 3841 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 3842 if isinstance(result, str): 3843 has_encoding = re.compile(enc_re).match 3844 else: 3845 has_encoding = re.compile(_bytes(enc_re)).match 3846 self.assertTrue(has_encoding(result)) 3847 result_encoding = has_encoding(result).group(1) 3848 self.assertEqual(result_encoding.upper(), encoding.upper())

3849

3850 - def _rootstring(self, tree):

3851 return self.etree.tostring(tree.getroot()).replace( 3852 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))

3853

3854 - def _check_element_tree(self, tree):

3855 self._check_element(tree.getroot())

3856

3857 - def _check_element(self, element):

3858 self.assertTrue(hasattr(element, 'tag')) 3859 self.assertTrue(hasattr(element, 'attrib')) 3860 self.assertTrue(hasattr(element, 'text')) 3861 self.assertTrue(hasattr(element, 'tail')) 3862 self._check_string(element.tag) 3863 self._check_mapping(element.attrib) 3864 if element.text != None: 3865 self._check_string(element.text) 3866 if element.tail != None: 3867 self._check_string(element.tail)

3868

3869 - def _check_string(self, string):

3870 len(string) 3871 for char in string: 3872 self.assertEqual(1, len(char)) 3873 new_string = string + "" 3874 new_string = string + " " 3875 string[:0]

3876

3877 - def _check_mapping(self, mapping):

3878 len(mapping) 3879 keys = mapping.keys() 3880 values = mapping.values() 3881 items = mapping.items() 3882 for key in keys: 3883 item = mapping[key] 3884 mapping["key"] = "value" 3885 self.assertEqual("value", mapping["key"])

3886 3887 3888 if etree:

3889 - class ETreeTestCase(_ETreeTestCaseBase):

3890 etree = etree

3891 3892 if ElementTree:

3893 - class ElementTreeTestCase(_ETreeTestCaseBase):

3894 etree = ElementTree 3895 3896 @classmethod

3897 - def setUpClass(cls):

3898 import warnings 3899 # ElementTree warns about getiterator() in recent Pythons 3900 warnings.filterwarnings( 3901 'ignore', 3902 'This method will be removed.*\.iter\(\).*instead', 3903 PendingDeprecationWarning)

3904 3905 filter_by_version( 3906 ElementTreeTestCase, 3907 ElementTreeTestCase.required_versions_ET, ET_VERSION) 3908 3909 if cElementTree:

3910 - class CElementTreeTestCase(_ETreeTestCaseBase):

3911 etree = cElementTree

3912 3913 filter_by_version( 3914 CElementTreeTestCase, 3915 CElementTreeTestCase.required_versions_cET, CET_VERSION)

3916 3917 -def test_suite():

3918 suite = unittest.TestSuite() 3919 if etree: 3920 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3921 if ElementTree: 3922 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3923 if cElementTree: 3924 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3925 return suite

3926 3927 if __name__ == '__main__': 3928 print('to test use test.py %s' % __file__) 3929