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, 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 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, next 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 XMLParser(self, **kwargs):

46 try: 47 XMLParser = self.etree.XMLParser 48 except AttributeError: 49 assert 'ElementTree' in self.etree.__name__ 50 XMLParser = self.etree.TreeBuilder 51 return XMLParser(**kwargs)

52

53 - def test_element(self):

54 for i in range(10): 55 e = self.etree.Element('foo') 56 self.assertEqual(e.tag, 'foo') 57 self.assertEqual(e.text, None) 58 self.assertEqual(e.tail, None)

59

60 - def test_simple(self):

61 Element = self.etree.Element 62 63 root = Element('root') 64 root.append(Element('one')) 65 root.append(Element('two')) 66 root.append(Element('three')) 67 self.assertEqual(3, len(root)) 68 self.assertEqual('one', root[0].tag) 69 self.assertEqual('two', root[1].tag) 70 self.assertEqual('three', root[2].tag) 71 self.assertRaises(IndexError, operator.getitem, root, 3)

72 73 # test weird dictionary interaction leading to segfault previously

74 - def test_weird_dict_interaction(self):

75 root = self.etree.Element('root') 76 self.assertEqual(root.tag, "root") 77 add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>')) 78 self.assertEqual(add.getroot().tag, "foo") 79 self.assertEqual(add.getroot().text, "Foo") 80 root.append(self.etree.Element('baz')) 81 self.assertEqual(root.tag, "root") 82 self.assertEqual(root[0].tag, "baz")

83

84 - def test_subelement(self):

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

96

97 - def test_element_contains(self):

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

114

115 - def test_element_indexing_with_text(self):

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

124

125 - def test_element_indexing_with_text2(self):

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

135

136 - def test_element_indexing_only_text(self):

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

143

144 - def test_element_indexing_negative(self):

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

159

160 - def test_elementtree(self):

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

169

170 - def test_text(self):

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

177

178 - def test_text_empty(self):

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

185

186 - def test_text_other(self):

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

194

195 - def test_text_escape_in(self):

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

202

203 - def test_text_escape_out(self):

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

210

211 - def test_text_escape_tostring(self):

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

219

220 - def test_text_str_subclass(self):

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

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

230

231 - def test_tail(self):

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

242

243 - def test_tail_str_subclass(self):

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

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

255 - def _test_del_tail(self):

256 # this is discouraged for ET compat, should not be tested... 257 XML = self.etree.XML 258 259 root = XML(_bytes('<doc>This is mixed content.</doc>')) 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(' content.', root[0].tail) 265 266 del root[0].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(None, root[0].tail) 273 274 root[0].tail = "TAIL" 275 276 self.assertEqual(1, len(root)) 277 self.assertEqual('This is ', root.text) 278 self.assertEqual(None, root.tail) 279 self.assertEqual('mixed', root[0].text) 280 self.assertEqual('TAIL', root[0].tail)

281

282 - def test_ElementTree(self):

283 Element = self.etree.Element 284 ElementTree = self.etree.ElementTree 285 286 el = Element('hoi') 287 doc = ElementTree(el) 288 root = doc.getroot() 289 self.assertEqual(None, root.text) 290 self.assertEqual('hoi', root.tag)

291

292 - def test_attrib(self):

293 ElementTree = self.etree.ElementTree 294 295 f = BytesIO('<doc one="One" two="Two"/>') 296 doc = ElementTree(file=f) 297 root = doc.getroot() 298 self.assertEqual('One', root.attrib['one']) 299 self.assertEqual('Two', root.attrib['two']) 300 self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')

301

302 - def test_attrib_get(self):

303 ElementTree = self.etree.ElementTree 304 305 f = BytesIO('<doc one="One" two="Two"/>') 306 doc = ElementTree(file=f) 307 root = doc.getroot() 308 self.assertEqual('One', root.attrib.get('one')) 309 self.assertEqual('Two', root.attrib.get('two')) 310 self.assertEqual(None, root.attrib.get('three')) 311 self.assertEqual('foo', root.attrib.get('three', 'foo'))

312

313 - def test_attrib_dict(self):

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

323

324 - def test_attrib_copy(self):

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

334

335 - def test_attrib_deepcopy(self):

336 ElementTree = self.etree.ElementTree 337 338 f = BytesIO('<doc one="One" two="Two"/>') 339 doc = ElementTree(file=f) 340 root = doc.getroot() 341 attrib = copy.deepcopy(root.attrib) 342 self.assertEqual('One', attrib['one']) 343 self.assertEqual('Two', attrib['two']) 344 self.assertRaises(KeyError, operator.getitem, attrib, 'three')

345

346 - def test_attributes_get(self):

347 ElementTree = self.etree.ElementTree 348 349 f = BytesIO('<doc one="One" two="Two"/>') 350 doc = ElementTree(file=f) 351 root = doc.getroot() 352 self.assertEqual('One', root.get('one')) 353 self.assertEqual('Two', root.get('two')) 354 self.assertEqual(None, root.get('three')) 355 self.assertEqual('foo', root.get('three', 'foo'))

356

357 - def test_attrib_clear(self):

358 XML = self.etree.XML 359 360 root = XML(_bytes('<doc one="One" two="Two"/>')) 361 self.assertEqual('One', root.get('one')) 362 self.assertEqual('Two', root.get('two')) 363 root.attrib.clear() 364 self.assertEqual(None, root.get('one')) 365 self.assertEqual(None, root.get('two'))

366

367 - def test_attrib_set_clear(self):

368 Element = self.etree.Element 369 370 root = Element("root", one="One") 371 root.set("two", "Two") 372 self.assertEqual('One', root.get('one')) 373 self.assertEqual('Two', root.get('two')) 374 root.attrib.clear() 375 self.assertEqual(None, root.get('one')) 376 self.assertEqual(None, root.get('two'))

377

378 - def test_attrib_ns_clear(self):

379 Element = self.etree.Element 380 SubElement = self.etree.SubElement 381 382 attribNS = '{http://foo/bar}x' 383 384 parent = Element('parent') 385 parent.set(attribNS, 'a') 386 child = SubElement(parent, 'child') 387 child.set(attribNS, 'b') 388 389 self.assertEqual('a', parent.get(attribNS)) 390 self.assertEqual('b', child.get(attribNS)) 391 392 parent.clear() 393 self.assertEqual(None, parent.get(attribNS)) 394 self.assertEqual('b', child.get(attribNS))

395

396 - def test_attrib_pop(self):

397 ElementTree = self.etree.ElementTree 398 399 f = BytesIO('<doc one="One" two="Two"/>') 400 doc = ElementTree(file=f) 401 root = doc.getroot() 402 self.assertEqual('One', root.attrib['one']) 403 self.assertEqual('Two', root.attrib['two']) 404 405 self.assertEqual('One', root.attrib.pop('one')) 406 407 self.assertEqual(None, root.attrib.get('one')) 408 self.assertEqual('Two', root.attrib['two'])

409

410 - def test_attrib_pop_unknown(self):

411 root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 412 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 413 414 self.assertEqual('One', root.attrib['one']) 415 self.assertEqual('Two', root.attrib['two'])

416

417 - def test_attrib_pop_default(self):

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

420

421 - def test_attrib_pop_empty_default(self):

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

424

425 - def test_attrib_pop_invalid_args(self):

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

428

429 - def test_attribute_update_dict(self):

430 XML = self.etree.XML 431 432 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 433 items = list(root.attrib.items()) 434 items.sort() 435 self.assertEqual( 436 [('alpha', 'Alpha'), ('beta', 'Beta')], 437 items) 438 439 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 440 441 items = list(root.attrib.items()) 442 items.sort() 443 self.assertEqual( 444 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 445 items)

446

447 - def test_attribute_update_sequence(self):

448 XML = self.etree.XML 449 450 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 451 items = list(root.attrib.items()) 452 items.sort() 453 self.assertEqual( 454 [('alpha', 'Alpha'), ('beta', 'Beta')], 455 items) 456 457 root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 458 459 items = list(root.attrib.items()) 460 items.sort() 461 self.assertEqual( 462 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 463 items)

464

465 - def test_attribute_update_iter(self):

466 XML = self.etree.XML 467 468 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 469 items = list(root.attrib.items()) 470 items.sort() 471 self.assertEqual( 472 [('alpha', 'Alpha'), ('beta', 'Beta')], 473 items) 474 475 root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items())) 476 477 items = list(root.attrib.items()) 478 items.sort() 479 self.assertEqual( 480 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 481 items)

482

483 - def test_attribute_update_attrib(self):

484 XML = self.etree.XML 485 486 root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 487 items = list(root.attrib.items()) 488 items.sort() 489 self.assertEqual( 490 [('alpha', 'Alpha'), ('beta', 'Beta')], 491 items) 492 493 other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>')) 494 root.attrib.update(other.attrib) 495 496 items = list(root.attrib.items()) 497 items.sort() 498 self.assertEqual( 499 [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 500 items)

501

502 - def test_attribute_keys(self):

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

509

510 - def test_attribute_keys2(self):

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

517

518 - def test_attribute_items2(self):

519 XML = self.etree.XML 520 521 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 522 items = list(root.items()) 523 items.sort() 524 self.assertEqual( 525 [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 526 items)

527

528 - def test_attribute_keys_ns(self):

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

536

537 - def test_attribute_values(self):

538 XML = self.etree.XML 539 540 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 541 values = list(root.attrib.values()) 542 values.sort() 543 self.assertEqual(['Alpha', 'Beta', 'Gamma'], values)

544

545 - def test_attribute_values_ns(self):

546 XML = self.etree.XML 547 548 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 549 values = list(root.attrib.values()) 550 values.sort() 551 self.assertEqual( 552 ['Bar', 'Baz'], values)

553

554 - def test_attribute_items(self):

555 XML = self.etree.XML 556 557 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 558 items = list(root.attrib.items()) 559 items.sort() 560 self.assertEqual([ 561 ('alpha', 'Alpha'), 562 ('beta', 'Beta'), 563 ('gamma', 'Gamma'), 564 ], 565 items)

566

567 - def test_attribute_items_ns(self):

568 XML = self.etree.XML 569 570 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 571 items = list(root.attrib.items()) 572 items.sort() 573 self.assertEqual( 574 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 575 items)

576

577 - def test_attribute_str(self):

578 XML = self.etree.XML 579 580 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 581 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 582 583 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 584 try: 585 self.assertEqual(expected, str(root.attrib)) 586 except AssertionError: 587 self.assertEqual(alternative, str(root.attrib))

588

589 - def test_attribute_contains(self):

590 XML = self.etree.XML 591 592 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 593 self.assertEqual( 594 True, 'bar' in root.attrib) 595 self.assertEqual( 596 False, 'baz' in root.attrib) 597 self.assertEqual( 598 False, 'hah' in root.attrib) 599 self.assertEqual( 600 True, 601 '{http://ns.codespeak.net/test}baz' in root.attrib)

602

603 - def test_attribute_set(self):

604 Element = self.etree.Element 605 606 root = Element("root") 607 root.set("attr", "TEST") 608 self.assertEqual("TEST", root.get("attr"))

609

610 - def test_attrib_as_attrib(self):

611 Element = self.etree.Element 612 613 root = Element("root") 614 root.set("attr", "TEST") 615 self.assertEqual("TEST", root.attrib["attr"]) 616 617 root2 = Element("root2", root.attrib) 618 self.assertEqual("TEST", root2.attrib["attr"])

619

620 - def test_attribute_iterator(self):

621 XML = self.etree.XML 622 623 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 624 result = [] 625 for key in root.attrib: 626 result.append(key) 627 result.sort() 628 self.assertEqual(['alpha', 'beta', 'gamma'], result)

629

630 - def test_attribute_manipulation(self):

631 Element = self.etree.Element 632 633 a = Element('a') 634 a.attrib['foo'] = 'Foo' 635 a.attrib['bar'] = 'Bar' 636 self.assertEqual('Foo', a.attrib['foo']) 637 del a.attrib['foo'] 638 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

639

640 - def test_del_attribute_ns(self):

641 Element = self.etree.Element 642 643 a = Element('a') 644 a.attrib['{http://a/}foo'] = 'Foo' 645 a.attrib['{http://a/}bar'] = 'Bar' 646 self.assertEqual(None, a.get('foo')) 647 self.assertEqual('Foo', a.get('{http://a/}foo')) 648 self.assertEqual('Foo', a.attrib['{http://a/}foo']) 649 650 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 651 self.assertEqual('Foo', a.attrib['{http://a/}foo']) 652 653 del a.attrib['{http://a/}foo'] 654 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

655

656 - def test_del_attribute_ns_parsed(self):

657 XML = self.etree.XML 658 659 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 660 661 self.assertEqual('Foo', a.attrib['foo']) 662 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 663 664 del a.attrib['foo'] 665 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 666 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 667 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 668 669 del a.attrib['{http://a/}foo'] 670 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 671 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 672 673 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 674 675 self.assertEqual('Foo', a.attrib['foo']) 676 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 677 678 del a.attrib['foo'] 679 self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 680 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 681 682 del a.attrib['{http://a/}foo'] 683 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 684 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

685

686 - def test_XML(self):

687 XML = self.etree.XML 688 689 root = XML(_bytes('<doc>This is a text.</doc>')) 690 self.assertEqual(0, len(root)) 691 self.assertEqual('This is a text.', root.text)

692

693 - def test_XMLID(self):

694 XMLID = self.etree.XMLID 695 XML = self.etree.XML 696 xml_text = _bytes(''' 697 <document> 698 <h1 id="chapter1">...</h1> 699 ... 700 Regular paragraph. 701 XML:ID paragraph. 702 ... 703 </document> 704 ''') 705 706 root, dic = XMLID(xml_text) 707 root2 = XML(xml_text) 708 self.assertEqual(self._writeElement(root), 709 self._writeElement(root2)) 710 expected = { 711 "chapter1" : root[0], 712 "note1" : root[1], 713 "warn1" : root[4] 714 } 715 self.assertEqual(dic, expected)

716

717 - def test_fromstring(self):

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

723 724 required_versions_ET['test_fromstringlist'] = (1,3)

725 - def test_fromstringlist(self):

726 fromstringlist = self.etree.fromstringlist 727 728 root = fromstringlist(["<do", "c>T", "hi", "s is", 729 " a text.<", "/doc", ">"]) 730 self.assertEqual(0, len(root)) 731 self.assertEqual('This is a text.', root.text)

732 733 required_versions_ET['test_fromstringlist_characters'] = (1,3)

734 - def test_fromstringlist_characters(self):

735 fromstringlist = self.etree.fromstringlist 736 737 root = fromstringlist(list('<doc>This is a text.</doc>')) 738 self.assertEqual(0, len(root)) 739 self.assertEqual('This is a text.', root.text)

740 741 required_versions_ET['test_fromstringlist_single'] = (1,3)

742 - def test_fromstringlist_single(self):

743 fromstringlist = self.etree.fromstringlist 744 745 root = fromstringlist(['<doc>This is a text.</doc>']) 746 self.assertEqual(0, len(root)) 747 self.assertEqual('This is a text.', root.text)

748

749 - def test_iselement(self):

750 iselement = self.etree.iselement 751 Element = self.etree.Element 752 ElementTree = self.etree.ElementTree 753 XML = self.etree.XML 754 Comment = self.etree.Comment 755 ProcessingInstruction = self.etree.ProcessingInstruction 756 757 el = Element('hoi') 758 self.assertTrue(iselement(el)) 759 760 el2 = XML(_bytes('<foo/>')) 761 self.assertTrue(iselement(el2)) 762 763 tree = ElementTree(element=Element('dag')) 764 self.assertTrue(not iselement(tree)) 765 self.assertTrue(iselement(tree.getroot())) 766 767 c = Comment('test') 768 self.assertTrue(iselement(c)) 769 770 p = ProcessingInstruction("test", "some text") 771 self.assertTrue(iselement(p))

772

773 - def test_iteration(self):

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

781

782 - def test_iteration_empty(self):

783 XML = self.etree.XML 784 785 root = XML(_bytes('<doc></doc>')) 786 result = [] 787 for el in root: 788 result.append(el.tag) 789 self.assertEqual([], result)

790

791 - def test_iteration_text_only(self):

792 XML = self.etree.XML 793 794 root = XML(_bytes('<doc>Text</doc>')) 795 result = [] 796 for el in root: 797 result.append(el.tag) 798 self.assertEqual([], result)

799

800 - def test_iteration_crash(self):

801 # this would cause a crash in the past 802 fromstring = self.etree.fromstring 803 root = etree.fromstring('<html>x</html>') 804 for elem in root: 805 elem.tail = ''

806

807 - def test_iteration_reversed(self):

808 XML = self.etree.XML 809 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 810 result = [] 811 for el in reversed(root): 812 result.append(el.tag) 813 self.assertEqual(['three', 'two', 'one'], result)

814

815 - def test_iteration_subelement(self):

816 XML = self.etree.XML 817 818 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 819 result = [] 820 add = True 821 for el in root: 822 result.append(el.tag) 823 if add: 824 self.etree.SubElement(root, 'four') 825 add = False 826 self.assertEqual(['one', 'two', 'three', 'four'], result)

827

828 - def test_iteration_del_child(self):

829 XML = self.etree.XML 830 831 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 832 result = [] 833 for el in root: 834 result.append(el.tag) 835 del root[-1] 836 self.assertEqual(['one', 'two'], result)

837

838 - def test_iteration_double(self):

839 XML = self.etree.XML 840 841 root = XML(_bytes('<doc><one/><two/></doc>')) 842 result = [] 843 for el0 in root: 844 result.append(el0.tag) 845 for el1 in root: 846 result.append(el1.tag) 847 self.assertEqual(['one','one', 'two', 'two', 'one', 'two'], result)

848 849 required_versions_ET['test_itertext'] = (1,3)

850 - def test_itertext(self):

851 # ET 1.3+ 852 XML = self.etree.XML 853 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 854 855 text = list(root.itertext()) 856 self.assertEqual(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 857 text)

858 859 required_versions_ET['test_itertext_child'] = (1,3)

860 - def test_itertext_child(self):

861 # ET 1.3+ 862 XML = self.etree.XML 863 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 864 865 text = list(root[2].itertext()) 866 self.assertEqual(["CTEXT"], 867 text)

868

869 - def test_findall(self):

870 XML = self.etree.XML 871 root = XML(_bytes('<a><c/><c></c></a>')) 872 self.assertEqual(len(list(root.findall("c"))), 1) 873 self.assertEqual(len(list(root.findall(".//c"))), 2) 874 self.assertEqual(len(list(root.findall(".//b"))), 3) 875 self.assertEqual(len(list(root.findall(".//b"))[0]), 1) 876 self.assertEqual(len(list(root.findall(".//b"))[1]), 0) 877 self.assertEqual(len(list(root.findall(".//b"))[2]), 0)

878

879 - def test_findall_ns(self):

880 XML = self.etree.XML 881 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 882 self.assertEqual(len(list(root.findall(".//{X}b"))), 2) 883 self.assertEqual(len(list(root.findall(".//b"))), 3) 884 self.assertEqual(len(list(root.findall("b"))), 2)

885

886 - def test_element_with_attributes_keywords(self):

887 Element = self.etree.Element 888 889 el = Element('tag', foo='Foo', bar='Bar') 890 self.assertEqual('Foo', el.attrib['foo']) 891 self.assertEqual('Bar', el.attrib['bar'])

892

893 - def test_element_with_attributes(self):

894 Element = self.etree.Element 895 896 el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}) 897 self.assertEqual('Foo', el.attrib['foo']) 898 self.assertEqual('Bar', el.attrib['bar'])

899

900 - def test_element_with_attributes_extra(self):

901 Element = self.etree.Element 902 903 el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, baz='Baz') 904 self.assertEqual('Foo', el.attrib['foo']) 905 self.assertEqual('Bar', el.attrib['bar']) 906 self.assertEqual('Baz', el.attrib['baz'])

907

908 - def test_element_with_attributes_extra_duplicate(self):

909 Element = self.etree.Element 910 911 el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, bar='Baz') 912 self.assertEqual('Foo', el.attrib['foo']) 913 self.assertEqual('Baz', el.attrib['bar'])

914

915 - def test_element_with_attributes_ns(self):

916 Element = self.etree.Element 917 918 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 919 self.assertEqual('Foo', el.attrib['{ns1}foo']) 920 self.assertEqual('Bar', el.attrib['{ns2}bar'])

921

922 - def test_subelement_with_attributes(self):

923 Element = self.etree.Element 924 SubElement = self.etree.SubElement 925 926 el = Element('tag') 927 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 928 self.assertEqual("Baz", el[0].attrib['baz']) 929 self.assertEqual('Foo', el[0].attrib['foo'])

930

931 - def test_subelement_with_attributes_ns(self):

932 Element = self.etree.Element 933 SubElement = self.etree.SubElement 934 935 el = Element('tag') 936 SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 937 self.assertEqual('Foo', el[0].attrib['{ns1}foo']) 938 self.assertEqual('Bar', el[0].attrib['{ns2}bar'])

939

940 - def test_write(self):

941 ElementTree = self.etree.ElementTree 942 XML = self.etree.XML 943 944 for i in range(10): 945 f = BytesIO() 946 root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 947 tree = ElementTree(element=root) 948 tree.write(f) 949 data = f.getvalue() 950 self.assertEqual( 951 _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 952 canonicalize(data))

953 954 required_versions_ET['test_write_method_html'] = (1,3)

955 - def test_write_method_html(self):

956 ElementTree = self.etree.ElementTree 957 Element = self.etree.Element 958 SubElement = self.etree.SubElement 959 960 html = Element('html') 961 body = SubElement(html, 'body') 962 p = SubElement(body, 'p') 963 p.text = "html" 964 SubElement(p, 'br').tail = "test" 965 966 tree = ElementTree(element=html) 967 f = BytesIO() 968 tree.write(f, method="html") 969 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 970 971 self.assertEqual(_bytes('<html><body>html test</body></html>'), 972 data)

973 974 required_versions_ET['test_write_method_text'] = (1,3)

975 - def test_write_method_text(self):

976 ElementTree = self.etree.ElementTree 977 Element = self.etree.Element 978 SubElement = self.etree.SubElement 979 980 a = Element('a') 981 a.text = "A" 982 a.tail = "tail" 983 b = SubElement(a, 'b') 984 b.text = "B" 985 b.tail = "TAIL" 986 c = SubElement(a, 'c') 987 c.text = "C" 988 989 tree = ElementTree(element=a) 990 f = BytesIO() 991 tree.write(f, method="text") 992 data = f.getvalue() 993 994 self.assertEqual(_bytes('ABTAILCtail'), 995 data)

996

997 - def test_write_fail(self):

998 ElementTree = self.etree.ElementTree 999 XML = self.etree.XML 1000 1001 tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 1002 self.assertRaises(IOError, tree.write, 1003 "definitely////\\-\\nonexisting\\-\\////FILE")

1004 1005 # this could trigger a crash, apparently because the document 1006 # reference was prematurely garbage collected

1007 - def test_crash(self):

1008 Element = self.etree.Element 1009 1010 element = Element('tag') 1011 for i in range(10): 1012 element.attrib['key'] = 'value' 1013 value = element.attrib['key'] 1014 self.assertEqual(value, 'value')

1015 1016 # from doctest; for some reason this caused crashes too

1017 - def test_write_ElementTreeDoctest(self):

1018 Element = self.etree.Element 1019 ElementTree = self.etree.ElementTree 1020 1021 f = BytesIO() 1022 for i in range(10): 1023 element = Element('tag%s' % i) 1024 self._check_element(element) 1025 tree = ElementTree(element) 1026 tree.write(f) 1027 self._check_element_tree(tree)

1028

1029 - def test_subelement_reference(self):

1030 Element = self.etree.Element 1031 SubElement = self.etree.SubElement 1032 1033 el = Element('foo') 1034 el2 = SubElement(el, 'bar') 1035 el3 = SubElement(el2, 'baz') 1036 1037 al = Element('foo2') 1038 al2 = SubElement(al, 'bar2') 1039 al3 = SubElement(al2, 'baz2') 1040 1041 # now move al2 into el 1042 el.append(al2) 1043 1044 # now change al3 directly 1045 al3.text = 'baz2-modified' 1046 1047 # it should have changed through this route too 1048 self.assertEqual( 1049 'baz2-modified', 1050 el[1][0].text)

1051

1052 - def test_set_text(self):

1053 Element = self.etree.Element 1054 SubElement = self.etree.SubElement 1055 1056 a = Element('a') 1057 b = SubElement(a, 'b') 1058 a.text = 'hoi' 1059 self.assertEqual( 1060 'hoi', 1061 a.text) 1062 self.assertEqual( 1063 'b', 1064 a[0].tag)

1065

1066 - def test_set_text2(self):

1067 Element = self.etree.Element 1068 SubElement = self.etree.SubElement 1069 1070 a = Element('a') 1071 a.text = 'hoi' 1072 b = SubElement(a ,'b') 1073 self.assertEqual( 1074 'hoi', 1075 a.text) 1076 self.assertEqual( 1077 'b', 1078 a[0].tag)

1079

1080 - def test_set_text_none(self):

1081 Element = self.etree.Element 1082 1083 a = Element('a') 1084 1085 a.text = 'foo' 1086 a.text = None 1087 1088 self.assertEqual( 1089 None, 1090 a.text) 1091 self.assertXML(_bytes('<a></a>'), a)

1092

1093 - def test_set_text_empty(self):

1094 Element = self.etree.Element 1095 1096 a = Element('a') 1097 self.assertEqual(None, a.text) 1098 1099 a.text = '' 1100 self.assertEqual('', a.text) 1101 self.assertXML(_bytes('<a></a>'), a)

1102

1103 - def test_tail1(self):

1104 Element = self.etree.Element 1105 SubElement = self.etree.SubElement 1106 1107 a = Element('a') 1108 a.tail = 'dag' 1109 self.assertEqual('dag', 1110 a.tail) 1111 b = SubElement(a, 'b') 1112 b.tail = 'hoi' 1113 self.assertEqual('hoi', 1114 b.tail) 1115 self.assertEqual('dag', 1116 a.tail)

1117

1118 - def test_tail_append(self):

1119 Element = self.etree.Element 1120 1121 a = Element('a') 1122 b = Element('b') 1123 b.tail = 'b_tail' 1124 a.append(b) 1125 self.assertEqual('b_tail', 1126 b.tail)

1127

1128 - def test_tail_set_twice(self):

1129 Element = self.etree.Element 1130 SubElement = self.etree.SubElement 1131 1132 a = Element('a') 1133 b = SubElement(a, 'b') 1134 b.tail = 'foo' 1135 b.tail = 'bar' 1136 self.assertEqual('bar', 1137 b.tail) 1138 self.assertXML(_bytes('<a>bar</a>'), a)

1139

1140 - def test_tail_set_none(self):

1141 Element = self.etree.Element 1142 a = Element('a') 1143 a.tail = 'foo' 1144 a.tail = None 1145 self.assertEqual( 1146 None, 1147 a.tail) 1148 self.assertXML(_bytes('<a></a>'), a)

1149 1150 required_versions_ET['test_extend'] = (1,3)

1151 - def test_extend(self):

1152 root = self.etree.Element('foo') 1153 for i in range(3): 1154 element = self.etree.SubElement(root, 'a%s' % i) 1155 element.text = "text%d" % i 1156 element.tail = "tail%d" % i 1157 1158 elements = [] 1159 for i in range(3): 1160 new_element = self.etree.Element("test%s" % i) 1161 new_element.text = "TEXT%s" % i 1162 new_element.tail = "TAIL%s" % i 1163 elements.append(new_element) 1164 1165 root.extend(elements) 1166 1167 self.assertEqual( 1168 ["a0", "a1", "a2", "test0", "test1", "test2"], 1169 [ el.tag for el in root ]) 1170 self.assertEqual( 1171 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1172 [ el.text for el in root ]) 1173 self.assertEqual( 1174 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1175 [ el.tail for el in root ])

1176

1177 - def test_comment(self):

1178 Element = self.etree.Element 1179 SubElement = self.etree.SubElement 1180 Comment = self.etree.Comment 1181 1182 a = Element('a') 1183 a.append(Comment('foo')) 1184 self.assertEqual(a[0].tag, Comment) 1185 self.assertEqual(a[0].text, 'foo')

1186 1187 # ElementTree < 1.3 adds whitespace around comments 1188 required_versions_ET['test_comment_text'] = (1,3)

1189 - def test_comment_text(self):

1190 Element = self.etree.Element 1191 SubElement = self.etree.SubElement 1192 Comment = self.etree.Comment 1193 tostring = self.etree.tostring 1194 1195 a = Element('a') 1196 a.append(Comment('foo')) 1197 self.assertEqual(a[0].text, 'foo') 1198 1199 self.assertEqual( 1200 _bytes('<a></a>'), 1201 tostring(a)) 1202 1203 a[0].text = "TEST" 1204 self.assertEqual(a[0].text, 'TEST') 1205 1206 self.assertEqual( 1207 _bytes('<a></a>'), 1208 tostring(a))

1209 1210 # ElementTree < 1.3 adds whitespace around comments 1211 required_versions_ET['test_comment_whitespace'] = (1,3)

1212 - def test_comment_whitespace(self):

1213 Element = self.etree.Element 1214 SubElement = self.etree.SubElement 1215 Comment = self.etree.Comment 1216 tostring = self.etree.tostring 1217 1218 a = Element('a') 1219 a.append(Comment(' foo ')) 1220 self.assertEqual(a[0].text, ' foo ') 1221 self.assertEqual( 1222 _bytes('<a></a>'), 1223 tostring(a))

1224

1225 - def test_comment_nonsense(self):

1226 Comment = self.etree.Comment 1227 c = Comment('foo') 1228 self.assertEqual({}, c.attrib) 1229 self.assertEqual([], list(c.keys())) 1230 self.assertEqual([], list(c.items())) 1231 self.assertEqual(None, c.get('hoi')) 1232 self.assertEqual(0, len(c)) 1233 # should not iterate 1234 for i in c: 1235 pass

1236

1237 - def test_pi(self):

1238 # lxml.etree separates target and text 1239 Element = self.etree.Element 1240 SubElement = self.etree.SubElement 1241 ProcessingInstruction = self.etree.ProcessingInstruction 1242 1243 a = Element('a') 1244 a.append(ProcessingInstruction('foo', 'some more text')) 1245 self.assertEqual(a[0].tag, ProcessingInstruction) 1246 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1247 a)

1248

1249 - def test_processinginstruction(self):

1250 # lxml.etree separates target and text 1251 Element = self.etree.Element 1252 SubElement = self.etree.SubElement 1253 ProcessingInstruction = self.etree.PI 1254 1255 a = Element('a') 1256 a.append(ProcessingInstruction('foo', 'some more text')) 1257 self.assertEqual(a[0].tag, ProcessingInstruction) 1258 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1259 a)

1260

1261 - def test_pi_nonsense(self):

1262 ProcessingInstruction = self.etree.ProcessingInstruction 1263 pi = ProcessingInstruction('foo') 1264 self.assertEqual({}, pi.attrib) 1265 self.assertEqual([], list(pi.keys())) 1266 self.assertEqual([], list(pi.items())) 1267 self.assertEqual(None, pi.get('hoi')) 1268 self.assertEqual(0, len(pi)) 1269 # should not iterate 1270 for i in pi: 1271 pass

1272

1273 - def test_setitem(self):

1274 Element = self.etree.Element 1275 SubElement = self.etree.SubElement 1276 1277 a = Element('a') 1278 b = SubElement(a, 'b') 1279 c = Element('c') 1280 a[0] = c 1281 self.assertEqual( 1282 c, 1283 a[0]) 1284 self.assertXML(_bytes('<a><c></c></a>'), 1285 a) 1286 self.assertXML(_bytes(''), 1287 b)

1288

1289 - def test_setitem2(self):

1290 Element = self.etree.Element 1291 SubElement = self.etree.SubElement 1292 1293 a = Element('a') 1294 for i in range(5): 1295 b = SubElement(a, 'b%s' % i) 1296 c = SubElement(b, 'c') 1297 for i in range(5): 1298 d = Element('d') 1299 e = SubElement(d, 'e') 1300 a[i] = d 1301 self.assertXML( 1302 _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 1303 a) 1304 self.assertXML(_bytes('<c></c>'), 1305 c)

1306

1307 - def test_setitem_replace(self):

1308 Element = self.etree.Element 1309 SubElement = self.etree.SubElement 1310 1311 a = Element('a') 1312 SubElement(a, 'b') 1313 d = Element('d') 1314 a[0] = d 1315 self.assertXML(_bytes('<a><d></d></a>'), a)

1316

1317 - def test_setitem_indexerror(self):

1318 Element = self.etree.Element 1319 SubElement = self.etree.SubElement 1320 1321 a = Element('a') 1322 b = SubElement(a, 'b') 1323 1324 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1325

1326 - def test_setitem_tail(self):

1327 Element = self.etree.Element 1328 SubElement = self.etree.SubElement 1329 1330 a = Element('a') 1331 b = SubElement(a, 'b') 1332 b.tail = 'B2' 1333 c = Element('c') 1334 c.tail = 'C2' 1335 1336 a[0] = c 1337 self.assertXML( 1338 _bytes('<a><c></c>C2</a>'), 1339 a)

1340

1341 - def test_tag_write(self):

1342 Element = self.etree.Element 1343 SubElement = self.etree.SubElement 1344 1345 a = Element('a') 1346 b = SubElement(a, 'b') 1347 1348 a.tag = 'c' 1349 1350 self.assertEqual( 1351 'c', 1352 a.tag) 1353 1354 self.assertXML( 1355 _bytes('<c></c>'), 1356 a)

1357

1358 - def test_tag_reset_ns(self):

1359 Element = self.etree.Element 1360 SubElement = self.etree.SubElement 1361 tostring = self.etree.tostring 1362 1363 a = Element('{a}a') 1364 b1 = SubElement(a, '{a}b') 1365 b2 = SubElement(a, '{b}b') 1366 1367 self.assertEqual('{a}b', b1.tag) 1368 1369 b1.tag = 'c' 1370 1371 # can't use C14N here! 1372 self.assertEqual('c', b1.tag) 1373 self.assertEqual(_bytes('<c'), tostring(b1)[:2]) 1374 self.assertTrue(_bytes('<c') in tostring(a))

1375

1376 - def test_tag_reset_root_ns(self):

1377 Element = self.etree.Element 1378 SubElement = self.etree.SubElement 1379 tostring = self.etree.tostring 1380 1381 a = Element('{a}a') 1382 b1 = SubElement(a, '{a}b') 1383 b2 = SubElement(a, '{b}b') 1384 1385 a.tag = 'c' 1386 1387 self.assertEqual( 1388 'c', 1389 a.tag) 1390 1391 # can't use C14N here! 1392 self.assertEqual('c', a.tag) 1393 self.assertEqual(_bytes('<c'), tostring(a)[:2])

1394

1395 - def test_tag_str_subclass(self):

1396 Element = self.etree.Element 1397 1398 class strTest(str): 1399 pass

1400 1401 a = Element("a") 1402 a.tag = strTest("TAG") 1403 self.assertXML(_bytes('<TAG></TAG>'), 1404 a) 1405

1406 - def test_delitem(self):

1407 Element = self.etree.Element 1408 SubElement = self.etree.SubElement 1409 1410 a = Element('a') 1411 b = SubElement(a, 'b') 1412 c = SubElement(a, 'c') 1413 d = SubElement(a, 'd') 1414 1415 del a[1] 1416 self.assertXML( 1417 _bytes('<a><d></d></a>'), 1418 a) 1419 1420 del a[0] 1421 self.assertXML( 1422 _bytes('<a><d></d></a>'), 1423 a) 1424 1425 del a[0] 1426 self.assertXML( 1427 _bytes('<a></a>'), 1428 a) 1429 # move deleted element into other tree afterwards 1430 other = Element('other') 1431 other.append(c) 1432 self.assertXML( 1433 _bytes('<other><c></c></other>'), 1434 other)

1435

1436 - def test_del_insert(self):

1437 Element = self.etree.Element 1438 SubElement = self.etree.SubElement 1439 1440 a = Element('a') 1441 b = SubElement(a, 'b') 1442 bs = SubElement(b, 'bs') 1443 c = SubElement(a, 'c') 1444 cs = SubElement(c, 'cs') 1445 1446 el = a[0] 1447 self.assertXML( 1448 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1449 a) 1450 self.assertXML(_bytes('<bs></bs>'), b) 1451 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1452 1453 del a[0] 1454 self.assertXML( 1455 _bytes('<a><c><cs></cs></c></a>'), 1456 a) 1457 self.assertXML(_bytes('<bs></bs>'), b) 1458 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1459 1460 a.insert(0, el) 1461 self.assertXML( 1462 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1463 a) 1464 self.assertXML(_bytes('<bs></bs>'), b) 1465 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1466

1467 - def test_del_setitem(self):

1468 Element = self.etree.Element 1469 SubElement = self.etree.SubElement 1470 1471 a = Element('a') 1472 b = SubElement(a, 'b') 1473 bs = SubElement(b, 'bs') 1474 c = SubElement(a, 'c') 1475 cs = SubElement(c, 'cs') 1476 1477 el = a[0] 1478 del a[0] 1479 a[0] = el 1480 self.assertXML( 1481 _bytes('<a><bs></bs></a>'), 1482 a) 1483 self.assertXML(_bytes('<bs></bs>'), b) 1484 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1485

1486 - def test_del_setslice(self):

1487 Element = self.etree.Element 1488 SubElement = self.etree.SubElement 1489 1490 a = Element('a') 1491 b = SubElement(a, 'b') 1492 bs = SubElement(b, 'bs') 1493 c = SubElement(a, 'c') 1494 cs = SubElement(c, 'cs') 1495 1496 el = a[0] 1497 del a[0] 1498 a[0:0] = [el] 1499 self.assertXML( 1500 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1501 a) 1502 self.assertXML(_bytes('<bs></bs>'), b) 1503 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1504

1505 - def test_replace_slice_tail(self):

1506 XML = self.etree.XML 1507 a = XML(_bytes('<a>B2<c></c>C2</a>')) 1508 b, c = a 1509 1510 a[:] = [] 1511 1512 self.assertEqual("B2", b.tail) 1513 self.assertEqual("C2", c.tail)

1514

1515 - def test_merge_namespaced_subtree_as_slice(self):

1516 XML = self.etree.XML 1517 root = XML(_bytes( 1518 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 1519 root[:] = root.findall('.//puh') # delete bar from hierarchy 1520 1521 # previously, this lost a namespace declaration on bump2 1522 result = self.etree.tostring(root) 1523 foo = self.etree.fromstring(result) 1524 1525 self.assertEqual('puh', foo[0].tag) 1526 self.assertEqual('{http://huhu}bump1', foo[0][0].tag) 1527 self.assertEqual('{http://huhu}bump2', foo[0][1].tag)

1528

1529 - def test_delitem_tail(self):

1530 ElementTree = self.etree.ElementTree 1531 f = BytesIO('<a>B2<c></c>C2</a>') 1532 doc = ElementTree(file=f) 1533 a = doc.getroot() 1534 del a[0] 1535 self.assertXML( 1536 _bytes('<a><c></c>C2</a>'), 1537 a)

1538

1539 - def test_clear(self):

1540 Element = self.etree.Element 1541 1542 a = Element('a') 1543 a.text = 'foo' 1544 a.tail = 'bar' 1545 a.set('hoi', 'dag') 1546 a.clear() 1547 self.assertEqual(None, a.text) 1548 self.assertEqual(None, a.tail) 1549 self.assertEqual(None, a.get('hoi')) 1550 self.assertEqual('a', a.tag)

1551

1552 - def test_clear_sub(self):

1553 Element = self.etree.Element 1554 SubElement = self.etree.SubElement 1555 1556 a = Element('a') 1557 a.text = 'foo' 1558 a.tail = 'bar' 1559 a.set('hoi', 'dag') 1560 b = SubElement(a, 'b') 1561 c = SubElement(b, 'c') 1562 a.clear() 1563 self.assertEqual(None, a.text) 1564 self.assertEqual(None, a.tail) 1565 self.assertEqual(None, a.get('hoi')) 1566 self.assertEqual('a', a.tag) 1567 self.assertEqual(0, len(a)) 1568 self.assertXML(_bytes('<a></a>'), 1569 a) 1570 self.assertXML(_bytes('<c></c>'), 1571 b)

1572

1573 - def test_clear_tail(self):

1574 ElementTree = self.etree.ElementTree 1575 f = BytesIO('<a>B2<c></c>C2</a>') 1576 doc = ElementTree(file=f) 1577 a = doc.getroot() 1578 a.clear() 1579 self.assertXML( 1580 _bytes('<a></a>'), 1581 a)

1582

1583 - def test_insert(self):

1584 Element = self.etree.Element 1585 SubElement = self.etree.SubElement 1586 1587 a = Element('a') 1588 b = SubElement(a, 'b') 1589 c = SubElement(a, 'c') 1590 d = Element('d') 1591 a.insert(0, d) 1592 1593 self.assertEqual( 1594 d, 1595 a[0]) 1596 1597 self.assertXML( 1598 _bytes('<a><d></d><c></c></a>'), 1599 a) 1600 1601 e = Element('e') 1602 a.insert(2, e) 1603 self.assertEqual( 1604 e, 1605 a[2]) 1606 self.assertXML( 1607 _bytes('<a><d></d><e></e><c></c></a>'), 1608 a)

1609

1610 - def test_insert_beyond_index(self):

1611 Element = self.etree.Element 1612 SubElement = self.etree.SubElement 1613 1614 a = Element('a') 1615 b = SubElement(a, 'b') 1616 c = Element('c') 1617 1618 a.insert(2, c) 1619 self.assertEqual( 1620 c, 1621 a[1]) 1622 self.assertXML( 1623 _bytes('<a><c></c></a>'), 1624 a)

1625

1626 - def test_insert_negative(self):

1627 Element = self.etree.Element 1628 SubElement = self.etree.SubElement 1629 1630 a = Element('a') 1631 b = SubElement(a, 'b') 1632 c = SubElement(a, 'c') 1633 1634 d = Element('d') 1635 a.insert(-1, d) 1636 self.assertEqual( 1637 d, 1638 a[-2]) 1639 self.assertXML( 1640 _bytes('<a><d></d><c></c></a>'), 1641 a)

1642

1643 - def test_insert_tail(self):

1644 Element = self.etree.Element 1645 SubElement = self.etree.SubElement 1646 1647 a = Element('a') 1648 b = SubElement(a, 'b') 1649 1650 c = Element('c') 1651 c.tail = 'C2' 1652 1653 a.insert(0, c) 1654 self.assertXML( 1655 _bytes('<a><c></c>C2</a>'), 1656 a)

1657

1658 - def test_remove(self):

1659 Element = self.etree.Element 1660 SubElement = self.etree.SubElement 1661 1662 a = Element('a') 1663 b = SubElement(a, 'b') 1664 c = SubElement(a, 'c') 1665 1666 a.remove(b) 1667 self.assertEqual( 1668 c, 1669 a[0]) 1670 self.assertXML( 1671 _bytes('<a><c></c></a>'), 1672 a)

1673

1674 - def test_remove_ns(self):

1675 Element = self.etree.Element 1676 SubElement = self.etree.SubElement 1677 1678 a = Element('{http://test}a') 1679 b = SubElement(a, '{http://test}b') 1680 c = SubElement(a, '{http://test}c') 1681 1682 a.remove(b) 1683 self.assertXML( 1684 _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 1685 a) 1686 self.assertXML( 1687 _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 1688 b)

1689

1690 - def test_remove_nonexisting(self):

1691 Element = self.etree.Element 1692 SubElement = self.etree.SubElement 1693 1694 a = Element('a') 1695 b = SubElement(a, 'b') 1696 c = SubElement(a, 'c') 1697 d = Element('d') 1698 self.assertRaises( 1699 ValueError, a.remove, d)

1700

1701 - def test_remove_tail(self):

1702 Element = self.etree.Element 1703 SubElement = self.etree.SubElement 1704 1705 a = Element('a') 1706 b = SubElement(a, 'b') 1707 b.tail = 'b2' 1708 a.remove(b) 1709 self.assertXML( 1710 _bytes('<a></a>'), 1711 a) 1712 self.assertEqual('b2', b.tail)

1713

1714 - def _test_getchildren(self):

1715 Element = self.etree.Element 1716 SubElement = self.etree.SubElement 1717 1718 a = Element('a') 1719 b = SubElement(a, 'b') 1720 c = SubElement(a, 'c') 1721 d = SubElement(b, 'd') 1722 e = SubElement(c, 'e') 1723 self.assertXML( 1724 _bytes('<a><d></d><c><e></e></c></a>'), 1725 a) 1726 self.assertEqual( 1727 [b, c], 1728 a.getchildren()) 1729 self.assertEqual( 1730 [d], 1731 b.getchildren()) 1732 self.assertEqual( 1733 [], 1734 d.getchildren())

1735

1736 - def test_makeelement(self):

1737 Element = self.etree.Element 1738 1739 a = Element('a') 1740 b = a.makeelement('c', {'hoi':'dag'}) 1741 self.assertXML( 1742 _bytes('<c hoi="dag"></c>'), 1743 b)

1744 1745 required_versions_ET['test_iter'] = (1,3)

1746 - def test_iter(self):

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

1762

1763 - def test_getiterator(self):

1764 Element = self.etree.Element 1765 SubElement = self.etree.SubElement 1766 1767 a = Element('a') 1768 b = SubElement(a, 'b') 1769 c = SubElement(a, 'c') 1770 d = SubElement(b, 'd') 1771 e = SubElement(c, 'e') 1772 1773 self.assertEqual( 1774 [a, b, d, c, e], 1775 list(a.getiterator())) 1776 self.assertEqual( 1777 [d], 1778 list(d.getiterator()))

1779

1780 - def test_getiterator_empty(self):

1781 Element = self.etree.Element 1782 SubElement = self.etree.SubElement 1783 1784 a = Element('a') 1785 b = SubElement(a, 'b') 1786 c = SubElement(a, 'c') 1787 d = SubElement(b, 'd') 1788 e = SubElement(c, 'e') 1789 1790 self.assertEqual( 1791 [], 1792 list(a.getiterator('none'))) 1793 self.assertEqual( 1794 [], 1795 list(e.getiterator('none'))) 1796 self.assertEqual( 1797 [e], 1798 list(e.getiterator()))

1799

1800 - def test_getiterator_filter(self):

1801 Element = self.etree.Element 1802 SubElement = self.etree.SubElement 1803 1804 a = Element('a') 1805 b = SubElement(a, 'b') 1806 c = SubElement(a, 'c') 1807 d = SubElement(b, 'd') 1808 e = SubElement(c, 'e') 1809 1810 self.assertEqual( 1811 [a], 1812 list(a.getiterator('a'))) 1813 a2 = SubElement(e, 'a') 1814 self.assertEqual( 1815 [a, a2], 1816 list(a.getiterator('a'))) 1817 self.assertEqual( 1818 [a2], 1819 list(c.getiterator('a')))

1820

1821 - def test_getiterator_filter_all(self):

1822 Element = self.etree.Element 1823 SubElement = self.etree.SubElement 1824 1825 a = Element('a') 1826 b = SubElement(a, 'b') 1827 c = SubElement(a, 'c') 1828 d = SubElement(b, 'd') 1829 e = SubElement(c, 'e') 1830 1831 self.assertEqual( 1832 [a, b, d, c, e], 1833 list(a.getiterator('*')))

1834

1835 - def test_getiterator_filter_comment(self):

1836 Element = self.etree.Element 1837 Comment = self.etree.Comment 1838 SubElement = self.etree.SubElement 1839 1840 a = Element('a') 1841 b = SubElement(a, 'b') 1842 comment_b = Comment("TEST-b") 1843 b.append(comment_b) 1844 1845 self.assertEqual( 1846 [comment_b], 1847 list(a.getiterator(Comment))) 1848 1849 comment_a = Comment("TEST-a") 1850 a.append(comment_a) 1851 1852 self.assertEqual( 1853 [comment_b, comment_a], 1854 list(a.getiterator(Comment))) 1855 1856 self.assertEqual( 1857 [comment_b], 1858 list(b.getiterator(Comment)))

1859

1860 - def test_getiterator_filter_pi(self):

1861 Element = self.etree.Element 1862 PI = self.etree.ProcessingInstruction 1863 SubElement = self.etree.SubElement 1864 1865 a = Element('a') 1866 b = SubElement(a, 'b') 1867 pi_b = PI("TEST-b") 1868 b.append(pi_b) 1869 1870 self.assertEqual( 1871 [pi_b], 1872 list(a.getiterator(PI))) 1873 1874 pi_a = PI("TEST-a") 1875 a.append(pi_a) 1876 1877 self.assertEqual( 1878 [pi_b, pi_a], 1879 list(a.getiterator(PI))) 1880 1881 self.assertEqual( 1882 [pi_b], 1883 list(b.getiterator(PI)))

1884

1885 - def test_getiterator_with_text(self):

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

1907 #self.assertEqual( 1908 # [d], 1909 # list(d.getiterator())) 1910

1911 - def test_getiterator_filter_with_text(self):

1912 Element = self.etree.Element 1913 SubElement = self.etree.SubElement 1914 1915 a = Element('a') 1916 a.text = 'a' 1917 b = SubElement(a, 'b') 1918 b.text = 'b' 1919 b.tail = 'b1' 1920 c = SubElement(a, 'c') 1921 c.text = 'c' 1922 c.tail = 'c1' 1923 d = SubElement(b, 'd') 1924 c.text = 'd' 1925 c.tail = 'd1' 1926 e = SubElement(c, 'e') 1927 e.text = 'e' 1928 e.tail = 'e1' 1929 1930 self.assertEqual( 1931 [a], 1932 list(a.getiterator('a'))) 1933 a2 = SubElement(e, 'a') 1934 self.assertEqual( 1935 [a, a2], 1936 list(a.getiterator('a'))) 1937 self.assertEqual( 1938 [a2], 1939 list(e.getiterator('a')))

1940

1941 - def test_getslice(self):

1942 Element = self.etree.Element 1943 SubElement = self.etree.SubElement 1944 1945 a = Element('a') 1946 b = SubElement(a, 'b') 1947 c = SubElement(a, 'c') 1948 d = SubElement(a, 'd') 1949 1950 self.assertEqual( 1951 [b, c], 1952 a[0:2]) 1953 self.assertEqual( 1954 [b, c, d], 1955 a[:]) 1956 self.assertEqual( 1957 [b, c, d], 1958 a[:10]) 1959 self.assertEqual( 1960 [b], 1961 a[0:1]) 1962 self.assertEqual( 1963 [], 1964 a[10:12])

1965

1966 - def test_getslice_negative(self):

1967 Element = self.etree.Element 1968 SubElement = self.etree.SubElement 1969 1970 a = Element('a') 1971 b = SubElement(a, 'b') 1972 c = SubElement(a, 'c') 1973 d = SubElement(a, 'd') 1974 1975 self.assertEqual( 1976 [d], 1977 a[-1:]) 1978 self.assertEqual( 1979 [c, d], 1980 a[-2:]) 1981 self.assertEqual( 1982 [c], 1983 a[-2:-1]) 1984 self.assertEqual( 1985 [b, c], 1986 a[-3:-1]) 1987 self.assertEqual( 1988 [b, c], 1989 a[-3:2])

1990

1991 - def test_getslice_step(self):

1992 Element = self.etree.Element 1993 SubElement = self.etree.SubElement 1994 1995 a = Element('a') 1996 b = SubElement(a, 'b') 1997 c = SubElement(a, 'c') 1998 d = SubElement(a, 'd') 1999 e = SubElement(a, 'e') 2000 2001 self.assertEqual( 2002 [e,d,c,b], 2003 a[::-1]) 2004 self.assertEqual( 2005 [b,d], 2006 a[::2]) 2007 self.assertEqual( 2008 [e,c], 2009 a[::-2]) 2010 self.assertEqual( 2011 [d,c], 2012 a[-2:0:-1]) 2013 self.assertEqual( 2014 [e], 2015 a[:1:-2])

2016

2017 - def test_getslice_text(self):

2018 ElementTree = self.etree.ElementTree 2019 2020 f = BytesIO('<a>BB1<c>C</c>C1</a>') 2021 doc = ElementTree(file=f) 2022 a = doc.getroot() 2023 b = a[0] 2024 c = a[1] 2025 self.assertEqual( 2026 [b, c], 2027 a[:]) 2028 self.assertEqual( 2029 [b], 2030 a[0:1]) 2031 self.assertEqual( 2032 [c], 2033 a[1:])

2034

2035 - def test_comment_getitem_getslice(self):

2036 Element = self.etree.Element 2037 Comment = self.etree.Comment 2038 SubElement = self.etree.SubElement 2039 2040 a = Element('a') 2041 b = SubElement(a, 'b') 2042 foo = Comment('foo') 2043 a.append(foo) 2044 c = SubElement(a, 'c') 2045 self.assertEqual( 2046 [b, foo, c], 2047 a[:]) 2048 self.assertEqual( 2049 foo, 2050 a[1]) 2051 a[1] = new = Element('new') 2052 self.assertEqual( 2053 new, 2054 a[1]) 2055 self.assertXML( 2056 _bytes('<a><new></new><c></c></a>'), 2057 a)

2058

2059 - def test_delslice(self):

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

2073

2074 - def test_delslice_negative1(self):

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

2088

2089 - def test_delslice_negative2(self):

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

2103

2104 - def test_delslice_step(self):

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

2118

2119 - def test_delslice_step_negative(self):

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

2133

2134 - def test_delslice_step_negative2(self):

2135 Element = self.etree.Element 2136 SubElement = self.etree.SubElement 2137 2138 a = Element('a') 2139 b = SubElement(a, 'b') 2140 c = SubElement(a, 'c') 2141 d = SubElement(a, 'd') 2142 e = SubElement(a, 'e') 2143 2144 del a[::-2] 2145 self.assertEqual( 2146 [b, d], 2147 list(a))

2148

2149 - def test_delslice_child_tail(self):

2150 ElementTree = self.etree.ElementTree 2151 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2152 doc = ElementTree(file=f) 2153 a = doc.getroot() 2154 del a[1:3] 2155 self.assertXML( 2156 _bytes('<a>B2<e></e>E2</a>'), 2157 a)

2158

2159 - def test_delslice_tail(self):

2160 XML = self.etree.XML 2161 a = XML(_bytes('<a>B2<c></c>C2</a>')) 2162 b, c = a 2163 2164 del a[:] 2165 2166 self.assertEqual("B2", b.tail) 2167 self.assertEqual("C2", c.tail)

2168

2169 - def test_delslice_memory(self):

2170 # this could trigger a crash 2171 Element = self.etree.Element 2172 SubElement = self.etree.SubElement 2173 a = Element('a') 2174 b = SubElement(a, 'b') 2175 c = SubElement(b, 'c') 2176 del b # no more reference to b 2177 del a[:] 2178 self.assertEqual('c', c.tag)

2179

2180 - def test_setslice(self):

2181 Element = self.etree.Element 2182 SubElement = self.etree.SubElement 2183 2184 a = Element('a') 2185 b = SubElement(a, 'b') 2186 c = SubElement(a, 'c') 2187 d = SubElement(a, 'd') 2188 2189 e = Element('e') 2190 f = Element('f') 2191 g = Element('g') 2192 2193 s = [e, f, g] 2194 a[1:2] = s 2195 self.assertEqual( 2196 [b, e, f, g, d], 2197 list(a))

2198

2199 - def test_setslice_all(self):

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

2216

2217 - def test_setslice_all_empty(self):

2218 Element = self.etree.Element 2219 SubElement = self.etree.SubElement 2220 2221 a = Element('a') 2222 2223 e = Element('e') 2224 f = Element('f') 2225 g = Element('g') 2226 2227 s = [e, f, g] 2228 a[:] = s 2229 self.assertEqual( 2230 [e, f, g], 2231 list(a))

2232

2233 - def test_setslice_all_replace(self):

2234 Element = self.etree.Element 2235 SubElement = self.etree.SubElement 2236 2237 a = Element('a') 2238 b = SubElement(a, 'b') 2239 c = SubElement(a, 'c') 2240 d = SubElement(a, 'd') 2241 2242 s = [b, c, d] 2243 a[:] = s 2244 self.assertEqual( 2245 [b, c, d], 2246 list(a))

2247

2248 - def test_setslice_all_replace_reversed(self):

2249 Element = self.etree.Element 2250 SubElement = self.etree.SubElement 2251 2252 a = Element('a') 2253 b = SubElement(a, 'b') 2254 c = SubElement(a, 'c') 2255 d = SubElement(a, 'd') 2256 2257 s = [d, c, b] 2258 a[:] = s 2259 self.assertEqual( 2260 [d, c, b], 2261 list(a))

2262

2263 - def test_setslice_all_replace_reversed_ns1(self):

2264 Element = self.etree.Element 2265 SubElement = self.etree.SubElement 2266 2267 a = Element('{ns}a') 2268 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2269 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2270 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2271 2272 s = [d, c, b] 2273 a[:] = s 2274 self.assertEqual( 2275 [d, c, b], 2276 list(a)) 2277 self.assertEqual( 2278 ['{ns}d', '{ns}c', '{ns}b'], 2279 [ child.tag for child in a ]) 2280 2281 self.assertEqual( 2282 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2283 [ list(child.attrib.keys()) for child in a ])

2284

2285 - def test_setslice_all_replace_reversed_ns2(self):

2286 Element = self.etree.Element 2287 SubElement = self.etree.SubElement 2288 2289 a = Element('{ns}a') 2290 b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 2291 c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 2292 d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 2293 2294 s = [d, c, b] 2295 a[:] = s 2296 self.assertEqual( 2297 [d, c, b], 2298 list(a)) 2299 self.assertEqual( 2300 ['{ns3}d', '{ns2}c', '{ns1}b'], 2301 [ child.tag for child in a ]) 2302 2303 self.assertEqual( 2304 [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 2305 [ list(child.attrib.keys()) for child in a ])

2306

2307 - def test_setslice_end(self):

2308 Element = self.etree.Element 2309 SubElement = self.etree.SubElement 2310 2311 a = Element('a') 2312 b = SubElement(a, 'b') 2313 c = SubElement(a, 'c') 2314 2315 e = Element('e') 2316 f = Element('f') 2317 g = Element('g') 2318 h = Element('h') 2319 2320 s = [e, f] 2321 a[99:] = s 2322 self.assertEqual( 2323 [b, c, e, f], 2324 list(a)) 2325 2326 s = [g, h] 2327 a[:0] = s 2328 self.assertEqual( 2329 [g, h, b, c, e, f], 2330 list(a))

2331

2332 - def test_setslice_end_exact(self):

2333 Element = self.etree.Element 2334 SubElement = self.etree.SubElement 2335 2336 a = Element('a') 2337 b = SubElement(a, 'b') 2338 c = SubElement(a, 'c') 2339 d = SubElement(a, 'd') 2340 2341 e = Element('e') 2342 f = Element('f') 2343 g = Element('g') 2344 2345 s = [e, f, g] 2346 a[3:] = s 2347 self.assertEqual( 2348 [b, c, d, e, f, g], 2349 list(a))

2350

2351 - def test_setslice_single(self):

2352 Element = self.etree.Element 2353 SubElement = self.etree.SubElement 2354 2355 a = Element('a') 2356 b = SubElement(a, 'b') 2357 c = SubElement(a, 'c') 2358 2359 e = Element('e') 2360 f = Element('f') 2361 2362 s = [e] 2363 a[0:1] = s 2364 self.assertEqual( 2365 [e, c], 2366 list(a)) 2367 2368 s = [f] 2369 a[1:2] = s 2370 self.assertEqual( 2371 [e, f], 2372 list(a))

2373

2374 - def test_setslice_tail(self):

2375 ElementTree = self.etree.ElementTree 2376 Element = self.etree.Element 2377 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2378 doc = ElementTree(file=f) 2379 a = doc.getroot() 2380 x = Element('x') 2381 y = Element('y') 2382 z = Element('z') 2383 x.tail = 'X2' 2384 y.tail = 'Y2' 2385 z.tail = 'Z2' 2386 a[1:3] = [x, y, z] 2387 self.assertXML( 2388 _bytes('<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 2389 a)

2390

2391 - def test_setslice_negative(self):

2392 Element = self.etree.Element 2393 SubElement = self.etree.SubElement 2394 2395 a = Element('a') 2396 b = SubElement(a, 'b') 2397 c = SubElement(a, 'c') 2398 d = SubElement(a, 'd') 2399 2400 x = Element('x') 2401 y = Element('y') 2402 2403 a[1:-1] = [x, y] 2404 self.assertEqual( 2405 [b, x, y, d], 2406 list(a))

2407

2408 - def test_setslice_negative2(self):

2409 Element = self.etree.Element 2410 SubElement = self.etree.SubElement 2411 2412 a = Element('a') 2413 b = SubElement(a, 'b') 2414 c = SubElement(a, 'c') 2415 d = SubElement(a, 'd') 2416 2417 x = Element('x') 2418 y = Element('y') 2419 2420 a[1:-2] = [x, y] 2421 self.assertEqual( 2422 [b, x, y, c, d], 2423 list(a))

2424

2425 - def test_setslice_empty(self):

2426 Element = self.etree.Element 2427 2428 a = Element('a') 2429 2430 b = Element('b') 2431 c = Element('c') 2432 2433 a[:] = [b, c] 2434 self.assertEqual( 2435 [b, c], 2436 list(a))

2437

2438 - def test_tail_elementtree_root(self):

2439 Element = self.etree.Element 2440 ElementTree = self.etree.ElementTree 2441 2442 a = Element('a') 2443 a.tail = 'A2' 2444 t = ElementTree(element=a) 2445 self.assertEqual('A2', 2446 a.tail)

2447

2448 - def test_elementtree_getiterator(self):

2449 Element = self.etree.Element 2450 SubElement = self.etree.SubElement 2451 ElementTree = self.etree.ElementTree 2452 2453 a = Element('a') 2454 b = SubElement(a, 'b') 2455 c = SubElement(a, 'c') 2456 d = SubElement(b, 'd') 2457 e = SubElement(c, 'e') 2458 t = ElementTree(element=a) 2459 2460 self.assertEqual( 2461 [a, b, d, c, e], 2462 list(t.getiterator()))

2463

2464 - def test_elementtree_getiterator_filter(self):

2465 Element = self.etree.Element 2466 SubElement = self.etree.SubElement 2467 ElementTree = self.etree.ElementTree 2468 a = Element('a') 2469 b = SubElement(a, 'b') 2470 c = SubElement(a, 'c') 2471 d = SubElement(b, 'd') 2472 e = SubElement(c, 'e') 2473 t = ElementTree(element=a) 2474 2475 self.assertEqual( 2476 [a], 2477 list(t.getiterator('a'))) 2478 a2 = SubElement(e, 'a') 2479 self.assertEqual( 2480 [a, a2], 2481 list(t.getiterator('a')))

2482

2483 - def test_ns_access(self):

2484 ElementTree = self.etree.ElementTree 2485 ns = 'http://xml.infrae.com/1' 2486 f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2487 t = ElementTree(file=f) 2488 a = t.getroot() 2489 self.assertEqual('{%s}a' % ns, 2490 a.tag) 2491 self.assertEqual('{%s}b' % ns, 2492 a[0].tag)

2493

2494 - def test_ns_access2(self):

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

2507

2508 - def test_ns_setting(self):

2509 Element = self.etree.Element 2510 SubElement = self.etree.SubElement 2511 ns = 'http://xml.infrae.com/1' 2512 ns2 = 'http://xml.infrae.com/2' 2513 a = Element('{%s}a' % ns) 2514 b = SubElement(a, '{%s}b' % ns2) 2515 c = SubElement(a, '{%s}c' % ns) 2516 self.assertEqual('{%s}a' % ns, 2517 a.tag) 2518 self.assertEqual('{%s}b' % ns2, 2519 b.tag) 2520 self.assertEqual('{%s}c' % ns, 2521 c.tag) 2522 self.assertEqual('{%s}a' % ns, 2523 a.tag) 2524 self.assertEqual('{%s}b' % ns2, 2525 b.tag) 2526 self.assertEqual('{%s}c' % ns, 2527 c.tag)

2528

2529 - def test_ns_tag_parse(self):

2530 Element = self.etree.Element 2531 SubElement = self.etree.SubElement 2532 ElementTree = self.etree.ElementTree 2533 2534 ns = 'http://xml.infrae.com/1' 2535 ns2 = 'http://xml.infrae.com/2' 2536 f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2537 t = ElementTree(file=f) 2538 2539 a = t.getroot() 2540 self.assertEqual('{%s}a' % ns, 2541 a.tag) 2542 self.assertEqual('{%s}b' % ns2, 2543 a[0].tag) 2544 self.assertEqual('{%s}b' % ns, 2545 a[1].tag)

2546

2547 - def test_ns_attr(self):

2548 Element = self.etree.Element 2549 ns = 'http://xml.infrae.com/1' 2550 ns2 = 'http://xml.infrae.com/2' 2551 a = Element('a') 2552 a.set('{%s}foo' % ns, 'Foo') 2553 a.set('{%s}bar' % ns2, 'Bar') 2554 self.assertEqual( 2555 'Foo', 2556 a.get('{%s}foo' % ns)) 2557 self.assertEqual( 2558 'Bar', 2559 a.get('{%s}bar' % ns2)) 2560 try: 2561 self.assertXML( 2562 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 2563 a) 2564 except AssertionError: 2565 self.assertXML( 2566 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 2567 a)

2568

2569 - def test_ns_move(self):

2570 Element = self.etree.Element 2571 one = self.etree.fromstring( 2572 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2573 baz = one[0][0] 2574 2575 two = Element('root') 2576 two.append(baz) 2577 # removing the originating document could cause a crash/error before 2578 # as namespace is not moved along with it 2579 del one, baz 2580 self.assertEqual('{http://a.b.c}baz', two[0].tag)

2581

2582 - def test_ns_decl_tostring(self):

2583 tostring = self.etree.tostring 2584 root = self.etree.XML( 2585 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2586 baz = root[0][0] 2587 2588 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2589 tostring(baz)) 2590 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2591

2592 - def test_ns_decl_tostring_default(self):

2593 tostring = self.etree.tostring 2594 root = self.etree.XML( 2595 _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 2596 baz = root[0][0] 2597 2598 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2599 tostring(baz)) 2600 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2601

2602 - def test_ns_decl_tostring_root(self):

2603 tostring = self.etree.tostring 2604 root = self.etree.XML( 2605 _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')) 2606 baz = root[0][0] 2607 2608 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2609 tostring(baz)) 2610 2611 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2612

2613 - def test_ns_decl_tostring_element(self):

2614 Element = self.etree.Element 2615 SubElement = self.etree.SubElement 2616 2617 root = Element("foo") 2618 bar = SubElement(root, "{http://a.b.c}bar") 2619 baz = SubElement(bar, "{http://a.b.c}baz") 2620 2621 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2622 self.etree.tostring(baz)) 2623 2624 self.assertEqual([_bytes("http://a.b.c")], nsdecl)

2625

2626 - def test_attribute_xmlns_move(self):

2627 Element = self.etree.Element 2628 2629 root = Element('element') 2630 2631 subelement = Element('subelement', 2632 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2633 self.assertEqual(1, len(subelement.attrib)) 2634 self.assertEqual( 2635 "foo", 2636 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2637 2638 root.append(subelement) 2639 self.assertEqual(1, len(subelement.attrib)) 2640 self.assertEqual( 2641 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 2642 list(subelement.attrib.items())) 2643 self.assertEqual( 2644 "foo", 2645 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2646

2647 - def test_namespaces_after_serialize(self):

2648 parse = self.etree.parse 2649 tostring = self.etree.tostring 2650 2651 ns_href = "http://a.b.c" 2652 one = parse( 2653 BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2654 baz = one.getroot()[0][0] 2655 2656 parsed = parse(BytesIO( tostring(baz) )).getroot() 2657 self.assertEqual('{%s}baz' % ns_href, parsed.tag)

2658

2659 - def test_attribute_namespace_roundtrip(self):

2660 fromstring = self.etree.fromstring 2661 tostring = self.etree.tostring 2662 2663 ns_href = "http://a.b.c" 2664 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2665 ns_href,ns_href)) 2666 root = fromstring(xml) 2667 self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 2668 2669 xml2 = tostring(root) 2670 self.assertTrue(_bytes(':a=') in xml2, xml2) 2671 2672 root2 = fromstring(xml2) 2673 self.assertEqual('test', root2[0].get('{%s}a' % ns_href))

2674

2675 - def test_attribute_namespace_roundtrip_replaced(self):

2676 fromstring = self.etree.fromstring 2677 tostring = self.etree.tostring 2678 2679 ns_href = "http://a.b.c" 2680 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2681 ns_href,ns_href)) 2682 root = fromstring(xml) 2683 self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 2684 2685 root[0].set('{%s}a' % ns_href, 'TEST') 2686 2687 xml2 = tostring(root) 2688 self.assertTrue(_bytes(':a=') in xml2, xml2) 2689 2690 root2 = fromstring(xml2) 2691 self.assertEqual('TEST', root2[0].get('{%s}a' % ns_href))

2692 2693 required_versions_ET['test_register_namespace'] = (1,3)

2694 - def test_register_namespace(self):

2695 # ET 1.3+ 2696 Element = self.etree.Element 2697 prefix = 'TESTPREFIX' 2698 namespace = 'http://seriously.unknown/namespace/URI' 2699 2700 el = Element('{%s}test' % namespace) 2701 self.assertEqual(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 2702 self._writeElement(el)) 2703 2704 self.etree.register_namespace(prefix, namespace) 2705 el = Element('{%s}test' % namespace) 2706 self.assertEqual(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 2707 prefix, prefix, namespace, prefix)), 2708 self._writeElement(el)) 2709 2710 self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace)

2711

2712 - def test_tostring(self):

2713 tostring = self.etree.tostring 2714 Element = self.etree.Element 2715 SubElement = self.etree.SubElement 2716 2717 a = Element('a') 2718 b = SubElement(a, 'b') 2719 c = SubElement(a, 'c') 2720 2721 self.assertEqual(_bytes('<a><c></c></a>'), 2722 canonicalize(tostring(a)))

2723

2724 - def test_tostring_element(self):

2725 tostring = self.etree.tostring 2726 Element = self.etree.Element 2727 SubElement = self.etree.SubElement 2728 2729 a = Element('a') 2730 b = SubElement(a, 'b') 2731 c = SubElement(a, 'c') 2732 d = SubElement(c, 'd') 2733 self.assertEqual(_bytes(''), 2734 canonicalize(tostring(b))) 2735 self.assertEqual(_bytes('<c><d></d></c>'), 2736 canonicalize(tostring(c)))

2737

2738 - def test_tostring_element_tail(self):

2739 tostring = self.etree.tostring 2740 Element = self.etree.Element 2741 SubElement = self.etree.SubElement 2742 2743 a = Element('a') 2744 b = SubElement(a, 'b') 2745 c = SubElement(a, 'c') 2746 d = SubElement(c, 'd') 2747 b.tail = 'Foo' 2748 2749 self.assertTrue(tostring(b) == _bytes('Foo') or 2750 tostring(b) == _bytes('Foo'))

2751 2752 required_versions_ET['test_tostring_method_html'] = (1,3)

2753 - def test_tostring_method_html(self):

2754 tostring = self.etree.tostring 2755 Element = self.etree.Element 2756 SubElement = self.etree.SubElement 2757 2758 html = Element('html') 2759 body = SubElement(html, 'body') 2760 p = SubElement(body, 'p') 2761 p.text = "html" 2762 SubElement(p, 'br').tail = "test" 2763 2764 self.assertEqual(_bytes('<html><body>html test</body></html>'), 2765 tostring(html, method="html"))

2766 2767 required_versions_ET['test_tostring_method_text'] = (1,3)

2768 - def test_tostring_method_text(self):

2769 tostring = self.etree.tostring 2770 Element = self.etree.Element 2771 SubElement = self.etree.SubElement 2772 2773 a = Element('a') 2774 a.text = "A" 2775 a.tail = "tail" 2776 b = SubElement(a, 'b') 2777 b.text = "B" 2778 b.tail = "TAIL" 2779 c = SubElement(a, 'c') 2780 c.text = "C" 2781 2782 self.assertEqual(_bytes('ABTAILCtail'), 2783 tostring(a, method="text"))

2784

2785 - def test_iterparse(self):

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

2797

2798 - def test_iterparse_file(self):

2799 iterparse = self.etree.iterparse 2800 iterator = iterparse(fileInTestDir("test.xml")) 2801 self.assertEqual(None, 2802 iterator.root) 2803 events = list(iterator) 2804 root = iterator.root 2805 self.assertEqual( 2806 [('end', root[0]), ('end', root)], 2807 events)

2808

2809 - def test_iterparse_start(self):

2810 iterparse = self.etree.iterparse 2811 f = BytesIO('<a><c/></a>') 2812 2813 iterator = iterparse(f, events=('start',)) 2814 events = list(iterator) 2815 root = iterator.root 2816 self.assertEqual( 2817 [('start', root), ('start', root[0]), ('start', root[1])], 2818 events)

2819

2820 - def test_iterparse_start_end(self):

2821 iterparse = self.etree.iterparse 2822 f = BytesIO('<a><c/></a>') 2823 2824 iterator = iterparse(f, events=('start','end')) 2825 events = list(iterator) 2826 root = iterator.root 2827 self.assertEqual( 2828 [('start', root), ('start', root[0]), ('end', root[0]), 2829 ('start', root[1]), ('end', root[1]), ('end', root)], 2830 events)

2831

2832 - def test_iterparse_clear(self):

2833 iterparse = self.etree.iterparse 2834 f = BytesIO('<a><c/></a>') 2835 2836 iterator = iterparse(f) 2837 for event, elem in iterator: 2838 elem.clear() 2839 2840 root = iterator.root 2841 self.assertEqual(0, 2842 len(root))

2843

2844 - def test_iterparse_large(self):

2845 iterparse = self.etree.iterparse 2846 CHILD_COUNT = 12345 2847 f = BytesIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2848 2849 i = 0 2850 for key in iterparse(f): 2851 event, element = key 2852 i += 1 2853 self.assertEqual(i, CHILD_COUNT + 1)

2854

2855 - def test_iterparse_attrib_ns(self):

2856 iterparse = self.etree.iterparse 2857 f = BytesIO('<a xmlns="http://ns1/"><c xmlns="http://ns2/"/></a>') 2858 2859 attr_name = '{http://testns/}bla' 2860 events = [] 2861 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2862 for event, elem in iterator: 2863 events.append(event) 2864 if event == 'start': 2865 if elem.tag != '{http://ns1/}a': 2866 elem.set(attr_name, 'value') 2867 2868 self.assertEqual( 2869 ['start-ns', 'start', 'start', 'start-ns', 'start', 2870 'end', 'end-ns', 'end', 'end', 'end-ns'], 2871 events) 2872 2873 root = iterator.root 2874 self.assertEqual( 2875 None, 2876 root.get(attr_name)) 2877 self.assertEqual( 2878 'value', 2879 root[0].get(attr_name))

2880

2881 - def test_iterparse_getiterator(self):

2882 iterparse = self.etree.iterparse 2883 f = BytesIO('<a><d/><c/></a>') 2884 2885 counts = [] 2886 for event, elem in iterparse(f): 2887 counts.append(len(list(elem.getiterator()))) 2888 self.assertEqual( 2889 [1,2,1,4], 2890 counts)

2891

2892 - def test_iterparse_move_elements(self):

2893 iterparse = self.etree.iterparse 2894 f = BytesIO('<a><d/><c/></a>') 2895 2896 for event, node in etree.iterparse(f): pass 2897 2898 root = etree.Element('new_root', {}) 2899 root[:] = node[:] 2900 2901 self.assertEqual( 2902 ['b', 'c'], 2903 [ el.tag for el in root ])

2904

2905 - def test_iterparse_cdata(self):

2906 tostring = self.etree.tostring 2907 f = BytesIO('<root><![CDATA[test]]></root>') 2908 context = self.etree.iterparse(f) 2909 content = [ el.text for event,el in context ] 2910 2911 self.assertEqual(['test'], content) 2912 self.assertEqual(_bytes('<root>test</root>'), 2913 tostring(context.root))

2914

2915 - def test_parse_file(self):

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

2922

2923 - def test_parse_file_nonexistent(self):

2924 parse = self.etree.parse 2925 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2926

2927 - def test_parse_error_none(self):

2928 parse = self.etree.parse 2929 self.assertRaises(TypeError, parse, None)

2930 2931 required_versions_ET['test_parse_error'] = (1,3)

2932 - def test_parse_error(self):

2933 # ET < 1.3 raises ExpatError 2934 parse = self.etree.parse 2935 f = BytesIO('<a></c></a>') 2936 self.assertRaises(SyntaxError, parse, f) 2937 f.close()

2938 2939 required_versions_ET['test_parse_error_from_file'] = (1,3)

2940 - def test_parse_error_from_file(self):

2941 parse = self.etree.parse 2942 # from file 2943 f = open(fileInTestDir('test_broken.xml'), 'rb') 2944 self.assertRaises(SyntaxError, parse, f) 2945 f.close()

2946

2947 - def test_parse_file_object(self):

2948 parse = self.etree.parse 2949 # from file object 2950 f = open(fileInTestDir('test.xml'), 'rb') 2951 tree = parse(f) 2952 f.close() 2953 self.assertXML( 2954 _bytes('<a></a>'), 2955 tree.getroot())

2956

2957 - def test_parse_stringio(self):

2958 parse = self.etree.parse 2959 f = BytesIO('<a></a>') 2960 tree = parse(f) 2961 f.close() 2962 self.assertXML( 2963 _bytes('<a></a>'), 2964 tree.getroot() 2965 )

2966

2967 - def test_parse_cdata(self):

2968 tostring = self.etree.tostring 2969 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 2970 2971 self.assertEqual('test', root.text) 2972 self.assertEqual(_bytes('<root>test</root>'), 2973 tostring(root))

2974

2975 - def test_parse_with_encoding(self):

2976 # this can fail in libxml2 <= 2.6.22 2977 parse = self.etree.parse 2978 tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2979 self.assertXML(_bytes('<html></html>'), 2980 tree.getroot())

2981

2982 - def test_encoding(self):

2983 Element = self.etree.Element 2984 2985 a = Element('a') 2986 a.text = _str('Søk på nettet') 2987 self.assertXML( 2988 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2989 a, 'utf-8')

2990

2991 - def test_encoding_exact(self):

2992 ElementTree = self.etree.ElementTree 2993 Element = self.etree.Element 2994 2995 a = Element('a') 2996 a.text = _str('Søk på nettet') 2997 2998 f = BytesIO() 2999 tree = ElementTree(element=a) 3000 tree.write(f, encoding='utf-8') 3001 self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 3002 f.getvalue().replace(_bytes('\n'),_bytes('')))

3003

3004 - def test_parse_file_encoding(self):

3005 parse = self.etree.parse 3006 # from file 3007 tree = parse(fileInTestDir('test-string.xml')) 3008 self.assertXML( 3009 _str('<a>Søk på nettet</a>').encode('UTF-8'), 3010 tree.getroot(), 'UTF-8')

3011

3012 - def test_parse_file_object_encoding(self):

3013 parse = self.etree.parse 3014 # from file object 3015 f = open(fileInTestDir('test-string.xml'), 'rb') 3016 tree = parse(f) 3017 f.close() 3018 self.assertXML( 3019 _str('<a>Søk på nettet</a>').encode('UTF-8'), 3020 tree.getroot(), 'UTF-8')

3021

3022 - def test_encoding_8bit_latin1(self):

3023 ElementTree = self.etree.ElementTree 3024 Element = self.etree.Element 3025 3026 a = Element('a') 3027 a.text = _str('Søk på nettet') 3028 3029 f = BytesIO() 3030 tree = ElementTree(element=a) 3031 tree.write(f, encoding='iso-8859-1') 3032 result = f.getvalue() 3033 declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 3034 self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 3035 result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 3036 self.assertEqual(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 3037 result)

3038 3039 required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3)

3040 - def test_parse_encoding_8bit_explicit(self):

3041 XMLParser = self.XMLParser 3042 3043 text = _str('Søk på nettet') 3044 xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 3045 3046 self.assertRaises(self.etree.ParseError, 3047 self.etree.parse, 3048 BytesIO(xml_latin1)) 3049 3050 tree = self.etree.parse(BytesIO(xml_latin1), 3051 XMLParser(encoding="iso-8859-1")) 3052 a = tree.getroot() 3053 self.assertEqual(a.text, text)

3054 3055 required_versions_ET['test_parse_encoding_8bit_override'] = (1,3)

3056 - def test_parse_encoding_8bit_override(self):

3057 XMLParser = self.XMLParser 3058 3059 text = _str('Søk på nettet') 3060 wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>") 3061 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 3062 ).encode('iso-8859-1') 3063 3064 self.assertRaises(self.etree.ParseError, 3065 self.etree.parse, 3066 BytesIO(xml_latin1)) 3067 3068 tree = self.etree.parse(BytesIO(xml_latin1), 3069 XMLParser(encoding="iso-8859-1")) 3070 a = tree.getroot() 3071 self.assertEqual(a.text, text)

3072

3073 - def _test_wrong_unicode_encoding(self):

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

3079

3080 - def test_encoding_write_default_encoding(self):

3081 ElementTree = self.etree.ElementTree 3082 Element = self.etree.Element 3083 3084 a = Element('a') 3085 a.text = _str('Søk på nettet') 3086 3087 f = BytesIO() 3088 tree = ElementTree(element=a) 3089 tree.write(f) 3090 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 3091 self.assertEqual( 3092 _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 3093 data)

3094

3095 - def test_encoding_tostring(self):

3096 Element = self.etree.Element 3097 tostring = self.etree.tostring 3098 3099 a = Element('a') 3100 a.text = _str('Søk på nettet') 3101 self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 3102 tostring(a, encoding='utf-8'))

3103

3104 - def test_encoding_tostring_unknown(self):

3105 Element = self.etree.Element 3106 tostring = self.etree.tostring 3107 3108 a = Element('a') 3109 a.text = _str('Søk på nettet') 3110 self.assertRaises(LookupError, tostring, a, 3111 encoding='Invalid Encoding')

3112

3113 - def test_encoding_tostring_sub(self):

3114 Element = self.etree.Element 3115 SubElement = self.etree.SubElement 3116 tostring = self.etree.tostring 3117 3118 a = Element('a') 3119 b = SubElement(a, 'b') 3120 b.text = _str('Søk på nettet') 3121 self.assertEqual(_str('Søk på nettet').encode('UTF-8'), 3122 tostring(b, encoding='utf-8'))

3123

3124 - def test_encoding_tostring_sub_tail(self):

3125 Element = self.etree.Element 3126 SubElement = self.etree.SubElement 3127 tostring = self.etree.tostring 3128 3129 a = Element('a') 3130 b = SubElement(a, 'b') 3131 b.text = _str('Søk på nettet') 3132 b.tail = _str('Søk') 3133 self.assertEqual(_str('Søk på nettetSøk').encode('UTF-8'), 3134 tostring(b, encoding='utf-8'))

3135

3136 - def test_encoding_tostring_default_encoding(self):

3137 Element = self.etree.Element 3138 SubElement = self.etree.SubElement 3139 tostring = self.etree.tostring 3140 3141 a = Element('a') 3142 a.text = _str('Søk på nettet') 3143 3144 expected = _bytes('<a>Søk på nettet</a>') 3145 self.assertEqual( 3146 expected, 3147 tostring(a))

3148

3149 - def test_encoding_sub_tostring_default_encoding(self):

3150 Element = self.etree.Element 3151 SubElement = self.etree.SubElement 3152 tostring = self.etree.tostring 3153 3154 a = Element('a') 3155 b = SubElement(a, 'b') 3156 b.text = _str('Søk på nettet') 3157 3158 expected = _bytes('Søk på nettet') 3159 self.assertEqual( 3160 expected, 3161 tostring(b))

3162

3163 - def test_encoding_8bit_xml(self):

3164 utext = _str('Søk på nettet') 3165 uxml = _str('%s') % utext 3166 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3167 isoxml = prologue + uxml.encode('iso-8859-1') 3168 tree = self.etree.XML(isoxml) 3169 self.assertEqual(utext, tree.text)

3170

3171 - def test_encoding_utf8_bom(self):

3172 utext = _str('Søk på nettet') 3173 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 3174 _str('%s') % utext) 3175 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 3176 xml = bom + uxml.encode("utf-8") 3177 tree = etree.XML(xml) 3178 self.assertEqual(utext, tree.text)

3179

3180 - def test_encoding_8bit_parse_stringio(self):

3181 utext = _str('Søk på nettet') 3182 uxml = _str('%s') % utext 3183 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3184 isoxml = prologue + uxml.encode('iso-8859-1') 3185 el = self.etree.parse(BytesIO(isoxml)).getroot() 3186 self.assertEqual(utext, el.text)

3187

3188 - def test_deepcopy_elementtree(self):

3189 Element = self.etree.Element 3190 ElementTree = self.etree.ElementTree 3191 3192 a = Element('a') 3193 a.text = "Foo" 3194 atree = ElementTree(a) 3195 3196 btree = copy.deepcopy(atree) 3197 self.assertEqual("Foo", atree.getroot().text) 3198 self.assertEqual("Foo", btree.getroot().text) 3199 self.assertFalse(btree is atree) 3200 self.assertFalse(btree.getroot() is atree.getroot())

3201

3202 - def test_deepcopy(self):

3203 Element = self.etree.Element 3204 3205 a = Element('a') 3206 a.text = 'Foo' 3207 3208 b = copy.deepcopy(a) 3209 self.assertEqual('Foo', b.text) 3210 3211 b.text = 'Bar' 3212 self.assertEqual('Bar', b.text) 3213 self.assertEqual('Foo', a.text) 3214 3215 del a 3216 self.assertEqual('Bar', b.text)

3217

3218 - def test_deepcopy_tail(self):

3219 Element = self.etree.Element 3220 3221 a = Element('a') 3222 a.tail = 'Foo' 3223 3224 b = copy.deepcopy(a) 3225 self.assertEqual('Foo', b.tail) 3226 3227 b.tail = 'Bar' 3228 self.assertEqual('Bar', b.tail) 3229 self.assertEqual('Foo', a.tail) 3230 3231 del a 3232 self.assertEqual('Bar', b.tail)

3233

3234 - def test_deepcopy_subelement(self):

3235 Element = self.etree.Element 3236 SubElement = self.etree.SubElement 3237 3238 root = Element('root') 3239 a = SubElement(root, 'a') 3240 a.text = 'FooText' 3241 a.tail = 'FooTail' 3242 3243 b = copy.deepcopy(a) 3244 self.assertEqual('FooText', b.text) 3245 self.assertEqual('FooTail', b.tail) 3246 3247 b.text = 'BarText' 3248 b.tail = 'BarTail' 3249 self.assertEqual('BarTail', b.tail) 3250 self.assertEqual('FooTail', a.tail) 3251 self.assertEqual('BarText', b.text) 3252 self.assertEqual('FooText', a.text) 3253 3254 del a 3255 self.assertEqual('BarTail', b.tail) 3256 self.assertEqual('BarText', b.text)

3257

3258 - def test_deepcopy_namespaces(self):

3259 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 3260 <parent><node t:foo="bar" /></parent> 3261 </doc>''')) 3262 self.assertEqual( 3263 root[0][0].get('{tns}foo'), 3264 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3265 self.assertEqual( 3266 root[0][0].get('{tns}foo'), 3267 copy.deepcopy(root[0][0]).get('{tns}foo') )

3268

3269 - def test_deepcopy_append(self):

3270 # previously caused a crash 3271 Element = self.etree.Element 3272 tostring = self.etree.tostring 3273 3274 a = Element('a') 3275 b = copy.deepcopy(a) 3276 a.append( Element('C') ) 3277 b.append( Element('X') ) 3278 3279 self.assertEqual(_bytes('<a><C/></a>'), 3280 tostring(a).replace(_bytes(' '), _bytes(''))) 3281 self.assertEqual(_bytes('<a><X/></a>'), 3282 tostring(b).replace(_bytes(' '), _bytes('')))

3283

3284 - def test_deepcopy_comment(self):

3285 # previously caused a crash 3286 # not supported by ET < 1.3! 3287 Comment = self.etree.Comment 3288 3289 a = Comment("ONE") 3290 b = copy.deepcopy(a) 3291 b.text = "ANOTHER" 3292 3293 self.assertEqual('ONE', a.text) 3294 self.assertEqual('ANOTHER', b.text)

3295

3296 - def test_shallowcopy(self):

3297 Element = self.etree.Element 3298 3299 a = Element('a') 3300 a.text = 'Foo' 3301 3302 b = copy.copy(a) 3303 self.assertEqual('Foo', b.text) 3304 3305 b.text = 'Bar' 3306 self.assertEqual('Bar', b.text) 3307 self.assertEqual('Foo', a.text)

3308 # XXX ElementTree will share nodes, but lxml.etree won't.. 3309

3310 - def test_shallowcopy_elementtree(self):

3311 Element = self.etree.Element 3312 ElementTree = self.etree.ElementTree 3313 3314 a = Element('a') 3315 a.text = 'Foo' 3316 atree = ElementTree(a) 3317 3318 btree = copy.copy(atree) 3319 self.assertFalse(btree is atree) 3320 self.assertTrue(btree.getroot() is atree.getroot()) 3321 self.assertEqual('Foo', atree.getroot().text)

3322

3323 - def _test_element_boolean(self):

3324 # deprecated as of ET 1.3/lxml 2.0 3325 etree = self.etree 3326 e = etree.Element('foo') 3327 self.assertEqual(False, bool(e)) 3328 etree.SubElement(e, 'bar') 3329 self.assertEqual(True, bool(e)) 3330 e = etree.Element('foo') 3331 e.text = 'hey' 3332 self.assertEqual(False, bool(e)) 3333 e = etree.Element('foo') 3334 e.tail = 'bar' 3335 self.assertEqual(False, bool(e)) 3336 e = etree.Element('foo') 3337 e.set('bar', 'Bar') 3338 self.assertEqual(False, bool(e))

3339

3340 - def test_multiple_elementrees(self):

3341 etree = self.etree 3342 3343 a = etree.Element('a') 3344 b = etree.SubElement(a, 'b') 3345 3346 t = etree.ElementTree(a) 3347 self.assertEqual(self._rootstring(t), _bytes('<a></a>')) 3348 3349 t1 = etree.ElementTree(a) 3350 self.assertEqual(self._rootstring(t1), _bytes('<a></a>')) 3351 self.assertEqual(self._rootstring(t), _bytes('<a></a>')) 3352 3353 t2 = etree.ElementTree(b) 3354 self.assertEqual(self._rootstring(t2), _bytes('')) 3355 self.assertEqual(self._rootstring(t1), _bytes('<a></a>')) 3356 self.assertEqual(self._rootstring(t), _bytes('<a></a>'))

3357

3358 - def test_qname(self):

3359 etree = self.etree 3360 qname = etree.QName('myns', 'a') 3361 a1 = etree.Element(qname) 3362 a2 = etree.SubElement(a1, qname) 3363 self.assertEqual(a1.tag, "{myns}a") 3364 self.assertEqual(a2.tag, "{myns}a")

3365

3366 - def test_qname_cmp(self):

3367 etree = self.etree 3368 qname1 = etree.QName('myns', 'a') 3369 qname2 = etree.QName('myns', 'a') 3370 self.assertEqual(qname1, "{myns}a") 3371 self.assertEqual("{myns}a", qname2) 3372 self.assertEqual(qname1, qname1) 3373 self.assertEqual(qname1, qname2)

3374

3375 - def test_qname_attribute_getset(self):

3376 etree = self.etree 3377 qname = etree.QName('myns', 'a') 3378 3379 a = etree.Element(qname) 3380 a.set(qname, "value") 3381 3382 self.assertEqual(a.get(qname), "value") 3383 self.assertEqual(a.get("{myns}a"), "value")

3384

3385 - def test_qname_attrib(self):

3386 etree = self.etree 3387 qname = etree.QName('myns', 'a') 3388 3389 a = etree.Element(qname) 3390 a.attrib[qname] = "value" 3391 3392 self.assertEqual(a.attrib[qname], "value") 3393 self.assertEqual(a.attrib.get(qname), "value") 3394 3395 self.assertEqual(a.attrib["{myns}a"], "value") 3396 self.assertEqual(a.attrib.get("{myns}a"), "value")

3397

3398 - def test_qname_attribute_resolve(self):

3399 etree = self.etree 3400 qname = etree.QName('http://myns', 'a') 3401 a = etree.Element(qname) 3402 a.set(qname, qname) 3403 3404 self.assertXML( 3405 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3406 a)

3407

3408 - def test_qname_attribute_resolve_new(self):

3409 etree = self.etree 3410 qname = etree.QName('http://myns', 'a') 3411 a = etree.Element('a') 3412 a.set('a', qname) 3413 3414 self.assertXML( 3415 _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 3416 a)

3417

3418 - def test_qname_attrib_resolve(self):

3419 etree = self.etree 3420 qname = etree.QName('http://myns', 'a') 3421 a = etree.Element(qname) 3422 a.attrib[qname] = qname 3423 3424 self.assertXML( 3425 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3426 a)

3427

3428 - def test_parser_version(self):

3429 etree = self.etree 3430 parser = etree.XMLParser() 3431 if hasattr(parser, "version"): 3432 # ElementTree 1.3+, cET 3433 self.assertTrue(re.match("[^ ]+ [0-9.]+", parser.version))

3434 3435 # feed parser interface 3436

3437 - def test_feed_parser_bytes(self):

3438 parser = self.XMLParser() 3439 3440 parser.feed(_bytes('<?xml version=')) 3441 parser.feed(_bytes('"1.0"?><ro')) 3442 parser.feed(_bytes('ot><')) 3443 parser.feed(_bytes('a test="works"/')) 3444 parser.feed(_bytes('></root')) 3445 parser.feed(_bytes('>')) 3446 3447 root = parser.close() 3448 3449 self.assertEqual(root.tag, "root") 3450 self.assertEqual(root[0].tag, "a") 3451 self.assertEqual(root[0].get("test"), "works")

3452

3453 - def test_feed_parser_unicode(self):

3454 parser = self.XMLParser() 3455 3456 parser.feed(_str('<ro')) 3457 parser.feed(_str('ot><')) 3458 parser.feed(_str('a test="works"/')) 3459 parser.feed(_str('></root')) 3460 parser.feed(_str('>')) 3461 3462 root = parser.close() 3463 3464 self.assertEqual(root.tag, "root") 3465 self.assertEqual(root[0].tag, "a") 3466 self.assertEqual(root[0].get("test"), "works")

3467 3468 required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)

3469 - def test_feed_parser_error_close_empty(self):

3470 ParseError = self.etree.ParseError 3471 parser = self.XMLParser() 3472 self.assertRaises(ParseError, parser.close)

3473 3474 required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3)

3475 - def test_feed_parser_error_close_incomplete(self):

3476 ParseError = self.etree.ParseError 3477 parser = self.XMLParser() 3478 3479 parser.feed('<?xml version=') 3480 parser.feed('"1.0"?><ro') 3481 3482 self.assertRaises(ParseError, parser.close)

3483 3484 required_versions_ET['test_feed_parser_error_broken'] = (1,3)

3485 - def test_feed_parser_error_broken(self):

3486 ParseError = self.etree.ParseError 3487 parser = self.XMLParser() 3488 3489 parser.feed('<?xml version=') 3490 parser.feed('"1.0"?><ro') 3491 try: 3492 parser.feed('<><><><><><><') 3493 except ParseError: 3494 # can raise, but not required before close() 3495 pass 3496 3497 self.assertRaises(ParseError, parser.close)

3498 3499 required_versions_ET['test_feed_parser_error_position'] = (1,3)

3500 - def test_feed_parser_error_position(self):

3501 ParseError = self.etree.ParseError 3502 parser = self.XMLParser() 3503 try: 3504 parser.close() 3505 except ParseError: 3506 e = sys.exc_info()[1] 3507 self.assertNotEqual(None, e.code) 3508 self.assertNotEqual(0, e.code) 3509 self.assertTrue(isinstance(e.position, tuple)) 3510 self.assertTrue(e.position >= (0, 0))

3511 3512 # parser target interface 3513 3514 required_versions_ET['test_parser_target_property'] = (1,3)

3515 - def test_parser_target_property(self):

3516 class Target(object): 3517 pass

3518 3519 target = Target() 3520 parser = self.XMLParser(target=target) 3521 3522 self.assertEqual(target, parser.target) 3523

3524 - def test_parser_target_tag(self):

3525 assertEqual = self.assertEqual 3526 assertFalse = self.assertFalse 3527 3528 events = [] 3529 class Target(object): 3530 def start(self, tag, attrib): 3531 events.append("start") 3532 assertFalse(attrib) 3533 assertEqual("TAG", tag)

3534 def end(self, tag): 3535 events.append("end") 3536 assertEqual("TAG", tag) 3537 def close(self): 3538 return "DONE" 3539 3540 parser = self.XMLParser(target=Target()) 3541 3542 parser.feed("<TAG/>") 3543 done = parser.close() 3544 3545 self.assertEqual("DONE", done) 3546 self.assertEqual(["start", "end"], events) 3547

3548 - def test_parser_target_error_in_start(self):

3549 assertEqual = self.assertEqual 3550 3551 events = [] 3552 class Target(object): 3553 def start(self, tag, attrib): 3554 events.append("start") 3555 assertEqual("TAG", tag) 3556 raise ValueError("TEST")

3557 def end(self, tag): 3558 events.append("end") 3559 assertEqual("TAG", tag) 3560 def close(self): 3561 return "DONE" 3562 3563 parser = self.XMLParser(target=Target()) 3564 3565 try: 3566 parser.feed("<TAG/>") 3567 except ValueError: 3568 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3569 else: 3570 self.assertTrue(False) 3571 if 'lxml' in self.etree.__name__: 3572 self.assertEqual(["start"], events) 3573 else: 3574 # cElementTree calls end() as well 3575 self.assertTrue("start" in events) 3576

3577 - def test_parser_target_error_in_end(self):

3578 assertEqual = self.assertEqual 3579 3580 events = [] 3581 class Target(object): 3582 def start(self, tag, attrib): 3583 events.append("start") 3584 assertEqual("TAG", tag)

3585 def end(self, tag): 3586 events.append("end") 3587 assertEqual("TAG", tag) 3588 raise ValueError("TEST") 3589 def close(self): 3590 return "DONE" 3591 3592 parser = self.XMLParser(target=Target()) 3593 3594 try: 3595 parser.feed("<TAG/>") 3596 except ValueError: 3597 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3598 else: 3599 self.assertTrue(False) 3600 self.assertEqual(["start", "end"], events) 3601

3602 - def test_parser_target_error_in_close(self):

3603 assertEqual = self.assertEqual 3604 3605 events = [] 3606 class Target(object): 3607 def start(self, tag, attrib): 3608 events.append("start") 3609 assertEqual("TAG", tag)

3610 def end(self, tag): 3611 events.append("end") 3612 assertEqual("TAG", tag) 3613 def close(self): 3614 raise ValueError("TEST") 3615 3616 parser = self.XMLParser(target=Target()) 3617 3618 try: 3619 parser.feed("<TAG/>") 3620 parser.close() 3621 except ValueError: 3622 self.assertTrue('TEST' in str(sys.exc_info()[1])) 3623 else: 3624 self.assertTrue(False) 3625 self.assertEqual(["start", "end"], events) 3626

3627 - def test_parser_target_error_in_start_and_close(self):

3628 assertEqual = self.assertEqual 3629 3630 events = [] 3631 class Target(object): 3632 def start(self, tag, attrib): 3633 events.append("start") 3634 assertEqual("TAG", tag) 3635 raise IndexError("TEST-IE")

3636 def end(self, tag): 3637 events.append("end") 3638 assertEqual("TAG", tag) 3639 def close(self): 3640 raise ValueError("TEST-VE") 3641 3642 parser = self.XMLParser(target=Target()) 3643 3644 try: 3645 parser.feed("<TAG/>") 3646 parser.close() 3647 except IndexError: 3648 if 'lxml' in self.etree.__name__: 3649 # we try not to swallow the initial exception in Py2 3650 self.assertTrue(sys.version_info[0] < 3) 3651 self.assertTrue('TEST-IE' in str(sys.exc_info()[1])) 3652 except ValueError: 3653 if 'lxml' in self.etree.__name__: 3654 self.assertTrue(sys.version_info[0] >= 3) 3655 self.assertTrue('TEST-VE' in str(sys.exc_info()[1])) 3656 else: 3657 self.assertTrue(False) 3658 3659 if 'lxml' in self.etree.__name__: 3660 self.assertEqual(["start"], events) 3661 else: 3662 # cElementTree calls end() as well 3663 self.assertTrue("start" in events) 3664

3665 - def test_elementtree_parser_target(self):

3666 assertEqual = self.assertEqual 3667 assertFalse = self.assertFalse 3668 Element = self.etree.Element 3669 3670 events = [] 3671 class Target(object): 3672 def start(self, tag, attrib): 3673 events.append("start") 3674 assertFalse(attrib) 3675 assertEqual("TAG", tag)

3676 def end(self, tag): 3677 events.append("end") 3678 assertEqual("TAG", tag) 3679 def close(self): 3680 return Element("DONE") 3681 3682 parser = self.XMLParser(target=Target()) 3683 tree = self.etree.ElementTree() 3684 tree.parse(BytesIO("<TAG/>"), parser=parser) 3685 3686 self.assertEqual("DONE", tree.getroot().tag) 3687 self.assertEqual(["start", "end"], events) 3688

3689 - def test_parser_target_attrib(self):

3690 assertEqual = self.assertEqual 3691 3692 events = [] 3693 class Target(object): 3694 def start(self, tag, attrib): 3695 events.append("start-" + tag) 3696 for name, value in attrib.items(): 3697 assertEqual(tag + name, value)

3698 def end(self, tag): 3699 events.append("end-" + tag) 3700 def close(self): 3701 return "DONE" 3702 3703 parser = self.XMLParser(target=Target()) 3704 3705 parser.feed('<root a="roota" b="rootb"></root>') 3706 done = parser.close() 3707 3708 self.assertEqual("DONE", done) 3709 self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"], 3710 events) 3711

3712 - def test_parser_target_data(self):

3713 events = [] 3714 class Target(object): 3715 def start(self, tag, attrib): 3716 events.append("start-" + tag)

3717 def end(self, tag): 3718 events.append("end-" + tag) 3719 def data(self, data): 3720 events.append("data-" + data) 3721 def close(self): 3722 return "DONE" 3723 3724 parser = self.XMLParser(target=Target()) 3725 3726 parser.feed('<root>AB</root>') 3727 done = parser.close() 3728 3729 self.assertEqual("DONE", done) 3730 self.assertEqual(["start-root", "data-A", "start-sub", 3731 "end-sub", "data-B", "end-root"], 3732 events) 3733

3734 - def test_parser_target_entity(self):

3735 events = [] 3736 class Target(object): 3737 def __init__(self): 3738 self._data = []

3739 def _flush_data(self): 3740 if self._data: 3741 events.append("data-" + ''.join(self._data)) 3742 del self._data[:] 3743 def start(self, tag, attrib): 3744 self._flush_data() 3745 events.append("start-" + tag) 3746 def end(self, tag): 3747 self._flush_data() 3748 events.append("end-" + tag) 3749 def data(self, data): 3750 self._data.append(data) 3751 def close(self): 3752 self._flush_data() 3753 return "DONE" 3754 3755 parser = self.XMLParser(target=Target()) 3756 3757 dtd = ''' 3758 <!DOCTYPE root [ 3759 <!ELEMENT root (sub*)> 3760 <!ELEMENT sub (#PCDATA)> 3761 <!ENTITY ent "an entity"> 3762 ]> 3763 ''' 3764 parser.feed(dtd+'<root>this is &ent;</root>') 3765 done = parser.close() 3766 3767 self.assertEqual("DONE", done) 3768 self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub", 3769 "data-this is an entity", 3770 "end-sub", "start-sub", "end-sub", "end-root"], 3771 events) 3772 3773 required_versions_ET['test_parser_target_entity_unknown'] = (1,3)

3774 - def test_parser_target_entity_unknown(self):

3775 events = [] 3776 class Target(object): 3777 def __init__(self): 3778 self._data = []

3779 def _flush_data(self): 3780 if self._data: 3781 events.append("data-" + ''.join(self._data)) 3782 del self._data[:] 3783 def start(self, tag, attrib): 3784 self._flush_data() 3785 events.append("start-" + tag) 3786 def end(self, tag): 3787 self._flush_data() 3788 events.append("end-" + tag) 3789 def data(self, data): 3790 self._data.append(data) 3791 def close(self): 3792 self._flush_data() 3793 return "DONE" 3794 3795 parser = self.XMLParser(target=Target()) 3796 3797 def feed(): 3798 parser.feed('<root>some &ent;</root>') 3799 parser.close() 3800 3801 self.assertRaises(self.etree.ParseError, feed) 3802

3803 - def test_treebuilder(self):

3804 builder = self.etree.TreeBuilder() 3805 el = builder.start("root", {'a':'A', 'b':'B'}) 3806 self.assertEqual("root", el.tag) 3807 self.assertEqual({'a':'A', 'b':'B'}, el.attrib) 3808 builder.data("ROOTTEXT") 3809 el = builder.start("child", {'x':'X', 'y':'Y'}) 3810 self.assertEqual("child", el.tag) 3811 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 3812 builder.data("CHILDTEXT") 3813 el = builder.end("child") 3814 self.assertEqual("child", el.tag) 3815 self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 3816 self.assertEqual("CHILDTEXT", el.text) 3817 self.assertEqual(None, el.tail) 3818 builder.data("CHILDTAIL") 3819 root = builder.end("root") 3820 3821 self.assertEqual("root", root.tag) 3822 self.assertEqual("ROOTTEXT", root.text) 3823 self.assertEqual("CHILDTEXT", root[0].text) 3824 self.assertEqual("CHILDTAIL", root[0].tail)

3825

3826 - def test_treebuilder_target(self):

3827 parser = self.XMLParser(target=self.etree.TreeBuilder()) 3828 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3829 root = parser.close() 3830 3831 self.assertEqual("root", root.tag) 3832 self.assertEqual("ROOTTEXT", root.text) 3833 self.assertEqual("CHILDTEXT", root[0].text) 3834 self.assertEqual("CHILDTAIL", root[0].tail)

3835 3836 # helper methods 3837

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

3839 """Write out element for comparison. 3840 """ 3841 data = self.etree.tostring(element, encoding=encoding) 3842 return canonicalize(data)

3843

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

3845 """Write out element for comparison, using real file. 3846 """ 3847 ElementTree = self.etree.ElementTree 3848 handle, filename = tempfile.mkstemp() 3849 try: 3850 f = open(filename, 'wb') 3851 tree = ElementTree(element=element) 3852 tree.write(f, encoding=encoding) 3853 f.close() 3854 f = open(filename, 'rb') 3855 data = f.read() 3856 f.close() 3857 finally: 3858 os.close(handle) 3859 os.remove(filename) 3860 return canonicalize(data)

3861

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

3863 """Writes element out and checks whether it is expected. 3864 3865 Does this two ways; once using BytesIO, once using a real file. 3866 """ 3867 if isinstance(expected, unicode): 3868 expected = expected.encode(encoding) 3869 self.assertEqual(expected, self._writeElement(element, encoding)) 3870 self.assertEqual(expected, self._writeElementFile(element, encoding))

3871

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

3873 "Checks if the result XML byte string specifies the encoding." 3874 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 3875 if isinstance(result, str): 3876 has_encoding = re.compile(enc_re).match 3877 else: 3878 has_encoding = re.compile(_bytes(enc_re)).match 3879 self.assertTrue(has_encoding(result)) 3880 result_encoding = has_encoding(result).group(1) 3881 self.assertEqual(result_encoding.upper(), encoding.upper())

3882

3883 - def _rootstring(self, tree):

3884 return self.etree.tostring(tree.getroot()).replace( 3885 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))

3886

3887 - def _check_element_tree(self, tree):

3888 self._check_element(tree.getroot())

3889

3890 - def _check_element(self, element):

3891 self.assertTrue(hasattr(element, 'tag')) 3892 self.assertTrue(hasattr(element, 'attrib')) 3893 self.assertTrue(hasattr(element, 'text')) 3894 self.assertTrue(hasattr(element, 'tail')) 3895 self._check_string(element.tag) 3896 self._check_mapping(element.attrib) 3897 if element.text != None: 3898 self._check_string(element.text) 3899 if element.tail != None: 3900 self._check_string(element.tail)

3901

3902 - def _check_string(self, string):

3903 len(string) 3904 for char in string: 3905 self.assertEqual(1, len(char)) 3906 new_string = string + "" 3907 new_string = string + " " 3908 string[:0]

3909

3910 - def _check_mapping(self, mapping):

3911 len(mapping) 3912 keys = mapping.keys() 3913 values = mapping.values() 3914 items = mapping.items() 3915 for key in keys: 3916 item = mapping[key] 3917 mapping["key"] = "value" 3918 self.assertEqual("value", mapping["key"])

3919

3920 3921 -class _XMLPullParserTest(unittest.TestCase):

3922 etree = None 3923

3924 - def _feed(self, parser, data, chunk_size=None):

3925 if chunk_size is None: 3926 parser.feed(data) 3927 else: 3928 for i in range(0, len(data), chunk_size): 3929 parser.feed(data[i:i+chunk_size])

3930

3931 - def _close_and_return_root(self, parser):

3932 if 'ElementTree' in self.etree.__name__: 3933 # ElementTree's API is a bit unwieldy in Py3.4 3934 root = parser._close_and_return_root() 3935 else: 3936 root = parser.close() 3937 return root

3938

3939 - def assert_event_tags(self, parser, expected):

3940 events = parser.read_events() 3941 self.assertEqual([(action, elem.tag) for action, elem in events], 3942 expected)

3943

3944 - def test_simple_xml(self):

3945 for chunk_size in (None, 1, 5): 3946 #with self.subTest(chunk_size=chunk_size): 3947 parser = self.etree.XMLPullParser() 3948 self.assert_event_tags(parser, []) 3949 self._feed(parser, "\n", chunk_size) 3950 self.assert_event_tags(parser, []) 3951 self._feed(parser, 3952 "<root>\n <element key='value'>text</element", 3953 chunk_size) 3954 self.assert_event_tags(parser, []) 3955 self._feed(parser, ">\n", chunk_size) 3956 self.assert_event_tags(parser, [('end', 'element')]) 3957 self._feed(parser, "<element>text</element>tail\n", chunk_size) 3958 self._feed(parser, "<empty-element/>\n", chunk_size) 3959 self.assert_event_tags(parser, [ 3960 ('end', 'element'), 3961 ('end', 'empty-element'), 3962 ]) 3963 self._feed(parser, "</root>\n", chunk_size) 3964 self.assert_event_tags(parser, [('end', 'root')]) 3965 root = self._close_and_return_root(parser) 3966 self.assertEqual(root.tag, 'root')

3967

3968 - def test_feed_while_iterating(self):

3969 parser = self.etree.XMLPullParser() 3970 it = parser.read_events() 3971 self._feed(parser, "<root>\n <element key='value'>text</element>\n") 3972 action, elem = next(it) 3973 self.assertEqual((action, elem.tag), ('end', 'element')) 3974 self._feed(parser, "</root>\n") 3975 action, elem = next(it) 3976 self.assertEqual((action, elem.tag), ('end', 'root')) 3977 try: 3978 next(it) 3979 except StopIteration: 3980 self.assertTrue(True) 3981 else: 3982 self.assertTrue(False)

3983

3984 - def test_simple_xml_with_ns(self):

3985 parser = self.etree.XMLPullParser() 3986 self.assert_event_tags(parser, []) 3987 self._feed(parser, "\n") 3988 self.assert_event_tags(parser, []) 3989 self._feed(parser, "<root xmlns='namespace'>\n") 3990 self.assert_event_tags(parser, []) 3991 self._feed(parser, "<element key='value'>text</element") 3992 self.assert_event_tags(parser, []) 3993 self._feed(parser, ">\n") 3994 self.assert_event_tags(parser, [('end', '{namespace}element')]) 3995 self._feed(parser, "<element>text</element>tail\n") 3996 self._feed(parser, "<empty-element/>\n") 3997 self.assert_event_tags(parser, [ 3998 ('end', '{namespace}element'), 3999 ('end', '{namespace}empty-element'), 4000 ]) 4001 self._feed(parser, "</root>\n") 4002 self.assert_event_tags(parser, [('end', '{namespace}root')]) 4003 root = self._close_and_return_root(parser) 4004 self.assertEqual(root.tag, '{namespace}root')

4005

4006 - def test_ns_events(self):

4007 parser = self.etree.XMLPullParser(events=('start-ns', 'end-ns')) 4008 self._feed(parser, "\n") 4009 self._feed(parser, "<root xmlns='namespace'>\n") 4010 self.assertEqual( 4011 list(parser.read_events()), 4012 [('start-ns', ('', 'namespace'))]) 4013 self._feed(parser, "<element key='value'>text</element") 4014 self._feed(parser, ">\n") 4015 self._feed(parser, "<element>text</element>tail\n") 4016 self._feed(parser, "<empty-element/>\n") 4017 self._feed(parser, "</root>\n") 4018 self.assertEqual(list(parser.read_events()), [('end-ns', None)]) 4019 parser.close()

4020

4021 - def test_events(self):

4022 parser = self.etree.XMLPullParser(events=()) 4023 self._feed(parser, "<root/>\n") 4024 self.assert_event_tags(parser, []) 4025 4026 parser = self.etree.XMLPullParser(events=('start', 'end')) 4027 self._feed(parser, "\n") 4028 self.assert_event_tags(parser, []) 4029 self._feed(parser, "<root>\n") 4030 self.assert_event_tags(parser, [('start', 'root')]) 4031 self._feed(parser, "<element key='value'>text</element") 4032 self.assert_event_tags(parser, [('start', 'element')]) 4033 self._feed(parser, ">\n") 4034 self.assert_event_tags(parser, [('end', 'element')]) 4035 self._feed(parser, 4036 "<element xmlns='foo'>text<empty-element/></element>tail\n") 4037 self.assert_event_tags(parser, [ 4038 ('start', '{foo}element'), 4039 ('start', '{foo}empty-element'), 4040 ('end', '{foo}empty-element'), 4041 ('end', '{foo}element'), 4042 ]) 4043 self._feed(parser, "</root>") 4044 root = self._close_and_return_root(parser) 4045 self.assert_event_tags(parser, [('end', 'root')]) 4046 self.assertEqual(root.tag, 'root') 4047 4048 parser = self.etree.XMLPullParser(events=('start',)) 4049 self._feed(parser, "\n") 4050 self.assert_event_tags(parser, []) 4051 self._feed(parser, "<root>\n") 4052 self.assert_event_tags(parser, [('start', 'root')]) 4053 self._feed(parser, "<element key='value'>text</element") 4054 self.assert_event_tags(parser, [('start', 'element')]) 4055 self._feed(parser, ">\n") 4056 self.assert_event_tags(parser, []) 4057 self._feed(parser, 4058 "<element xmlns='foo'>text<empty-element/></element>tail\n") 4059 self.assert_event_tags(parser, [ 4060 ('start', '{foo}element'), 4061 ('start', '{foo}empty-element'), 4062 ]) 4063 self._feed(parser, "</root>") 4064 root = self._close_and_return_root(parser) 4065 self.assertEqual(root.tag, 'root')

4066

4067 - def test_events_sequence(self):

4068 # Test that events can be some sequence that's not just a tuple or list 4069 eventset = set(['end', 'start']) 4070 parser = self.etree.XMLPullParser(events=eventset) 4071 self._feed(parser, "<foo>bar</foo>") 4072 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 4073 4074 class DummyIter: 4075 def __init__(self): 4076 self.events = iter(['start', 'end', 'start-ns'])

4077 def __iter__(self): 4078 return self

4079 def __next__(self): 4080 return next(self.events) 4081 next = __next__ 4082 4083 parser = self.etree.XMLPullParser(events=DummyIter()) 4084 self._feed(parser, "<foo>bar</foo>") 4085 self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 4086

4087 - def test_unknown_event(self):

4088 try: 4089 self.etree.XMLPullParser(events=('start', 'end', 'bogus')) 4090 except ValueError: 4091 self.assertTrue(True) 4092 else: 4093 self.assertTrue(False)

4094 4095 4096 if etree:

4097 - class ETreeTestCase(_ETreeTestCaseBase):

4098 etree = etree

4099

4100 - class ETreePullTestCase(_XMLPullParserTest):

4101 etree = etree

4102 4103 4104 if ElementTree:

4105 - class ElementTreeTestCase(_ETreeTestCaseBase):

4106 etree = ElementTree 4107 4108 @classmethod

4109 - def setUpClass(cls):

4110 import warnings 4111 # ElementTree warns about getiterator() in recent Pythons 4112 warnings.filterwarnings( 4113 'ignore', 4114 'This method will be removed.*\.iter\(\).*instead', 4115 PendingDeprecationWarning)

4116 4117 filter_by_version( 4118 ElementTreeTestCase, 4119 ElementTreeTestCase.required_versions_ET, ET_VERSION) 4120 4121 if hasattr(ElementTree, 'XMLPullParser'):

4122 - class ElementTreePullTestCase(_XMLPullParserTest):

4123 etree = ElementTree

4124 else: 4125 ElementTreePullTestCase = None 4126 4127 4128 if cElementTree:

4129 - class CElementTreeTestCase(_ETreeTestCaseBase):

4130 etree = cElementTree

4131 4132 filter_by_version( 4133 CElementTreeTestCase, 4134 CElementTreeTestCase.required_versions_cET, CET_VERSION)

4135 4136 4137 -def test_suite():

4138 suite = unittest.TestSuite() 4139 if etree: 4140 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 4141 suite.addTests([unittest.makeSuite(ETreePullTestCase)]) 4142 if ElementTree: 4143 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 4144 if ElementTreePullTestCase: 4145 suite.addTests([unittest.makeSuite(ElementTreePullTestCase)]) 4146 if cElementTree: 4147 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 4148 return suite

4149 4150 if __name__ == '__main__': 4151 print('to test use test.py %s' % __file__) 4152