lxml.tests.test_elementtree

Source Code for Module lxml.tests.test_elementtree

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

36 - def reversed(seq):

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

39

40 -class ETreeTestCaseBase(HelperTestCase):

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

45 - def test_element(self):

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

51

52 - def test_simple(self):

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

64 65 # test weird dictionary interaction leading to segfault previously

66 - def test_weird_dict_interaction(self):

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

75

76 - def test_subelement(self):

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

88

89 - def test_element_contains(self):

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

106

107 - def test_element_indexing_with_text(self):

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

116

117 - def test_element_indexing_with_text2(self):

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

127

128 - def test_element_indexing_only_text(self):

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

135

136 - def test_element_indexing_negative(self):

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

151

152 - def test_elementtree(self):

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

161

162 - def test_text(self):

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

169

170 - def test_text_empty(self):

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

177

178 - def test_text_other(self):

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

186

187 - def test_text_escape_in(self):

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

194

195 - def test_text_escape_out(self):

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

202

203 - def test_text_escape_tostring(self):

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

211

212 - def test_text_str_subclass(self):

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

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

222

223 - def test_tail(self):

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

234

235 - def test_tail_str_subclass(self):

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

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

247 - def _test_del_tail(self):

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

273

274 - def test_ElementTree(self):

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

283

284 - def test_attributes(self):

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

293

294 - def test_attributes2(self):

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

304

305 - def test_attributes3(self):

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

315

316 - def test_attrib_clear(self):

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

325

326 - def test_attrib_set_clear(self):

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

336

337 - def test_attrib_ns_clear(self):

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

354

355 - def test_attrib_pop(self):

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

368

369 - def test_attrib_pop_unknown(self):

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

375

376 - def test_attrib_pop_default(self):

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

379

380 - def test_attrib_pop_empty_default(self):

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

383

384 - def test_attrib_pop_invalid_args(self):

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

387

388 - def test_attribute_update_dict(self):

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

405

406 - def test_attribute_update_sequence(self):

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

423

424 - def test_attribute_update_iter(self):

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

441

442 - def test_attribute_keys(self):

443 XML = self.etree.XML 444 445 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 446 keys = list(root.attrib.keys()) 447 keys.sort() 448 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

449

450 - def test_attribute_keys2(self):

451 XML = self.etree.XML 452 453 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 454 keys = list(root.keys()) 455 keys.sort() 456 self.assertEquals(['alpha', 'beta', 'gamma'], keys)

457

458 - def test_attribute_items2(self):

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

467

468 - def test_attribute_keys_ns(self):

469 XML = self.etree.XML 470 471 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 472 keys = list(root.keys()) 473 keys.sort() 474 self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'], 475 keys)

476

477 - def test_attribute_values(self):

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

484

485 - def test_attribute_values_ns(self):

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

493

494 - def test_attribute_items(self):

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

506

507 - def test_attribute_items_ns(self):

508 XML = self.etree.XML 509 510 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 511 items = list(root.attrib.items()) 512 items.sort() 513 self.assertEquals( 514 [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 515 items)

516

517 - def test_attribute_str(self):

518 XML = self.etree.XML 519 520 expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 521 alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 522 523 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 524 try: 525 self.assertEquals(expected, str(root.attrib)) 526 except AssertionError: 527 self.assertEquals(alternative, str(root.attrib))

528

529 - def test_attribute_contains(self):

530 XML = self.etree.XML 531 532 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 533 self.assertEquals( 534 True, 'bar' in root.attrib) 535 self.assertEquals( 536 False, 'baz' in root.attrib) 537 self.assertEquals( 538 False, 'hah' in root.attrib) 539 self.assertEquals( 540 True, 541 '{http://ns.codespeak.net/test}baz' in root.attrib)

542

543 - def test_attribute_set(self):

544 Element = self.etree.Element 545 546 root = Element("root") 547 root.set("attr", "TEST") 548 self.assertEquals("TEST", root.get("attr"))

549

550 - def test_attribute_iterator(self):

551 XML = self.etree.XML 552 553 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 554 result = [] 555 for key in root.attrib: 556 result.append(key) 557 result.sort() 558 self.assertEquals(['alpha', 'beta', 'gamma'], result)

559

560 - def test_attribute_manipulation(self):

561 Element = self.etree.Element 562 563 a = Element('a') 564 a.attrib['foo'] = 'Foo' 565 a.attrib['bar'] = 'Bar' 566 self.assertEquals('Foo', a.attrib['foo']) 567 del a.attrib['foo'] 568 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

569

570 - def test_del_attribute_ns(self):

571 Element = self.etree.Element 572 573 a = Element('a') 574 a.attrib['{http://a/}foo'] = 'Foo' 575 a.attrib['{http://a/}bar'] = 'Bar' 576 self.assertEquals(None, a.get('foo')) 577 self.assertEquals('Foo', a.get('{http://a/}foo')) 578 self.assertEquals('Foo', a.attrib['{http://a/}foo']) 579 580 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 581 self.assertEquals('Foo', a.attrib['{http://a/}foo']) 582 583 del a.attrib['{http://a/}foo'] 584 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

585

586 - def test_del_attribute_ns_parsed(self):

587 XML = self.etree.XML 588 589 a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 590 591 self.assertEquals('Foo', a.attrib['foo']) 592 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 593 594 del a.attrib['foo'] 595 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 596 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 597 self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 598 599 del a.attrib['{http://a/}foo'] 600 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 601 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 602 603 a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 604 605 self.assertEquals('Foo', a.attrib['foo']) 606 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 607 608 del a.attrib['foo'] 609 self.assertEquals('FooNS', a.attrib['{http://a/}foo']) 610 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 611 612 del a.attrib['{http://a/}foo'] 613 self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 614 self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')

615

616 - def test_XML(self):

617 XML = self.etree.XML 618 619 root = XML(_bytes('<doc>This is a text.</doc>')) 620 self.assertEquals(0, len(root)) 621 self.assertEquals('This is a text.', root.text)

622

623 - def test_XMLID(self):

624 XMLID = self.etree.XMLID 625 XML = self.etree.XML 626 xml_text = _bytes(''' 627 <document> 628 <h1 id="chapter1">...</h1> 629 ... 630 Regular paragraph. 631 XML:ID paragraph. 632 ... 633 </document> 634 ''') 635 636 root, dic = XMLID(xml_text) 637 root2 = XML(xml_text) 638 self.assertEquals(self._writeElement(root), 639 self._writeElement(root2)) 640 expected = { 641 "chapter1" : root[0], 642 "note1" : root[1], 643 "warn1" : root[4] 644 } 645 self.assertEquals(dic, expected)

646

647 - def test_fromstring(self):

648 fromstring = self.etree.fromstring 649 650 root = fromstring('<doc>This is a text.</doc>') 651 self.assertEquals(0, len(root)) 652 self.assertEquals('This is a text.', root.text)

653 654 required_versions_ET['test_fromstringlist'] = (1,3)

655 - def test_fromstringlist(self):

656 fromstringlist = self.etree.fromstringlist 657 658 root = fromstringlist(["<do", "c>T", "hi", "s is", 659 " a text.<", "/doc", ">"]) 660 self.assertEquals(0, len(root)) 661 self.assertEquals('This is a text.', root.text)

662 663 required_versions_ET['test_fromstringlist_characters'] = (1,3)

664 - def test_fromstringlist_characters(self):

665 fromstringlist = self.etree.fromstringlist 666 667 root = fromstringlist(list('<doc>This is a text.</doc>')) 668 self.assertEquals(0, len(root)) 669 self.assertEquals('This is a text.', root.text)

670 671 required_versions_ET['test_fromstringlist_single'] = (1,3)

672 - def test_fromstringlist_single(self):

673 fromstringlist = self.etree.fromstringlist 674 675 root = fromstringlist(['<doc>This is a text.</doc>']) 676 self.assertEquals(0, len(root)) 677 self.assertEquals('This is a text.', root.text)

678

679 - def test_iselement(self):

680 iselement = self.etree.iselement 681 Element = self.etree.Element 682 ElementTree = self.etree.ElementTree 683 XML = self.etree.XML 684 Comment = self.etree.Comment 685 ProcessingInstruction = self.etree.ProcessingInstruction 686 687 el = Element('hoi') 688 self.assert_(iselement(el)) 689 690 el2 = XML(_bytes('<foo/>')) 691 self.assert_(iselement(el2)) 692 693 tree = ElementTree(element=Element('dag')) 694 self.assert_(not iselement(tree)) 695 self.assert_(iselement(tree.getroot())) 696 697 c = Comment('test') 698 self.assert_(iselement(c)) 699 700 p = ProcessingInstruction("test", "some text") 701 self.assert_(iselement(p))

702

703 - def test_iteration(self):

704 XML = self.etree.XML 705 706 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 707 result = [] 708 for el in root: 709 result.append(el.tag) 710 self.assertEquals(['one', 'two', 'three'], result)

711

712 - def test_iteration_empty(self):

713 XML = self.etree.XML 714 715 root = XML(_bytes('<doc></doc>')) 716 result = [] 717 for el in root: 718 result.append(el.tag) 719 self.assertEquals([], result)

720

721 - def test_iteration_text_only(self):

722 XML = self.etree.XML 723 724 root = XML(_bytes('<doc>Text</doc>')) 725 result = [] 726 for el in root: 727 result.append(el.tag) 728 self.assertEquals([], result)

729

730 - def test_iteration_crash(self):

731 # this would cause a crash in the past 732 fromstring = self.etree.fromstring 733 root = etree.fromstring('<html>x</html>') 734 for elem in root: 735 elem.tail = ''

736

737 - def test_iteration_reversed(self):

738 XML = self.etree.XML 739 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 740 result = [] 741 for el in reversed(root): 742 result.append(el.tag) 743 self.assertEquals(['three', 'two', 'one'], result)

744

745 - def test_iteration_subelement(self):

746 XML = self.etree.XML 747 748 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 749 result = [] 750 add = True 751 for el in root: 752 result.append(el.tag) 753 if add: 754 self.etree.SubElement(root, 'four') 755 add = False 756 self.assertEquals(['one', 'two', 'three', 'four'], result)

757

758 - def test_iteration_del_child(self):

759 XML = self.etree.XML 760 761 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 762 result = [] 763 for el in root: 764 result.append(el.tag) 765 del root[-1] 766 self.assertEquals(['one', 'two'], result)

767

768 - def test_iteration_double(self):

769 XML = self.etree.XML 770 771 root = XML(_bytes('<doc><one/><two/></doc>')) 772 result = [] 773 for el0 in root: 774 result.append(el0.tag) 775 for el1 in root: 776 result.append(el1.tag) 777 self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)

778 779 required_versions_ET['test_itertext'] = (1,3)

780 - def test_itertext(self):

781 # ET 1.3+ 782 XML = self.etree.XML 783 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 784 785 text = list(root.itertext()) 786 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 787 text)

788 789 required_versions_ET['test_itertext_child'] = (1,3)

790 - def test_itertext_child(self):

791 # ET 1.3+ 792 XML = self.etree.XML 793 root = XML(_bytes("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>")) 794 795 text = list(root[2].itertext()) 796 self.assertEquals(["CTEXT"], 797 text)

798

799 - def test_findall(self):

800 XML = self.etree.XML 801 root = XML(_bytes('<a><c/><c></c></a>')) 802 self.assertEquals(len(list(root.findall("c"))), 1) 803 self.assertEquals(len(list(root.findall(".//c"))), 2) 804 self.assertEquals(len(list(root.findall(".//b"))), 3) 805 self.assertEquals(len(list(root.findall(".//b"))[0]), 1) 806 self.assertEquals(len(list(root.findall(".//b"))[1]), 0) 807 self.assertEquals(len(list(root.findall(".//b"))[2]), 0)

808

809 - def test_findall_ns(self):

810 XML = self.etree.XML 811 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 812 self.assertEquals(len(list(root.findall(".//{X}b"))), 2) 813 self.assertEquals(len(list(root.findall(".//b"))), 3) 814 self.assertEquals(len(list(root.findall("b"))), 2)

815

816 - def test_element_with_attributes_keywords(self):

817 Element = self.etree.Element 818 819 el = Element('tag', foo='Foo', bar='Bar') 820 self.assertEquals('Foo', el.attrib['foo']) 821 self.assertEquals('Bar', el.attrib['bar'])

822

823 - def test_element_with_attributes(self):

824 Element = self.etree.Element 825 826 el = Element('tag', {'foo':'Foo', 'bar':'Bar'}) 827 self.assertEquals('Foo', el.attrib['foo']) 828 self.assertEquals('Bar', el.attrib['bar'])

829

830 - def test_element_with_attributes_ns(self):

831 Element = self.etree.Element 832 833 el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 834 self.assertEquals('Foo', el.attrib['{ns1}foo']) 835 self.assertEquals('Bar', el.attrib['{ns2}bar'])

836

837 - def test_subelement_with_attributes(self):

838 Element = self.etree.Element 839 SubElement = self.etree.SubElement 840 841 el = Element('tag') 842 SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 843 self.assertEquals("Baz", el[0].attrib['baz']) 844 self.assertEquals('Foo', el[0].attrib['foo'])

845

846 - def test_subelement_with_attributes_ns(self):

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

854

855 - def test_write(self):

856 ElementTree = self.etree.ElementTree 857 XML = self.etree.XML 858 859 for i in range(10): 860 f = BytesIO() 861 root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 862 tree = ElementTree(element=root) 863 tree.write(f) 864 data = f.getvalue() 865 self.assertEquals( 866 _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 867 canonicalize(data))

868 869 required_versions_ET['test_write_method_html'] = (1,3)

870 - def test_write_method_html(self):

871 ElementTree = self.etree.ElementTree 872 Element = self.etree.Element 873 SubElement = self.etree.SubElement 874 875 html = Element('html') 876 body = SubElement(html, 'body') 877 p = SubElement(body, 'p') 878 p.text = "html" 879 SubElement(p, 'br').tail = "test" 880 881 tree = ElementTree(element=html) 882 f = BytesIO() 883 tree.write(f, method="html") 884 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 885 886 self.assertEquals(_bytes('<html><body>html test</body></html>'), 887 data)

888 889 required_versions_ET['test_write_method_text'] = (1,3)

890 - def test_write_method_text(self):

891 ElementTree = self.etree.ElementTree 892 Element = self.etree.Element 893 SubElement = self.etree.SubElement 894 895 a = Element('a') 896 a.text = "A" 897 a.tail = "tail" 898 b = SubElement(a, 'b') 899 b.text = "B" 900 b.tail = "TAIL" 901 c = SubElement(a, 'c') 902 c.text = "C" 903 904 tree = ElementTree(element=a) 905 f = BytesIO() 906 tree.write(f, method="text") 907 data = f.getvalue() 908 909 self.assertEquals(_bytes('ABTAILCtail'), 910 data)

911

912 - def test_write_fail(self):

913 ElementTree = self.etree.ElementTree 914 XML = self.etree.XML 915 916 tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 917 self.assertRaises(IOError, tree.write, 918 "definitely////\\-\\nonexisting\\-\\////FILE")

919 920 # this could trigger a crash, apparently because the document 921 # reference was prematurely garbage collected

922 - def test_crash(self):

923 Element = self.etree.Element 924 925 element = Element('tag') 926 for i in range(10): 927 element.attrib['key'] = 'value' 928 value = element.attrib['key'] 929 self.assertEquals(value, 'value')

930 931 # from doctest; for some reason this caused crashes too

932 - def test_write_ElementTreeDoctest(self):

933 Element = self.etree.Element 934 ElementTree = self.etree.ElementTree 935 936 f = BytesIO() 937 for i in range(10): 938 element = Element('tag%s' % i) 939 self._check_element(element) 940 tree = ElementTree(element) 941 tree.write(f) 942 self._check_element_tree(tree)

943

944 - def test_subelement_reference(self):

945 Element = self.etree.Element 946 SubElement = self.etree.SubElement 947 948 el = Element('foo') 949 el2 = SubElement(el, 'bar') 950 el3 = SubElement(el2, 'baz') 951 952 al = Element('foo2') 953 al2 = SubElement(al, 'bar2') 954 al3 = SubElement(al2, 'baz2') 955 956 # now move al2 into el 957 el.append(al2) 958 959 # now change al3 directly 960 al3.text = 'baz2-modified' 961 962 # it should have changed through this route too 963 self.assertEquals( 964 'baz2-modified', 965 el[1][0].text)

966

967 - def test_set_text(self):

968 Element = self.etree.Element 969 SubElement = self.etree.SubElement 970 971 a = Element('a') 972 b = SubElement(a, 'b') 973 a.text = 'hoi' 974 self.assertEquals( 975 'hoi', 976 a.text) 977 self.assertEquals( 978 'b', 979 a[0].tag)

980

981 - def test_set_text2(self):

982 Element = self.etree.Element 983 SubElement = self.etree.SubElement 984 985 a = Element('a') 986 a.text = 'hoi' 987 b = SubElement(a ,'b') 988 self.assertEquals( 989 'hoi', 990 a.text) 991 self.assertEquals( 992 'b', 993 a[0].tag)

994

995 - def test_set_text_none(self):

996 Element = self.etree.Element 997 998 a = Element('a') 999 1000 a.text = 'foo' 1001 a.text = None 1002 1003 self.assertEquals( 1004 None, 1005 a.text) 1006 self.assertXML(_bytes('<a></a>'), a)

1007

1008 - def test_set_text_empty(self):

1009 Element = self.etree.Element 1010 1011 a = Element('a') 1012 self.assertEquals(None, a.text) 1013 1014 a.text = '' 1015 self.assertEquals('', a.text) 1016 self.assertXML(_bytes('<a></a>'), a)

1017

1018 - def test_tail1(self):

1019 Element = self.etree.Element 1020 SubElement = self.etree.SubElement 1021 1022 a = Element('a') 1023 a.tail = 'dag' 1024 self.assertEquals('dag', 1025 a.tail) 1026 b = SubElement(a, 'b') 1027 b.tail = 'hoi' 1028 self.assertEquals('hoi', 1029 b.tail) 1030 self.assertEquals('dag', 1031 a.tail)

1032

1033 - def test_tail_append(self):

1034 Element = self.etree.Element 1035 1036 a = Element('a') 1037 b = Element('b') 1038 b.tail = 'b_tail' 1039 a.append(b) 1040 self.assertEquals('b_tail', 1041 b.tail)

1042

1043 - def test_tail_set_twice(self):

1044 Element = self.etree.Element 1045 SubElement = self.etree.SubElement 1046 1047 a = Element('a') 1048 b = SubElement(a, 'b') 1049 b.tail = 'foo' 1050 b.tail = 'bar' 1051 self.assertEquals('bar', 1052 b.tail) 1053 self.assertXML(_bytes('<a>bar</a>'), a)

1054

1055 - def test_tail_set_none(self):

1056 Element = self.etree.Element 1057 a = Element('a') 1058 a.tail = 'foo' 1059 a.tail = None 1060 self.assertEquals( 1061 None, 1062 a.tail) 1063 self.assertXML(_bytes('<a></a>'), a)

1064 1065 required_versions_ET['test_extend'] = (1,3)

1066 - def test_extend(self):

1067 root = self.etree.Element('foo') 1068 for i in range(3): 1069 element = self.etree.SubElement(root, 'a%s' % i) 1070 element.text = "text%d" % i 1071 element.tail = "tail%d" % i 1072 1073 elements = [] 1074 for i in range(3): 1075 new_element = self.etree.Element("test%s" % i) 1076 new_element.text = "TEXT%s" % i 1077 new_element.tail = "TAIL%s" % i 1078 elements.append(new_element) 1079 1080 root.extend(elements) 1081 1082 self.assertEquals( 1083 ["a0", "a1", "a2", "test0", "test1", "test2"], 1084 [ el.tag for el in root ]) 1085 self.assertEquals( 1086 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1087 [ el.text for el in root ]) 1088 self.assertEquals( 1089 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1090 [ el.tail for el in root ])

1091

1092 - def test_comment(self):

1093 Element = self.etree.Element 1094 SubElement = self.etree.SubElement 1095 Comment = self.etree.Comment 1096 1097 a = Element('a') 1098 a.append(Comment('foo')) 1099 self.assertEquals(a[0].tag, Comment) 1100 self.assertEquals(a[0].text, 'foo')

1101 1102 # ElementTree < 1.3 adds whitespace around comments 1103 required_versions_ET['test_comment_text'] = (1,3)

1104 - def test_comment_text(self):

1105 Element = self.etree.Element 1106 SubElement = self.etree.SubElement 1107 Comment = self.etree.Comment 1108 tostring = self.etree.tostring 1109 1110 a = Element('a') 1111 a.append(Comment('foo')) 1112 self.assertEquals(a[0].text, 'foo') 1113 1114 self.assertEquals( 1115 _bytes('<a></a>'), 1116 tostring(a)) 1117 1118 a[0].text = "TEST" 1119 self.assertEquals(a[0].text, 'TEST') 1120 1121 self.assertEquals( 1122 _bytes('<a></a>'), 1123 tostring(a))

1124 1125 # ElementTree < 1.3 adds whitespace around comments 1126 required_versions_ET['test_comment_whitespace'] = (1,3)

1127 - def test_comment_whitespace(self):

1128 Element = self.etree.Element 1129 SubElement = self.etree.SubElement 1130 Comment = self.etree.Comment 1131 tostring = self.etree.tostring 1132 1133 a = Element('a') 1134 a.append(Comment(' foo ')) 1135 self.assertEquals(a[0].text, ' foo ') 1136 self.assertEquals( 1137 _bytes('<a></a>'), 1138 tostring(a))

1139

1140 - def test_comment_nonsense(self):

1141 Comment = self.etree.Comment 1142 c = Comment('foo') 1143 self.assertEquals({}, c.attrib) 1144 self.assertEquals([], list(c.keys())) 1145 self.assertEquals([], list(c.items())) 1146 self.assertEquals(None, c.get('hoi')) 1147 self.assertEquals(0, len(c)) 1148 # should not iterate 1149 for i in c: 1150 pass

1151

1152 - def test_pi(self):

1153 # lxml.etree separates target and text 1154 Element = self.etree.Element 1155 SubElement = self.etree.SubElement 1156 ProcessingInstruction = self.etree.ProcessingInstruction 1157 1158 a = Element('a') 1159 a.append(ProcessingInstruction('foo', 'some more text')) 1160 self.assertEquals(a[0].tag, ProcessingInstruction) 1161 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1162 a)

1163

1164 - def test_processinginstruction(self):

1165 # lxml.etree separates target and text 1166 Element = self.etree.Element 1167 SubElement = self.etree.SubElement 1168 ProcessingInstruction = self.etree.PI 1169 1170 a = Element('a') 1171 a.append(ProcessingInstruction('foo', 'some more text')) 1172 self.assertEquals(a[0].tag, ProcessingInstruction) 1173 self.assertXML(_bytes("<a><?foo some more text?></a>"), 1174 a)

1175

1176 - def test_pi_nonsense(self):

1177 ProcessingInstruction = self.etree.ProcessingInstruction 1178 pi = ProcessingInstruction('foo') 1179 self.assertEquals({}, pi.attrib) 1180 self.assertEquals([], list(pi.keys())) 1181 self.assertEquals([], list(pi.items())) 1182 self.assertEquals(None, pi.get('hoi')) 1183 self.assertEquals(0, len(pi)) 1184 # should not iterate 1185 for i in pi: 1186 pass

1187

1188 - def test_setitem(self):

1189 Element = self.etree.Element 1190 SubElement = self.etree.SubElement 1191 1192 a = Element('a') 1193 b = SubElement(a, 'b') 1194 c = Element('c') 1195 a[0] = c 1196 self.assertEquals( 1197 c, 1198 a[0]) 1199 self.assertXML(_bytes('<a><c></c></a>'), 1200 a) 1201 self.assertXML(_bytes(''), 1202 b)

1203

1204 - def test_setitem2(self):

1205 Element = self.etree.Element 1206 SubElement = self.etree.SubElement 1207 1208 a = Element('a') 1209 for i in range(5): 1210 b = SubElement(a, 'b%s' % i) 1211 c = SubElement(b, 'c') 1212 for i in range(5): 1213 d = Element('d') 1214 e = SubElement(d, 'e') 1215 a[i] = d 1216 self.assertXML( 1217 _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 1218 a) 1219 self.assertXML(_bytes('<c></c>'), 1220 c)

1221

1222 - def test_setitem_replace(self):

1223 Element = self.etree.Element 1224 SubElement = self.etree.SubElement 1225 1226 a = Element('a') 1227 SubElement(a, 'b') 1228 d = Element('d') 1229 a[0] = d 1230 self.assertXML(_bytes('<a><d></d></a>'), a)

1231

1232 - def test_setitem_indexerror(self):

1233 Element = self.etree.Element 1234 SubElement = self.etree.SubElement 1235 1236 a = Element('a') 1237 b = SubElement(a, 'b') 1238 1239 self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))

1240

1241 - def test_setitem_tail(self):

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

1255

1256 - def test_tag_write(self):

1257 Element = self.etree.Element 1258 SubElement = self.etree.SubElement 1259 1260 a = Element('a') 1261 b = SubElement(a, 'b') 1262 1263 a.tag = 'c' 1264 1265 self.assertEquals( 1266 'c', 1267 a.tag) 1268 1269 self.assertXML( 1270 _bytes('<c></c>'), 1271 a)

1272

1273 - def test_tag_reset_ns(self):

1274 Element = self.etree.Element 1275 SubElement = self.etree.SubElement 1276 tostring = self.etree.tostring 1277 1278 a = Element('{a}a') 1279 b1 = SubElement(a, '{a}b') 1280 b2 = SubElement(a, '{b}b') 1281 1282 self.assertEquals('{a}b', b1.tag) 1283 1284 b1.tag = 'c' 1285 1286 # can't use C14N here! 1287 self.assertEquals('c', b1.tag) 1288 self.assertEquals(_bytes('<c'), tostring(b1)[:2]) 1289 self.assert_(_bytes('<c') in tostring(a))

1290

1291 - def test_tag_reset_root_ns(self):

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

1309

1310 - def test_tag_str_subclass(self):

1311 Element = self.etree.Element 1312 1313 class strTest(str): 1314 pass

1315 1316 a = Element("a") 1317 a.tag = strTest("TAG") 1318 self.assertXML(_bytes('<TAG></TAG>'), 1319 a) 1320

1321 - def test_delitem(self):

1322 Element = self.etree.Element 1323 SubElement = self.etree.SubElement 1324 1325 a = Element('a') 1326 b = SubElement(a, 'b') 1327 c = SubElement(a, 'c') 1328 d = SubElement(a, 'd') 1329 1330 del a[1] 1331 self.assertXML( 1332 _bytes('<a><d></d></a>'), 1333 a) 1334 1335 del a[0] 1336 self.assertXML( 1337 _bytes('<a><d></d></a>'), 1338 a) 1339 1340 del a[0] 1341 self.assertXML( 1342 _bytes('<a></a>'), 1343 a) 1344 # move deleted element into other tree afterwards 1345 other = Element('other') 1346 other.append(c) 1347 self.assertXML( 1348 _bytes('<other><c></c></other>'), 1349 other)

1350

1351 - def test_del_insert(self):

1352 Element = self.etree.Element 1353 SubElement = self.etree.SubElement 1354 1355 a = Element('a') 1356 b = SubElement(a, 'b') 1357 bs = SubElement(b, 'bs') 1358 c = SubElement(a, 'c') 1359 cs = SubElement(c, 'cs') 1360 1361 el = a[0] 1362 self.assertXML( 1363 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1364 a) 1365 self.assertXML(_bytes('<bs></bs>'), b) 1366 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1367 1368 del a[0] 1369 self.assertXML( 1370 _bytes('<a><c><cs></cs></c></a>'), 1371 a) 1372 self.assertXML(_bytes('<bs></bs>'), b) 1373 self.assertXML(_bytes('<c><cs></cs></c>'), c) 1374 1375 a.insert(0, el) 1376 self.assertXML( 1377 _bytes('<a><bs></bs><c><cs></cs></c></a>'), 1378 a) 1379 self.assertXML(_bytes('<bs></bs>'), b) 1380 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1381

1382 - def test_del_setitem(self):

1383 Element = self.etree.Element 1384 SubElement = self.etree.SubElement 1385 1386 a = Element('a') 1387 b = SubElement(a, 'b') 1388 bs = SubElement(b, 'bs') 1389 c = SubElement(a, 'c') 1390 cs = SubElement(c, 'cs') 1391 1392 el = a[0] 1393 del a[0] 1394 a[0] = el 1395 self.assertXML( 1396 _bytes('<a><bs></bs></a>'), 1397 a) 1398 self.assertXML(_bytes('<bs></bs>'), b) 1399 self.assertXML(_bytes('<c><cs></cs></c>'), c)

1400

1401 - def test_del_setslice(self):

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

1419

1420 - def test_replace_slice_tail(self):

1421 XML = self.etree.XML 1422 a = XML(_bytes('<a>B2<c></c>C2</a>')) 1423 b, c = a 1424 1425 a[:] = [] 1426 1427 self.assertEquals("B2", b.tail) 1428 self.assertEquals("C2", c.tail)

1429

1430 - def test_merge_namespaced_subtree_as_slice(self):

1431 XML = self.etree.XML 1432 root = XML(_bytes( 1433 '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 1434 root[:] = root.findall('.//puh') # delete bar from hierarchy 1435 1436 # previously, this lost a namespace declaration on bump2 1437 result = self.etree.tostring(root) 1438 foo = self.etree.fromstring(result) 1439 1440 self.assertEquals('puh', foo[0].tag) 1441 self.assertEquals('{http://huhu}bump1', foo[0][0].tag) 1442 self.assertEquals('{http://huhu}bump2', foo[0][1].tag)

1443

1444 - def test_delitem_tail(self):

1445 ElementTree = self.etree.ElementTree 1446 f = BytesIO('<a>B2<c></c>C2</a>') 1447 doc = ElementTree(file=f) 1448 a = doc.getroot() 1449 del a[0] 1450 self.assertXML( 1451 _bytes('<a><c></c>C2</a>'), 1452 a)

1453

1454 - def test_clear(self):

1455 Element = self.etree.Element 1456 1457 a = Element('a') 1458 a.text = 'foo' 1459 a.tail = 'bar' 1460 a.set('hoi', 'dag') 1461 a.clear() 1462 self.assertEquals(None, a.text) 1463 self.assertEquals(None, a.tail) 1464 self.assertEquals(None, a.get('hoi')) 1465 self.assertEquals('a', a.tag)

1466

1467 - def test_clear_sub(self):

1468 Element = self.etree.Element 1469 SubElement = self.etree.SubElement 1470 1471 a = Element('a') 1472 a.text = 'foo' 1473 a.tail = 'bar' 1474 a.set('hoi', 'dag') 1475 b = SubElement(a, 'b') 1476 c = SubElement(b, 'c') 1477 a.clear() 1478 self.assertEquals(None, a.text) 1479 self.assertEquals(None, a.tail) 1480 self.assertEquals(None, a.get('hoi')) 1481 self.assertEquals('a', a.tag) 1482 self.assertEquals(0, len(a)) 1483 self.assertXML(_bytes('<a></a>'), 1484 a) 1485 self.assertXML(_bytes('<c></c>'), 1486 b)

1487

1488 - def test_clear_tail(self):

1489 ElementTree = self.etree.ElementTree 1490 f = BytesIO('<a>B2<c></c>C2</a>') 1491 doc = ElementTree(file=f) 1492 a = doc.getroot() 1493 a.clear() 1494 self.assertXML( 1495 _bytes('<a></a>'), 1496 a)

1497

1498 - def test_insert(self):

1499 Element = self.etree.Element 1500 SubElement = self.etree.SubElement 1501 1502 a = Element('a') 1503 b = SubElement(a, 'b') 1504 c = SubElement(a, 'c') 1505 d = Element('d') 1506 a.insert(0, d) 1507 1508 self.assertEquals( 1509 d, 1510 a[0]) 1511 1512 self.assertXML( 1513 _bytes('<a><d></d><c></c></a>'), 1514 a) 1515 1516 e = Element('e') 1517 a.insert(2, e) 1518 self.assertEquals( 1519 e, 1520 a[2]) 1521 self.assertXML( 1522 _bytes('<a><d></d><e></e><c></c></a>'), 1523 a)

1524

1525 - def test_insert_beyond_index(self):

1526 Element = self.etree.Element 1527 SubElement = self.etree.SubElement 1528 1529 a = Element('a') 1530 b = SubElement(a, 'b') 1531 c = Element('c') 1532 1533 a.insert(2, c) 1534 self.assertEquals( 1535 c, 1536 a[1]) 1537 self.assertXML( 1538 _bytes('<a><c></c></a>'), 1539 a)

1540

1541 - def test_insert_negative(self):

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

1557

1558 - def test_insert_tail(self):

1559 Element = self.etree.Element 1560 SubElement = self.etree.SubElement 1561 1562 a = Element('a') 1563 b = SubElement(a, 'b') 1564 1565 c = Element('c') 1566 c.tail = 'C2' 1567 1568 a.insert(0, c) 1569 self.assertXML( 1570 _bytes('<a><c></c>C2</a>'), 1571 a)

1572

1573 - def test_remove(self):

1574 Element = self.etree.Element 1575 SubElement = self.etree.SubElement 1576 1577 a = Element('a') 1578 b = SubElement(a, 'b') 1579 c = SubElement(a, 'c') 1580 1581 a.remove(b) 1582 self.assertEquals( 1583 c, 1584 a[0]) 1585 self.assertXML( 1586 _bytes('<a><c></c></a>'), 1587 a)

1588

1589 - def test_remove_ns(self):

1590 Element = self.etree.Element 1591 SubElement = self.etree.SubElement 1592 1593 a = Element('{http://test}a') 1594 b = SubElement(a, '{http://test}b') 1595 c = SubElement(a, '{http://test}c') 1596 1597 a.remove(b) 1598 self.assertXML( 1599 _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 1600 a) 1601 self.assertXML( 1602 _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 1603 b)

1604

1605 - def test_remove_nonexisting(self):

1606 Element = self.etree.Element 1607 SubElement = self.etree.SubElement 1608 1609 a = Element('a') 1610 b = SubElement(a, 'b') 1611 c = SubElement(a, 'c') 1612 d = Element('d') 1613 self.assertRaises( 1614 ValueError, a.remove, d)

1615

1616 - def test_remove_tail(self):

1617 Element = self.etree.Element 1618 SubElement = self.etree.SubElement 1619 1620 a = Element('a') 1621 b = SubElement(a, 'b') 1622 b.tail = 'b2' 1623 a.remove(b) 1624 self.assertXML( 1625 _bytes('<a></a>'), 1626 a) 1627 self.assertEquals('b2', b.tail)

1628

1629 - def _test_getchildren(self):

1630 Element = self.etree.Element 1631 SubElement = self.etree.SubElement 1632 1633 a = Element('a') 1634 b = SubElement(a, 'b') 1635 c = SubElement(a, 'c') 1636 d = SubElement(b, 'd') 1637 e = SubElement(c, 'e') 1638 self.assertXML( 1639 _bytes('<a><d></d><c><e></e></c></a>'), 1640 a) 1641 self.assertEquals( 1642 [b, c], 1643 a.getchildren()) 1644 self.assertEquals( 1645 [d], 1646 b.getchildren()) 1647 self.assertEquals( 1648 [], 1649 d.getchildren())

1650

1651 - def test_makeelement(self):

1652 Element = self.etree.Element 1653 1654 a = Element('a') 1655 b = a.makeelement('c', {'hoi':'dag'}) 1656 self.assertXML( 1657 _bytes('<c hoi="dag"></c>'), 1658 b)

1659 1660 required_versions_ET['test_iter'] = (1,3)

1661 - def test_iter(self):

1662 Element = self.etree.Element 1663 SubElement = self.etree.SubElement 1664 1665 a = Element('a') 1666 b = SubElement(a, 'b') 1667 c = SubElement(a, 'c') 1668 d = SubElement(b, 'd') 1669 e = SubElement(c, 'e') 1670 1671 self.assertEquals( 1672 [a, b, d, c, e], 1673 list(a.iter())) 1674 self.assertEquals( 1675 [d], 1676 list(d.iter()))

1677

1678 - def test_getiterator(self):

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

1694

1695 - def test_getiterator_empty(self):

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

1714

1715 - def test_getiterator_filter(self):

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

1735

1736 - def test_getiterator_filter_all(self):

1737 Element = self.etree.Element 1738 SubElement = self.etree.SubElement 1739 1740 a = Element('a') 1741 b = SubElement(a, 'b') 1742 c = SubElement(a, 'c') 1743 d = SubElement(b, 'd') 1744 e = SubElement(c, 'e') 1745 1746 self.assertEquals( 1747 [a, b, d, c, e], 1748 list(a.getiterator('*')))

1749

1750 - def test_getiterator_filter_comment(self):

1751 Element = self.etree.Element 1752 Comment = self.etree.Comment 1753 SubElement = self.etree.SubElement 1754 1755 a = Element('a') 1756 b = SubElement(a, 'b') 1757 comment_b = Comment("TEST-b") 1758 b.append(comment_b) 1759 1760 self.assertEquals( 1761 [comment_b], 1762 list(a.getiterator(Comment))) 1763 1764 comment_a = Comment("TEST-a") 1765 a.append(comment_a) 1766 1767 self.assertEquals( 1768 [comment_b, comment_a], 1769 list(a.getiterator(Comment))) 1770 1771 self.assertEquals( 1772 [comment_b], 1773 list(b.getiterator(Comment)))

1774

1775 - def test_getiterator_filter_pi(self):

1776 Element = self.etree.Element 1777 PI = self.etree.ProcessingInstruction 1778 SubElement = self.etree.SubElement 1779 1780 a = Element('a') 1781 b = SubElement(a, 'b') 1782 pi_b = PI("TEST-b") 1783 b.append(pi_b) 1784 1785 self.assertEquals( 1786 [pi_b], 1787 list(a.getiterator(PI))) 1788 1789 pi_a = PI("TEST-a") 1790 a.append(pi_a) 1791 1792 self.assertEquals( 1793 [pi_b, pi_a], 1794 list(a.getiterator(PI))) 1795 1796 self.assertEquals( 1797 [pi_b], 1798 list(b.getiterator(PI)))

1799

1800 - def test_getiterator_with_text(self):

1801 Element = self.etree.Element 1802 SubElement = self.etree.SubElement 1803 1804 a = Element('a') 1805 a.text = 'a' 1806 b = SubElement(a, 'b') 1807 b.text = 'b' 1808 b.tail = 'b1' 1809 c = SubElement(a, 'c') 1810 c.text = 'c' 1811 c.tail = 'c1' 1812 d = SubElement(b, 'd') 1813 c.text = 'd' 1814 c.tail = 'd1' 1815 e = SubElement(c, 'e') 1816 e.text = 'e' 1817 e.tail = 'e1' 1818 1819 self.assertEquals( 1820 [a, b, d, c, e], 1821 list(a.getiterator()))

1822 #self.assertEquals( 1823 # [d], 1824 # list(d.getiterator())) 1825

1826 - def test_getiterator_filter_with_text(self):

1827 Element = self.etree.Element 1828 SubElement = self.etree.SubElement 1829 1830 a = Element('a') 1831 a.text = 'a' 1832 b = SubElement(a, 'b') 1833 b.text = 'b' 1834 b.tail = 'b1' 1835 c = SubElement(a, 'c') 1836 c.text = 'c' 1837 c.tail = 'c1' 1838 d = SubElement(b, 'd') 1839 c.text = 'd' 1840 c.tail = 'd1' 1841 e = SubElement(c, 'e') 1842 e.text = 'e' 1843 e.tail = 'e1' 1844 1845 self.assertEquals( 1846 [a], 1847 list(a.getiterator('a'))) 1848 a2 = SubElement(e, 'a') 1849 self.assertEquals( 1850 [a, a2], 1851 list(a.getiterator('a'))) 1852 self.assertEquals( 1853 [a2], 1854 list(e.getiterator('a')))

1855

1856 - def test_getslice(self):

1857 Element = self.etree.Element 1858 SubElement = self.etree.SubElement 1859 1860 a = Element('a') 1861 b = SubElement(a, 'b') 1862 c = SubElement(a, 'c') 1863 d = SubElement(a, 'd') 1864 1865 self.assertEquals( 1866 [b, c], 1867 a[0:2]) 1868 self.assertEquals( 1869 [b, c, d], 1870 a[:]) 1871 self.assertEquals( 1872 [b, c, d], 1873 a[:10]) 1874 self.assertEquals( 1875 [b], 1876 a[0:1]) 1877 self.assertEquals( 1878 [], 1879 a[10:12])

1880

1881 - def test_getslice_negative(self):

1882 Element = self.etree.Element 1883 SubElement = self.etree.SubElement 1884 1885 a = Element('a') 1886 b = SubElement(a, 'b') 1887 c = SubElement(a, 'c') 1888 d = SubElement(a, 'd') 1889 1890 self.assertEquals( 1891 [d], 1892 a[-1:]) 1893 self.assertEquals( 1894 [c, d], 1895 a[-2:]) 1896 self.assertEquals( 1897 [c], 1898 a[-2:-1]) 1899 self.assertEquals( 1900 [b, c], 1901 a[-3:-1]) 1902 self.assertEquals( 1903 [b, c], 1904 a[-3:2])

1905

1906 - def test_getslice_step(self):

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

1931

1932 - def test_getslice_text(self):

1933 ElementTree = self.etree.ElementTree 1934 1935 f = BytesIO('<a>BB1<c>C</c>C1</a>') 1936 doc = ElementTree(file=f) 1937 a = doc.getroot() 1938 b = a[0] 1939 c = a[1] 1940 self.assertEquals( 1941 [b, c], 1942 a[:]) 1943 self.assertEquals( 1944 [b], 1945 a[0:1]) 1946 self.assertEquals( 1947 [c], 1948 a[1:])

1949

1950 - def test_comment_getitem_getslice(self):

1951 Element = self.etree.Element 1952 Comment = self.etree.Comment 1953 SubElement = self.etree.SubElement 1954 1955 a = Element('a') 1956 b = SubElement(a, 'b') 1957 foo = Comment('foo') 1958 a.append(foo) 1959 c = SubElement(a, 'c') 1960 self.assertEquals( 1961 [b, foo, c], 1962 a[:]) 1963 self.assertEquals( 1964 foo, 1965 a[1]) 1966 a[1] = new = Element('new') 1967 self.assertEquals( 1968 new, 1969 a[1]) 1970 self.assertXML( 1971 _bytes('<a><new></new><c></c></a>'), 1972 a)

1973

1974 - def test_delslice(self):

1975 Element = self.etree.Element 1976 SubElement = self.etree.SubElement 1977 1978 a = Element('a') 1979 b = SubElement(a, 'b') 1980 c = SubElement(a, 'c') 1981 d = SubElement(a, 'd') 1982 e = SubElement(a, 'e') 1983 1984 del a[1:3] 1985 self.assertEquals( 1986 [b, e], 1987 list(a))

1988

1989 - def test_delslice_negative1(self):

1990 Element = self.etree.Element 1991 SubElement = self.etree.SubElement 1992 1993 a = Element('a') 1994 b = SubElement(a, 'b') 1995 c = SubElement(a, 'c') 1996 d = SubElement(a, 'd') 1997 e = SubElement(a, 'e') 1998 1999 del a[1:-1] 2000 self.assertEquals( 2001 [b, e], 2002 list(a))

2003

2004 - def test_delslice_negative2(self):

2005 Element = self.etree.Element 2006 SubElement = self.etree.SubElement 2007 2008 a = Element('a') 2009 b = SubElement(a, 'b') 2010 c = SubElement(a, 'c') 2011 d = SubElement(a, 'd') 2012 e = SubElement(a, 'e') 2013 2014 del a[-3:-1] 2015 self.assertEquals( 2016 [b, e], 2017 list(a))

2018

2019 - def test_delslice_step(self):

2020 Element = self.etree.Element 2021 SubElement = self.etree.SubElement 2022 2023 a = Element('a') 2024 b = SubElement(a, 'b') 2025 c = SubElement(a, 'c') 2026 d = SubElement(a, 'd') 2027 e = SubElement(a, 'e') 2028 2029 del a[1::2] 2030 self.assertEquals( 2031 [b, d], 2032 list(a))

2033

2034 - def test_delslice_step_negative(self):

2035 Element = self.etree.Element 2036 SubElement = self.etree.SubElement 2037 2038 a = Element('a') 2039 b = SubElement(a, 'b') 2040 c = SubElement(a, 'c') 2041 d = SubElement(a, 'd') 2042 e = SubElement(a, 'e') 2043 2044 del a[::-1] 2045 self.assertEquals( 2046 [], 2047 list(a))

2048

2049 - def test_delslice_step_negative2(self):

2050 Element = self.etree.Element 2051 SubElement = self.etree.SubElement 2052 2053 a = Element('a') 2054 b = SubElement(a, 'b') 2055 c = SubElement(a, 'c') 2056 d = SubElement(a, 'd') 2057 e = SubElement(a, 'e') 2058 2059 del a[::-2] 2060 self.assertEquals( 2061 [b, d], 2062 list(a))

2063

2064 - def test_delslice_child_tail(self):

2065 ElementTree = self.etree.ElementTree 2066 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2067 doc = ElementTree(file=f) 2068 a = doc.getroot() 2069 del a[1:3] 2070 self.assertXML( 2071 _bytes('<a>B2<e></e>E2</a>'), 2072 a)

2073

2074 - def test_delslice_tail(self):

2075 XML = self.etree.XML 2076 a = XML(_bytes('<a>B2<c></c>C2</a>')) 2077 b, c = a 2078 2079 del a[:] 2080 2081 self.assertEquals("B2", b.tail) 2082 self.assertEquals("C2", c.tail)

2083

2084 - def test_delslice_memory(self):

2085 # this could trigger a crash 2086 Element = self.etree.Element 2087 SubElement = self.etree.SubElement 2088 a = Element('a') 2089 b = SubElement(a, 'b') 2090 c = SubElement(b, 'c') 2091 del b # no more reference to b 2092 del a[:] 2093 self.assertEquals('c', c.tag)

2094

2095 - def test_setslice(self):

2096 Element = self.etree.Element 2097 SubElement = self.etree.SubElement 2098 2099 a = Element('a') 2100 b = SubElement(a, 'b') 2101 c = SubElement(a, 'c') 2102 d = SubElement(a, 'd') 2103 2104 e = Element('e') 2105 f = Element('f') 2106 g = Element('g') 2107 2108 s = [e, f, g] 2109 a[1:2] = s 2110 self.assertEquals( 2111 [b, e, f, g, d], 2112 list(a))

2113

2114 - def test_setslice_all(self):

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

2131

2132 - def test_setslice_all_empty(self):

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

2147

2148 - def test_setslice_all_replace(self):

2149 Element = self.etree.Element 2150 SubElement = self.etree.SubElement 2151 2152 a = Element('a') 2153 b = SubElement(a, 'b') 2154 c = SubElement(a, 'c') 2155 d = SubElement(a, 'd') 2156 2157 s = [b, c, d] 2158 a[:] = s 2159 self.assertEquals( 2160 [b, c, d], 2161 list(a))

2162

2163 - def test_setslice_all_replace_reversed(self):

2164 Element = self.etree.Element 2165 SubElement = self.etree.SubElement 2166 2167 a = Element('a') 2168 b = SubElement(a, 'b') 2169 c = SubElement(a, 'c') 2170 d = SubElement(a, 'd') 2171 2172 s = [d, c, b] 2173 a[:] = s 2174 self.assertEquals( 2175 [d, c, b], 2176 list(a))

2177

2178 - def test_setslice_all_replace_reversed_ns1(self):

2179 Element = self.etree.Element 2180 SubElement = self.etree.SubElement 2181 2182 a = Element('{ns}a') 2183 b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 2184 c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 2185 d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 2186 2187 s = [d, c, b] 2188 a[:] = s 2189 self.assertEquals( 2190 [d, c, b], 2191 list(a)) 2192 self.assertEquals( 2193 ['{ns}d', '{ns}c', '{ns}b'], 2194 [ child.tag for child in a ]) 2195 2196 self.assertEquals( 2197 [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 2198 [ list(child.attrib.keys()) for child in a ])

2199

2200 - def test_setslice_all_replace_reversed_ns2(self):

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

2221

2222 - def test_setslice_end(self):

2223 Element = self.etree.Element 2224 SubElement = self.etree.SubElement 2225 2226 a = Element('a') 2227 b = SubElement(a, 'b') 2228 c = SubElement(a, 'c') 2229 2230 e = Element('e') 2231 f = Element('f') 2232 g = Element('g') 2233 h = Element('h') 2234 2235 s = [e, f] 2236 a[99:] = s 2237 self.assertEquals( 2238 [a, b, e, f], 2239 list(a)) 2240 2241 s = [g, h] 2242 a[:0] = s 2243 self.assertEquals( 2244 [g, h, a, b, e, f], 2245 list(a))

2246

2247 - def test_setslice_single(self):

2248 Element = self.etree.Element 2249 SubElement = self.etree.SubElement 2250 2251 a = Element('a') 2252 b = SubElement(a, 'b') 2253 c = SubElement(a, 'c') 2254 2255 e = Element('e') 2256 f = Element('f') 2257 2258 s = [e] 2259 a[0:1] = s 2260 self.assertEquals( 2261 [e, c], 2262 list(a)) 2263 2264 s = [f] 2265 a[1:2] = s 2266 self.assertEquals( 2267 [e, f], 2268 list(a))

2269

2270 - def test_setslice_tail(self):

2271 ElementTree = self.etree.ElementTree 2272 Element = self.etree.Element 2273 f = BytesIO('<a>B2<c></c>C2<d></d>D2<e></e>E2</a>') 2274 doc = ElementTree(file=f) 2275 a = doc.getroot() 2276 x = Element('x') 2277 y = Element('y') 2278 z = Element('z') 2279 x.tail = 'X2' 2280 y.tail = 'Y2' 2281 z.tail = 'Z2' 2282 a[1:3] = [x, y, z] 2283 self.assertXML( 2284 _bytes('<a>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 2285 a)

2286

2287 - def test_setslice_negative(self):

2288 Element = self.etree.Element 2289 SubElement = self.etree.SubElement 2290 2291 a = Element('a') 2292 b = SubElement(a, 'b') 2293 c = SubElement(a, 'c') 2294 d = SubElement(a, 'd') 2295 2296 x = Element('x') 2297 y = Element('y') 2298 2299 a[1:-1] = [x, y] 2300 self.assertEquals( 2301 [b, x, y, d], 2302 list(a))

2303

2304 - def test_setslice_negative2(self):

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

2320

2321 - def test_setslice_end(self):

2322 Element = self.etree.Element 2323 SubElement = self.etree.SubElement 2324 2325 a = Element('a') 2326 b = SubElement(a, 'b') 2327 c = SubElement(a, 'c') 2328 d = SubElement(a, 'd') 2329 2330 e = Element('e') 2331 f = Element('f') 2332 g = Element('g') 2333 2334 s = [e, f, g] 2335 a[3:] = s 2336 self.assertEquals( 2337 [b, c, d, e, f, g], 2338 list(a))

2339

2340 - def test_setslice_empty(self):

2341 Element = self.etree.Element 2342 2343 a = Element('a') 2344 2345 b = Element('b') 2346 c = Element('c') 2347 2348 a[:] = [b, c] 2349 self.assertEquals( 2350 [b, c], 2351 list(a))

2352

2353 - def test_tail_elementtree_root(self):

2354 Element = self.etree.Element 2355 ElementTree = self.etree.ElementTree 2356 2357 a = Element('a') 2358 a.tail = 'A2' 2359 t = ElementTree(element=a) 2360 self.assertEquals('A2', 2361 a.tail)

2362

2363 - def test_elementtree_getiterator(self):

2364 Element = self.etree.Element 2365 SubElement = self.etree.SubElement 2366 ElementTree = self.etree.ElementTree 2367 2368 a = Element('a') 2369 b = SubElement(a, 'b') 2370 c = SubElement(a, 'c') 2371 d = SubElement(b, 'd') 2372 e = SubElement(c, 'e') 2373 t = ElementTree(element=a) 2374 2375 self.assertEquals( 2376 [a, b, d, c, e], 2377 list(t.getiterator()))

2378

2379 - def test_elementtree_getiterator_filter(self):

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

2397

2398 - def test_ns_access(self):

2399 ElementTree = self.etree.ElementTree 2400 ns = 'http://xml.infrae.com/1' 2401 f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 2402 t = ElementTree(file=f) 2403 a = t.getroot() 2404 self.assertEquals('{%s}a' % ns, 2405 a.tag) 2406 self.assertEquals('{%s}b' % ns, 2407 a[0].tag)

2408

2409 - def test_ns_access2(self):

2410 ElementTree = self.etree.ElementTree 2411 ns = 'http://xml.infrae.com/1' 2412 ns2 = 'http://xml.infrae.com/2' 2413 f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 2414 t = ElementTree(file=f) 2415 a = t.getroot() 2416 self.assertEquals('{%s}a' % ns, 2417 a.tag) 2418 self.assertEquals('{%s}b' % ns, 2419 a[0].tag) 2420 self.assertEquals('{%s}b' % ns2, 2421 a[1].tag)

2422

2423 - def test_ns_setting(self):

2424 Element = self.etree.Element 2425 SubElement = self.etree.SubElement 2426 ns = 'http://xml.infrae.com/1' 2427 ns2 = 'http://xml.infrae.com/2' 2428 a = Element('{%s}a' % ns) 2429 b = SubElement(a, '{%s}b' % ns2) 2430 c = SubElement(a, '{%s}c' % ns) 2431 self.assertEquals('{%s}a' % ns, 2432 a.tag) 2433 self.assertEquals('{%s}b' % ns2, 2434 b.tag) 2435 self.assertEquals('{%s}c' % ns, 2436 c.tag) 2437 self.assertEquals('{%s}a' % ns, 2438 a.tag) 2439 self.assertEquals('{%s}b' % ns2, 2440 b.tag) 2441 self.assertEquals('{%s}c' % ns, 2442 c.tag)

2443

2444 - def test_ns_tag_parse(self):

2445 Element = self.etree.Element 2446 SubElement = self.etree.SubElement 2447 ElementTree = self.etree.ElementTree 2448 2449 ns = 'http://xml.infrae.com/1' 2450 ns2 = 'http://xml.infrae.com/2' 2451 f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b></a>' % (ns, ns2)) 2452 t = ElementTree(file=f) 2453 2454 a = t.getroot() 2455 self.assertEquals('{%s}a' % ns, 2456 a.tag) 2457 self.assertEquals('{%s}b' % ns2, 2458 a[0].tag) 2459 self.assertEquals('{%s}b' % ns, 2460 a[1].tag)

2461

2462 - def test_ns_attr(self):

2463 Element = self.etree.Element 2464 ns = 'http://xml.infrae.com/1' 2465 ns2 = 'http://xml.infrae.com/2' 2466 a = Element('a') 2467 a.set('{%s}foo' % ns, 'Foo') 2468 a.set('{%s}bar' % ns2, 'Bar') 2469 self.assertEquals( 2470 'Foo', 2471 a.get('{%s}foo' % ns)) 2472 self.assertEquals( 2473 'Bar', 2474 a.get('{%s}bar' % ns2)) 2475 try: 2476 self.assertXML( 2477 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 2478 a) 2479 except AssertionError: 2480 self.assertXML( 2481 _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 2482 a)

2483

2484 - def test_ns_move(self):

2485 Element = self.etree.Element 2486 one = self.etree.fromstring( 2487 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2488 baz = one[0][0] 2489 2490 two = Element('root') 2491 two.append(baz) 2492 # removing the originating document could cause a crash/error before 2493 # as namespace is not moved along with it 2494 del one, baz 2495 self.assertEquals('{http://a.b.c}baz', two[0].tag)

2496

2497 - def test_ns_decl_tostring(self):

2498 tostring = self.etree.tostring 2499 root = self.etree.XML( 2500 _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 2501 baz = root[0][0] 2502 2503 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2504 tostring(baz)) 2505 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2506

2507 - def test_ns_decl_tostring_default(self):

2508 tostring = self.etree.tostring 2509 root = self.etree.XML( 2510 _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 2511 baz = root[0][0] 2512 2513 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2514 tostring(baz)) 2515 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2516

2517 - def test_ns_decl_tostring_root(self):

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

2527

2528 - def test_ns_decl_tostring_element(self):

2529 Element = self.etree.Element 2530 SubElement = self.etree.SubElement 2531 2532 root = Element("foo") 2533 bar = SubElement(root, "{http://a.b.c}bar") 2534 baz = SubElement(bar, "{http://a.b.c}baz") 2535 2536 nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 2537 self.etree.tostring(baz)) 2538 2539 self.assertEquals([_bytes("http://a.b.c")], nsdecl)

2540

2541 - def test_attribute_xmlns_move(self):

2542 Element = self.etree.Element 2543 2544 root = Element('element') 2545 2546 subelement = Element('subelement', 2547 {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 2548 self.assertEquals(1, len(subelement.attrib)) 2549 self.assertEquals( 2550 "foo", 2551 subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 2552 2553 root.append(subelement) 2554 self.assertEquals(1, len(subelement.attrib)) 2555 self.assertEquals( 2556 list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 2557 list(subelement.attrib.items())) 2558 self.assertEquals( 2559 "foo", 2560 subelement.get("{http://www.w3.org/XML/1998/namespace}id"))

2561

2562 - def test_namespaces_after_serialize(self):

2563 parse = self.etree.parse 2564 tostring = self.etree.tostring 2565 2566 ns_href = "http://a.b.c" 2567 one = parse( 2568 BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2569 baz = one.getroot()[0][0] 2570 2571 parsed = parse(BytesIO( tostring(baz) )).getroot() 2572 self.assertEquals('{%s}baz' % ns_href, parsed.tag)

2573

2574 - def test_attribute_namespace_roundtrip(self):

2575 fromstring = self.etree.fromstring 2576 tostring = self.etree.tostring 2577 2578 ns_href = "http://a.b.c" 2579 xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 2580 ns_href,ns_href)) 2581 root = fromstring(xml) 2582 self.assertEquals('test', root[0].get('{%s}a' % ns_href)) 2583 2584 xml2 = tostring(root) 2585 self.assertTrue(_bytes(':a=') in xml2, xml2) 2586 2587 root2 = fromstring(xml2) 2588 self.assertEquals('test', root[0].get('{%s}a' % ns_href))

2589

2590 - def test_attribute_namespace_roundtrip_replaced(self):

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

2607 2608 required_versions_ET['test_register_namespace'] = (1,3)

2609 - def test_register_namespace(self):

2610 # ET 1.3+ 2611 Element = self.etree.Element 2612 tostring = self.etree.tostring 2613 prefix = 'TESTPREFIX' 2614 namespace = 'http://seriously.unknown/namespace/URI' 2615 2616 el = Element('{%s}test' % namespace) 2617 self.assertEquals(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 2618 self._writeElement(el)) 2619 2620 self.etree.register_namespace(prefix, namespace) 2621 el = Element('{%s}test' % namespace) 2622 self.assertEquals(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 2623 prefix, prefix, namespace, prefix)), 2624 self._writeElement(el)) 2625 2626 self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace)

2627

2628 - def test_tostring(self):

2629 tostring = self.etree.tostring 2630 Element = self.etree.Element 2631 SubElement = self.etree.SubElement 2632 2633 a = Element('a') 2634 b = SubElement(a, 'b') 2635 c = SubElement(a, 'c') 2636 2637 self.assertEquals(_bytes('<a><c></c></a>'), 2638 canonicalize(tostring(a)))

2639

2640 - def test_tostring_element(self):

2641 tostring = self.etree.tostring 2642 Element = self.etree.Element 2643 SubElement = self.etree.SubElement 2644 2645 a = Element('a') 2646 b = SubElement(a, 'b') 2647 c = SubElement(a, 'c') 2648 d = SubElement(c, 'd') 2649 self.assertEquals(_bytes(''), 2650 canonicalize(tostring(b))) 2651 self.assertEquals(_bytes('<c><d></d></c>'), 2652 canonicalize(tostring(c)))

2653

2654 - def test_tostring_element_tail(self):

2655 tostring = self.etree.tostring 2656 Element = self.etree.Element 2657 SubElement = self.etree.SubElement 2658 2659 a = Element('a') 2660 b = SubElement(a, 'b') 2661 c = SubElement(a, 'c') 2662 d = SubElement(c, 'd') 2663 b.tail = 'Foo' 2664 2665 self.assert_(tostring(b) == _bytes('Foo') or 2666 tostring(b) == _bytes('Foo'))

2667 2668 required_versions_ET['test_tostring_method_html'] = (1,3)

2669 - def test_tostring_method_html(self):

2670 tostring = self.etree.tostring 2671 Element = self.etree.Element 2672 SubElement = self.etree.SubElement 2673 2674 html = Element('html') 2675 body = SubElement(html, 'body') 2676 p = SubElement(body, 'p') 2677 p.text = "html" 2678 SubElement(p, 'br').tail = "test" 2679 2680 self.assertEquals(_bytes('<html><body>html test</body></html>'), 2681 tostring(html, method="html"))

2682 2683 required_versions_ET['test_tostring_method_text'] = (1,3)

2684 - def test_tostring_method_text(self):

2685 tostring = self.etree.tostring 2686 Element = self.etree.Element 2687 SubElement = self.etree.SubElement 2688 2689 a = Element('a') 2690 a.text = "A" 2691 a.tail = "tail" 2692 b = SubElement(a, 'b') 2693 b.text = "B" 2694 b.tail = "TAIL" 2695 c = SubElement(a, 'c') 2696 c.text = "C" 2697 2698 self.assertEquals(_bytes('ABTAILCtail'), 2699 tostring(a, method="text"))

2700

2701 - def test_iterparse(self):

2702 iterparse = self.etree.iterparse 2703 f = BytesIO('<a><c/></a>') 2704 2705 iterator = iterparse(f) 2706 self.assertEquals(None, 2707 iterator.root) 2708 events = list(iterator) 2709 root = iterator.root 2710 self.assertEquals( 2711 [('end', root[0]), ('end', root[1]), ('end', root)], 2712 events)

2713

2714 - def test_iterparse_file(self):

2715 iterparse = self.etree.iterparse 2716 iterator = iterparse(fileInTestDir("test.xml")) 2717 self.assertEquals(None, 2718 iterator.root) 2719 events = list(iterator) 2720 root = iterator.root 2721 self.assertEquals( 2722 [('end', root[0]), ('end', root)], 2723 events)

2724

2725 - def test_iterparse_start(self):

2726 iterparse = self.etree.iterparse 2727 f = BytesIO('<a><c/></a>') 2728 2729 iterator = iterparse(f, events=('start',)) 2730 events = list(iterator) 2731 root = iterator.root 2732 self.assertEquals( 2733 [('start', root), ('start', root[0]), ('start', root[1])], 2734 events)

2735

2736 - def test_iterparse_start_end(self):

2737 iterparse = self.etree.iterparse 2738 f = BytesIO('<a><c/></a>') 2739 2740 iterator = iterparse(f, events=('start','end')) 2741 events = list(iterator) 2742 root = iterator.root 2743 self.assertEquals( 2744 [('start', root), ('start', root[0]), ('end', root[0]), 2745 ('start', root[1]), ('end', root[1]), ('end', root)], 2746 events)

2747

2748 - def test_iterparse_clear(self):

2749 iterparse = self.etree.iterparse 2750 f = BytesIO('<a><c/></a>') 2751 2752 iterator = iterparse(f) 2753 for event, elem in iterator: 2754 elem.clear() 2755 2756 root = iterator.root 2757 self.assertEquals(0, 2758 len(root))

2759

2760 - def test_iterparse_large(self):

2761 iterparse = self.etree.iterparse 2762 CHILD_COUNT = 12345 2763 f = BytesIO('<a>%s</a>' % ('test'*CHILD_COUNT)) 2764 2765 i = 0 2766 for key in iterparse(f): 2767 event, element = key 2768 i += 1 2769 self.assertEquals(i, CHILD_COUNT + 1)

2770

2771 - def test_iterparse_attrib_ns(self):

2772 iterparse = self.etree.iterparse 2773 f = BytesIO('<a xmlns="http://ns1/"><c xmlns="http://ns2/"/></a>') 2774 2775 attr_name = '{http://testns/}bla' 2776 events = [] 2777 iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 2778 for event, elem in iterator: 2779 events.append(event) 2780 if event == 'start': 2781 if elem.tag != '{http://ns1/}a': 2782 elem.set(attr_name, 'value') 2783 2784 self.assertEquals( 2785 ['start-ns', 'start', 'start', 'start-ns', 'start', 2786 'end', 'end-ns', 'end', 'end', 'end-ns'], 2787 events) 2788 2789 root = iterator.root 2790 self.assertEquals( 2791 None, 2792 root.get(attr_name)) 2793 self.assertEquals( 2794 'value', 2795 root[0].get(attr_name))

2796

2797 - def test_iterparse_getiterator(self):

2798 iterparse = self.etree.iterparse 2799 f = BytesIO('<a><d/><c/></a>') 2800 2801 counts = [] 2802 for event, elem in iterparse(f): 2803 counts.append(len(list(elem.getiterator()))) 2804 self.assertEquals( 2805 [1,2,1,4], 2806 counts)

2807

2808 - def test_iterparse_move_elements(self):

2809 iterparse = self.etree.iterparse 2810 f = BytesIO('<a><d/><c/></a>') 2811 2812 for event, node in etree.iterparse(f): pass 2813 2814 root = etree.Element('new_root', {}) 2815 root[:] = node[:] 2816 2817 self.assertEquals( 2818 ['b', 'c'], 2819 [ el.tag for el in root ])

2820

2821 - def test_iterparse_cdata(self):

2822 tostring = self.etree.tostring 2823 f = BytesIO('<root><![CDATA[test]]></root>') 2824 context = self.etree.iterparse(f) 2825 content = [ el.text for event,el in context ] 2826 2827 self.assertEquals(['test'], content) 2828 self.assertEquals(_bytes('<root>test</root>'), 2829 tostring(context.root))

2830

2831 - def test_parse_file(self):

2832 parse = self.etree.parse 2833 # from file 2834 tree = parse(fileInTestDir('test.xml')) 2835 self.assertXML( 2836 _bytes('<a></a>'), 2837 tree.getroot())

2838

2839 - def test_parse_file_nonexistent(self):

2840 parse = self.etree.parse 2841 self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))

2842

2843 - def test_parse_error_none(self):

2844 parse = self.etree.parse 2845 self.assertRaises(TypeError, parse, None)

2846 2847 required_versions_ET['test_parse_error'] = (1,3)

2848 - def test_parse_error(self):

2849 # ET < 1.3 raises ExpatError 2850 parse = self.etree.parse 2851 f = BytesIO('<a></c></a>') 2852 self.assertRaises(SyntaxError, parse, f) 2853 f.close()

2854 2855 required_versions_ET['test_parse_error_from_file'] = (1,3)

2856 - def test_parse_error_from_file(self):

2857 parse = self.etree.parse 2858 # from file 2859 f = open(fileInTestDir('test_broken.xml'), 'rb') 2860 self.assertRaises(SyntaxError, parse, f) 2861 f.close()

2862

2863 - def test_parse_file_object(self):

2864 parse = self.etree.parse 2865 # from file object 2866 f = open(fileInTestDir('test.xml'), 'rb') 2867 tree = parse(f) 2868 f.close() 2869 self.assertXML( 2870 _bytes('<a></a>'), 2871 tree.getroot())

2872

2873 - def test_parse_stringio(self):

2874 parse = self.etree.parse 2875 f = BytesIO('<a></a>') 2876 tree = parse(f) 2877 f.close() 2878 self.assertXML( 2879 _bytes('<a></a>'), 2880 tree.getroot() 2881 )

2882

2883 - def test_parse_cdata(self):

2884 tostring = self.etree.tostring 2885 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 2886 2887 self.assertEquals('test', root.text) 2888 self.assertEquals(_bytes('<root>test</root>'), 2889 tostring(root))

2890

2891 - def test_parse_with_encoding(self):

2892 # this can fail in libxml2 <= 2.6.22 2893 parse = self.etree.parse 2894 tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 2895 self.assertXML(_bytes('<html></html>'), 2896 tree.getroot())

2897

2898 - def test_encoding(self):

2899 Element = self.etree.Element 2900 2901 a = Element('a') 2902 a.text = _str('Søk på nettet') 2903 self.assertXML( 2904 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2905 a, 'utf-8')

2906

2907 - def test_encoding_exact(self):

2908 ElementTree = self.etree.ElementTree 2909 Element = self.etree.Element 2910 2911 a = Element('a') 2912 a.text = _str('Søk på nettet') 2913 2914 f = BytesIO() 2915 tree = ElementTree(element=a) 2916 tree.write(f, encoding='utf-8') 2917 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'), 2918 f.getvalue().replace(_bytes('\n'),_bytes('')))

2919

2920 - def test_parse_file_encoding(self):

2921 parse = self.etree.parse 2922 # from file 2923 tree = parse(fileInTestDir('test-string.xml')) 2924 self.assertXML( 2925 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2926 tree.getroot(), 'UTF-8')

2927

2928 - def test_parse_file_object_encoding(self):

2929 parse = self.etree.parse 2930 # from file object 2931 f = open(fileInTestDir('test-string.xml'), 'rb') 2932 tree = parse(f) 2933 f.close() 2934 self.assertXML( 2935 _str('<a>Søk på nettet</a>').encode('UTF-8'), 2936 tree.getroot(), 'UTF-8')

2937

2938 - def test_encoding_8bit_latin1(self):

2939 ElementTree = self.etree.ElementTree 2940 Element = self.etree.Element 2941 2942 a = Element('a') 2943 a.text = _str('Søk på nettet') 2944 2945 f = BytesIO() 2946 tree = ElementTree(element=a) 2947 tree.write(f, encoding='iso-8859-1') 2948 result = f.getvalue() 2949 declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 2950 self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 2951 result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 2952 self.assertEquals(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 2953 result)

2954 2955 required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3)

2956 - def test_parse_encoding_8bit_explicit(self):

2957 XMLParser = self.etree.XMLParser 2958 2959 text = _str('Søk på nettet') 2960 xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 2961 2962 self.assertRaises(self.etree.ParseError, 2963 self.etree.parse, 2964 BytesIO(xml_latin1)) 2965 2966 tree = self.etree.parse(BytesIO(xml_latin1), 2967 XMLParser(encoding="iso-8859-1")) 2968 a = tree.getroot() 2969 self.assertEquals(a.text, text)

2970 2971 required_versions_ET['test_parse_encoding_8bit_override'] = (1,3)

2972 - def test_parse_encoding_8bit_override(self):

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

2988

2989 - def _test_wrong_unicode_encoding(self):

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

2995

2996 - def test_encoding_write_default_encoding(self):

2997 ElementTree = self.etree.ElementTree 2998 Element = self.etree.Element 2999 3000 a = Element('a') 3001 a.text = _str('Søk på nettet') 3002 3003 f = BytesIO() 3004 tree = ElementTree(element=a) 3005 tree.write(f) 3006 data = f.getvalue().replace(_bytes('\n'),_bytes('')) 3007 self.assertEquals( 3008 _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 3009 data)

3010

3011 - def test_encoding_tostring(self):

3012 Element = self.etree.Element 3013 tostring = self.etree.tostring 3014 3015 a = Element('a') 3016 a.text = _str('Søk på nettet') 3017 self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'), 3018 tostring(a, encoding='utf-8'))

3019

3020 - def test_encoding_tostring_unknown(self):

3021 Element = self.etree.Element 3022 tostring = self.etree.tostring 3023 3024 a = Element('a') 3025 a.text = _str('Søk på nettet') 3026 self.assertRaises(LookupError, tostring, a, 3027 encoding='Invalid Encoding')

3028

3029 - def test_encoding_tostring_sub(self):

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

3039

3040 - def test_encoding_tostring_sub_tail(self):

3041 Element = self.etree.Element 3042 SubElement = self.etree.SubElement 3043 tostring = self.etree.tostring 3044 3045 a = Element('a') 3046 b = SubElement(a, 'b') 3047 b.text = _str('Søk på nettet') 3048 b.tail = _str('Søk') 3049 self.assertEquals(_str('Søk på nettetSøk').encode('UTF-8'), 3050 tostring(b, encoding='utf-8'))

3051

3052 - def test_encoding_tostring_default_encoding(self):

3053 Element = self.etree.Element 3054 SubElement = self.etree.SubElement 3055 tostring = self.etree.tostring 3056 3057 a = Element('a') 3058 a.text = _str('Søk på nettet') 3059 3060 expected = _bytes('<a>Søk på nettet</a>') 3061 self.assertEquals( 3062 expected, 3063 tostring(a))

3064

3065 - def test_encoding_sub_tostring_default_encoding(self):

3066 Element = self.etree.Element 3067 SubElement = self.etree.SubElement 3068 tostring = self.etree.tostring 3069 3070 a = Element('a') 3071 b = SubElement(a, 'b') 3072 b.text = _str('Søk på nettet') 3073 3074 expected = _bytes('Søk på nettet') 3075 self.assertEquals( 3076 expected, 3077 tostring(b))

3078

3079 - def test_encoding_8bit_xml(self):

3080 utext = _str('Søk på nettet') 3081 uxml = _str('%s') % utext 3082 prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 3083 isoxml = prologue + uxml.encode('iso-8859-1') 3084 tree = self.etree.XML(isoxml) 3085 self.assertEquals(utext, tree.text)

3086

3087 - def test_encoding_utf8_bom(self):

3088 utext = _str('Søk på nettet') 3089 uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 3090 _str('%s') % utext) 3091 bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 3092 xml = bom + uxml.encode("utf-8") 3093 tree = etree.XML(xml) 3094 self.assertEquals(utext, tree.text)

3095

3096 - def test_encoding_8bit_parse_stringio(self):

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

3103

3104 - def test_deepcopy_elementtree(self):

3105 Element = self.etree.Element 3106 ElementTree = self.etree.ElementTree 3107 3108 a = Element('a') 3109 a.text = "Foo" 3110 atree = ElementTree(a) 3111 3112 btree = copy.deepcopy(atree) 3113 self.assertEqual("Foo", atree.getroot().text) 3114 self.assertEqual("Foo", btree.getroot().text) 3115 self.assertFalse(btree is atree) 3116 self.assertFalse(btree.getroot() is atree.getroot())

3117

3118 - def test_deepcopy(self):

3119 Element = self.etree.Element 3120 3121 a = Element('a') 3122 a.text = 'Foo' 3123 3124 b = copy.deepcopy(a) 3125 self.assertEquals('Foo', b.text) 3126 3127 b.text = 'Bar' 3128 self.assertEquals('Bar', b.text) 3129 self.assertEquals('Foo', a.text) 3130 3131 del a 3132 self.assertEquals('Bar', b.text)

3133

3134 - def test_deepcopy_tail(self):

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

3149

3150 - def test_deepcopy_subelement(self):

3151 Element = self.etree.Element 3152 SubElement = self.etree.SubElement 3153 3154 root = Element('root') 3155 a = SubElement(root, 'a') 3156 a.text = 'FooText' 3157 a.tail = 'FooTail' 3158 3159 b = copy.deepcopy(a) 3160 self.assertEquals('FooText', b.text) 3161 self.assertEquals('FooTail', b.tail) 3162 3163 b.text = 'BarText' 3164 b.tail = 'BarTail' 3165 self.assertEquals('BarTail', b.tail) 3166 self.assertEquals('FooTail', a.tail) 3167 self.assertEquals('BarText', b.text) 3168 self.assertEquals('FooText', a.text) 3169 3170 del a 3171 self.assertEquals('BarTail', b.tail) 3172 self.assertEquals('BarText', b.text)

3173

3174 - def test_deepcopy_namespaces(self):

3175 root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 3176 <parent><node t:foo="bar" /></parent> 3177 </doc>''')) 3178 self.assertEquals( 3179 root[0][0].get('{tns}foo'), 3180 copy.deepcopy(root[0])[0].get('{tns}foo') ) 3181 self.assertEquals( 3182 root[0][0].get('{tns}foo'), 3183 copy.deepcopy(root[0][0]).get('{tns}foo') )

3184

3185 - def test_deepcopy_append(self):

3186 # previously caused a crash 3187 Element = self.etree.Element 3188 tostring = self.etree.tostring 3189 3190 a = Element('a') 3191 b = copy.deepcopy(a) 3192 a.append( Element('C') ) 3193 b.append( Element('X') ) 3194 3195 self.assertEquals(_bytes('<a><C/></a>'), 3196 tostring(a).replace(_bytes(' '), _bytes(''))) 3197 self.assertEquals(_bytes('<a><X/></a>'), 3198 tostring(b).replace(_bytes(' '), _bytes('')))

3199

3200 - def test_deepcopy_comment(self):

3201 # previously caused a crash 3202 # not supported by ET < 1.3! 3203 Comment = self.etree.Comment 3204 3205 a = Comment("ONE") 3206 b = copy.deepcopy(a) 3207 b.text = "ANOTHER" 3208 3209 self.assertEquals('ONE', a.text) 3210 self.assertEquals('ANOTHER', b.text)

3211

3212 - def test_shallowcopy(self):

3213 Element = self.etree.Element 3214 3215 a = Element('a') 3216 a.text = 'Foo' 3217 3218 b = copy.copy(a) 3219 self.assertEquals('Foo', b.text) 3220 3221 b.text = 'Bar' 3222 self.assertEquals('Bar', b.text) 3223 self.assertEquals('Foo', a.text)

3224 # XXX ElementTree will share nodes, but lxml.etree won't.. 3225

3226 - def test_shallowcopy_elementtree(self):

3227 Element = self.etree.Element 3228 ElementTree = self.etree.ElementTree 3229 3230 a = Element('a') 3231 a.text = 'Foo' 3232 atree = ElementTree(a) 3233 3234 btree = copy.copy(atree) 3235 self.assertFalse(btree is atree) 3236 self.assert_(btree.getroot() is atree.getroot()) 3237 self.assertEquals('Foo', atree.getroot().text)

3238

3239 - def _test_element_boolean(self):

3240 # deprecated as of ET 1.3/lxml 2.0 3241 etree = self.etree 3242 e = etree.Element('foo') 3243 self.assertEquals(False, bool(e)) 3244 etree.SubElement(e, 'bar') 3245 self.assertEquals(True, bool(e)) 3246 e = etree.Element('foo') 3247 e.text = 'hey' 3248 self.assertEquals(False, bool(e)) 3249 e = etree.Element('foo') 3250 e.tail = 'bar' 3251 self.assertEquals(False, bool(e)) 3252 e = etree.Element('foo') 3253 e.set('bar', 'Bar') 3254 self.assertEquals(False, bool(e))

3255

3256 - def test_multiple_elementrees(self):

3257 etree = self.etree 3258 3259 a = etree.Element('a') 3260 b = etree.SubElement(a, 'b') 3261 3262 t = etree.ElementTree(a) 3263 self.assertEquals(self._rootstring(t), _bytes('<a></a>')) 3264 3265 t1 = etree.ElementTree(a) 3266 self.assertEquals(self._rootstring(t1), _bytes('<a></a>')) 3267 self.assertEquals(self._rootstring(t), _bytes('<a></a>')) 3268 3269 t2 = etree.ElementTree(b) 3270 self.assertEquals(self._rootstring(t2), _bytes('')) 3271 self.assertEquals(self._rootstring(t1), _bytes('<a></a>')) 3272 self.assertEquals(self._rootstring(t), _bytes('<a></a>'))

3273

3274 - def test_qname(self):

3275 etree = self.etree 3276 qname = etree.QName('myns', 'a') 3277 a1 = etree.Element(qname) 3278 a2 = etree.SubElement(a1, qname) 3279 self.assertEquals(a1.tag, "{myns}a") 3280 self.assertEquals(a2.tag, "{myns}a")

3281

3282 - def test_qname_cmp(self):

3283 etree = self.etree 3284 qname1 = etree.QName('myns', 'a') 3285 qname2 = etree.QName('myns', 'a') 3286 self.assertEquals(qname1, "{myns}a") 3287 self.assertEquals("{myns}a", qname2) 3288 self.assertEquals(qname1, qname1) 3289 self.assertEquals(qname1, qname2)

3290

3291 - def test_qname_attribute_getset(self):

3292 etree = self.etree 3293 qname = etree.QName('myns', 'a') 3294 3295 a = etree.Element(qname) 3296 a.set(qname, "value") 3297 3298 self.assertEquals(a.get(qname), "value") 3299 self.assertEquals(a.get("{myns}a"), "value")

3300

3301 - def test_qname_attrib(self):

3302 etree = self.etree 3303 qname = etree.QName('myns', 'a') 3304 3305 a = etree.Element(qname) 3306 a.attrib[qname] = "value" 3307 3308 self.assertEquals(a.attrib[qname], "value") 3309 self.assertEquals(a.attrib.get(qname), "value") 3310 3311 self.assertEquals(a.attrib["{myns}a"], "value") 3312 self.assertEquals(a.attrib.get("{myns}a"), "value")

3313

3314 - def test_qname_attribute_resolve(self):

3315 etree = self.etree 3316 qname = etree.QName('http://myns', 'a') 3317 a = etree.Element(qname) 3318 a.set(qname, qname) 3319 3320 self.assertXML( 3321 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3322 a)

3323

3324 - def test_qname_attribute_resolve_new(self):

3325 etree = self.etree 3326 qname = etree.QName('http://myns', 'a') 3327 a = etree.Element('a') 3328 a.set('a', qname) 3329 3330 self.assertXML( 3331 _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 3332 a)

3333

3334 - def test_qname_attrib_resolve(self):

3335 etree = self.etree 3336 qname = etree.QName('http://myns', 'a') 3337 a = etree.Element(qname) 3338 a.attrib[qname] = qname 3339 3340 self.assertXML( 3341 _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 3342 a)

3343

3344 - def test_parser_version(self):

3345 etree = self.etree 3346 parser = etree.XMLParser() 3347 if hasattr(parser, "version"): 3348 # ElementTree 1.3+, cET 3349 self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))

3350 3351 # feed parser interface 3352

3353 - def test_feed_parser_bytes(self):

3354 parser = self.etree.XMLParser() 3355 3356 parser.feed(_bytes('<?xml version=')) 3357 parser.feed(_bytes('"1.0"?><ro')) 3358 parser.feed(_bytes('ot><')) 3359 parser.feed(_bytes('a test="works"/')) 3360 parser.feed(_bytes('></root')) 3361 parser.feed(_bytes('>')) 3362 3363 root = parser.close() 3364 3365 self.assertEquals(root.tag, "root") 3366 self.assertEquals(root[0].tag, "a") 3367 self.assertEquals(root[0].get("test"), "works")

3368

3369 - def test_feed_parser_unicode(self):

3370 parser = self.etree.XMLParser() 3371 3372 parser.feed(_str('<ro')) 3373 parser.feed(_str('ot><')) 3374 parser.feed(_str('a test="works"/')) 3375 parser.feed(_str('></root')) 3376 parser.feed(_str('>')) 3377 3378 root = parser.close() 3379 3380 self.assertEquals(root.tag, "root") 3381 self.assertEquals(root[0].tag, "a") 3382 self.assertEquals(root[0].get("test"), "works")

3383 3384 required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)

3385 - def test_feed_parser_error_close_empty(self):

3386 ParseError = self.etree.ParseError 3387 parser = self.etree.XMLParser() 3388 self.assertRaises(ParseError, parser.close)

3389 3390 required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3)

3391 - def test_feed_parser_error_close_incomplete(self):

3392 ParseError = self.etree.ParseError 3393 parser = self.etree.XMLParser() 3394 3395 parser.feed('<?xml version=') 3396 parser.feed('"1.0"?><ro') 3397 3398 self.assertRaises(ParseError, parser.close)

3399 3400 required_versions_ET['test_feed_parser_error_broken'] = (1,3)

3401 - def test_feed_parser_error_broken(self):

3402 ParseError = self.etree.ParseError 3403 parser = self.etree.XMLParser() 3404 3405 parser.feed('<?xml version=') 3406 parser.feed('"1.0"?><ro') 3407 try: 3408 parser.feed('<><><><><><><') 3409 except ParseError: 3410 # can raise, but not required before close() 3411 pass 3412 3413 self.assertRaises(ParseError, parser.close)

3414 3415 required_versions_ET['test_feed_parser_error_position'] = (1,3)

3416 - def test_feed_parser_error_position(self):

3417 ParseError = self.etree.ParseError 3418 parser = self.etree.XMLParser() 3419 try: 3420 parser.close() 3421 except ParseError: 3422 e = sys.exc_info()[1] 3423 self.assertNotEquals(None, e.code) 3424 self.assertNotEquals(0, e.code) 3425 self.assert_(isinstance(e.position, tuple)) 3426 self.assert_(e.position >= (0, 0))

3427 3428 # parser target interface 3429 3430 required_versions_ET['test_parser_target_property'] = (1,3)

3431 - def test_parser_target_property(self):

3432 class Target(object): 3433 pass

3434 3435 target = Target() 3436 parser = self.etree.XMLParser(target=target) 3437 3438 self.assertEquals(target, parser.target) 3439

3440 - def test_parser_target_tag(self):

3441 assertEquals = self.assertEquals 3442 assertFalse = self.assertFalse 3443 3444 events = [] 3445 class Target(object): 3446 def start(self, tag, attrib): 3447 events.append("start") 3448 assertFalse(attrib) 3449 assertEquals("TAG", tag)

3450 def end(self, tag): 3451 events.append("end") 3452 assertEquals("TAG", tag) 3453 def close(self): 3454 return "DONE" 3455 3456 parser = self.etree.XMLParser(target=Target()) 3457 3458 parser.feed("<TAG/>") 3459 done = parser.close() 3460 3461 self.assertEquals("DONE", done) 3462 self.assertEquals(["start", "end"], events) 3463

3464 - def test_elementtree_parser_target(self):

3465 assertEquals = self.assertEquals 3466 assertFalse = self.assertFalse 3467 Element = self.etree.Element 3468 3469 events = [] 3470 class Target(object): 3471 def start(self, tag, attrib): 3472 events.append("start") 3473 assertFalse(attrib) 3474 assertEquals("TAG", tag)

3475 def end(self, tag): 3476 events.append("end") 3477 assertEquals("TAG", tag) 3478 def close(self): 3479 return Element("DONE") 3480 3481 parser = self.etree.XMLParser(target=Target()) 3482 tree = self.etree.ElementTree() 3483 tree.parse(BytesIO("<TAG/>"), parser=parser) 3484 3485 self.assertEquals("DONE", tree.getroot().tag) 3486 self.assertEquals(["start", "end"], events) 3487

3488 - def test_parser_target_attrib(self):

3489 assertEquals = self.assertEquals 3490 3491 events = [] 3492 class Target(object): 3493 def start(self, tag, attrib): 3494 events.append("start-" + tag) 3495 for name, value in attrib.items(): 3496 assertEquals(tag + name, value)

3497 def end(self, tag): 3498 events.append("end-" + tag) 3499 def close(self): 3500 return "DONE" 3501 3502 parser = self.etree.XMLParser(target=Target()) 3503 3504 parser.feed('<root a="roota" b="rootb"></root>') 3505 done = parser.close() 3506 3507 self.assertEquals("DONE", done) 3508 self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"], 3509 events) 3510

3511 - def test_parser_target_data(self):

3512 events = [] 3513 class Target(object): 3514 def start(self, tag, attrib): 3515 events.append("start-" + tag)

3516 def end(self, tag): 3517 events.append("end-" + tag) 3518 def data(self, data): 3519 events.append("data-" + data) 3520 def close(self): 3521 return "DONE" 3522 3523 parser = self.etree.XMLParser(target=Target()) 3524 3525 parser.feed('<root>AB</root>') 3526 done = parser.close() 3527 3528 self.assertEquals("DONE", done) 3529 self.assertEquals(["start-root", "data-A", "start-sub", 3530 "end-sub", "data-B", "end-root"], 3531 events) 3532

3533 - def test_parser_target_entity(self):

3534 events = [] 3535 class Target(object): 3536 def __init__(self): 3537 self._data = []

3538 def _flush_data(self): 3539 if self._data: 3540 events.append("data-" + ''.join(self._data)) 3541 del self._data[:] 3542 def start(self, tag, attrib): 3543 self._flush_data() 3544 events.append("start-" + tag) 3545 def end(self, tag): 3546 self._flush_data() 3547 events.append("end-" + tag) 3548 def data(self, data): 3549 self._data.append(data) 3550 def close(self): 3551 self._flush_data() 3552 return "DONE" 3553 3554 parser = self.etree.XMLParser(target=Target()) 3555 3556 dtd = ''' 3557 <!DOCTYPE root [ 3558 <!ELEMENT root (sub*)> 3559 <!ELEMENT sub (#PCDATA)> 3560 <!ENTITY ent "an entity"> 3561 ]> 3562 ''' 3563 parser.feed(dtd+'<root>this is &ent;</root>') 3564 done = parser.close() 3565 3566 self.assertEquals("DONE", done) 3567 self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub", 3568 "data-this is an entity", 3569 "end-sub", "start-sub", "end-sub", "end-root"], 3570 events) 3571 3572 required_versions_ET['test_parser_target_entity_unknown'] = (1,3)

3573 - def test_parser_target_entity_unknown(self):

3574 events = [] 3575 class Target(object): 3576 def __init__(self): 3577 self._data = []

3578 def _flush_data(self): 3579 if self._data: 3580 events.append("data-" + ''.join(self._data)) 3581 del self._data[:] 3582 def start(self, tag, attrib): 3583 self._flush_data() 3584 events.append("start-" + tag) 3585 def end(self, tag): 3586 self._flush_data() 3587 events.append("end-" + tag) 3588 def data(self, data): 3589 self._data.append(data) 3590 def close(self): 3591 self._flush_data() 3592 return "DONE" 3593 3594 parser = self.etree.XMLParser(target=Target()) 3595 3596 def feed(): 3597 parser.feed('<root>some &ent;</root>') 3598 parser.close() 3599 3600 self.assertRaises(self.etree.ParseError, feed) 3601

3602 - def test_treebuilder(self):

3603 builder = self.etree.TreeBuilder() 3604 el = builder.start("root", {'a':'A', 'b':'B'}) 3605 self.assertEquals("root", el.tag) 3606 self.assertEquals({'a':'A', 'b':'B'}, el.attrib) 3607 builder.data("ROOTTEXT") 3608 el = builder.start("child", {'x':'X', 'y':'Y'}) 3609 self.assertEquals("child", el.tag) 3610 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3611 builder.data("CHILDTEXT") 3612 el = builder.end("child") 3613 self.assertEquals("child", el.tag) 3614 self.assertEquals({'x':'X', 'y':'Y'}, el.attrib) 3615 self.assertEquals("CHILDTEXT", el.text) 3616 self.assertEquals(None, el.tail) 3617 builder.data("CHILDTAIL") 3618 root = builder.end("root") 3619 3620 self.assertEquals("root", root.tag) 3621 self.assertEquals("ROOTTEXT", root.text) 3622 self.assertEquals("CHILDTEXT", root[0].text) 3623 self.assertEquals("CHILDTAIL", root[0].tail)

3624

3625 - def test_treebuilder_target(self):

3626 parser = self.etree.XMLParser(target=self.etree.TreeBuilder()) 3627 parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 3628 root = parser.close() 3629 3630 self.assertEquals("root", root.tag) 3631 self.assertEquals("ROOTTEXT", root.text) 3632 self.assertEquals("CHILDTEXT", root[0].text) 3633 self.assertEquals("CHILDTAIL", root[0].tail)

3634 3635 # helper methods 3636

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

3638 """Write out element for comparison. 3639 """ 3640 data = self.etree.tostring(element, encoding=encoding) 3641 return canonicalize(data)

3642

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

3644 """Write out element for comparison, using real file. 3645 """ 3646 ElementTree = self.etree.ElementTree 3647 handle, filename = tempfile.mkstemp() 3648 try: 3649 f = open(filename, 'wb') 3650 tree = ElementTree(element=element) 3651 tree.write(f, encoding=encoding) 3652 f.close() 3653 f = open(filename, 'rb') 3654 data = f.read() 3655 f.close() 3656 finally: 3657 os.close(handle) 3658 os.remove(filename) 3659 return canonicalize(data)

3660

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

3662 """Writes element out and checks whether it is expected. 3663 3664 Does this two ways; once using BytesIO, once using a real file. 3665 """ 3666 if isinstance(expected, unicode): 3667 expected = expected.encode(encoding) 3668 self.assertEquals(expected, self._writeElement(element, encoding)) 3669 self.assertEquals(expected, self._writeElementFile(element, encoding))

3670

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

3672 "Checks if the result XML byte string specifies the encoding." 3673 enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 3674 if isinstance(result, str): 3675 has_encoding = re.compile(enc_re).match 3676 else: 3677 has_encoding = re.compile(_bytes(enc_re)).match 3678 self.assert_(has_encoding(result)) 3679 result_encoding = has_encoding(result).group(1) 3680 self.assertEquals(result_encoding.upper(), encoding.upper())

3681

3682 - def _rootstring(self, tree):

3683 return self.etree.tostring(tree.getroot()).replace( 3684 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))

3685

3686 - def _check_element_tree(self, tree):

3687 self._check_element(tree.getroot())

3688

3689 - def _check_element(self, element):

3690 self.assert_(hasattr(element, 'tag')) 3691 self.assert_(hasattr(element, 'attrib')) 3692 self.assert_(hasattr(element, 'text')) 3693 self.assert_(hasattr(element, 'tail')) 3694 self._check_string(element.tag) 3695 self._check_mapping(element.attrib) 3696 if element.text != None: 3697 self._check_string(element.text) 3698 if element.tail != None: 3699 self._check_string(element.tail)

3700

3701 - def _check_string(self, string):

3702 len(string) 3703 for char in string: 3704 self.assertEquals(1, len(char)) 3705 new_string = string + "" 3706 new_string = string + " " 3707 string[:0]

3708

3709 - def _check_mapping(self, mapping):

3710 len(mapping) 3711 keys = mapping.keys() 3712 values = mapping.values() 3713 items = mapping.items() 3714 for key in keys: 3715 item = mapping[key] 3716 mapping["key"] = "value" 3717 self.assertEquals("value", mapping["key"])

3718 3719 3720 if etree:

3721 - class ETreeTestCase(ETreeTestCaseBase):

3722 etree = etree

3723 3724 if ElementTree:

3725 - class ElementTreeTestCase(ETreeTestCaseBase):

3726 etree = ElementTree

3727 3728 filter_by_version( 3729 ElementTreeTestCase, 3730 ElementTreeTestCase.required_versions_ET, ET_VERSION) 3731 3732 if cElementTree:

3733 - class CElementTreeTestCase(ETreeTestCaseBase):

3734 etree = cElementTree

3735 3736 filter_by_version( 3737 CElementTreeTestCase, 3738 CElementTreeTestCase.required_versions_cET, CET_VERSION) 3739

3740 -def test_suite():

3741 suite = unittest.TestSuite() 3742 if etree: 3743 suite.addTests([unittest.makeSuite(ETreeTestCase)]) 3744 if ElementTree: 3745 suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 3746 if cElementTree: 3747 suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 3748 return suite

3749 3750 if __name__ == '__main__': 3751 print('to test use test.py %s' % __file__) 3752