lxml.tests.test

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests specific to the extended etree API 5 6 Tests that apply to the general ElementTree API should go into 7 test_elementtree 8 """ 9 10 11 import unittest, copy, sys, operator 12 13 from common_imports import etree, StringIO, HelperTestCase, fileInTestDir 14 from common_imports import SillyFileLike, canonicalize, doctest 15 16 print 17 print "TESTED VERSION:", etree.__version__ 18 print " Python: ", sys.version_info 19 print " lxml.etree: ", etree.LXML_VERSION 20 print " libxml used: ", etree.LIBXML_VERSION 21 print " libxml compiled: ", etree.LIBXML_COMPILED_VERSION 22 print " libxslt used: ", etree.LIBXSLT_VERSION 23 print " libxslt compiled: ", etree.LIBXSLT_COMPILED_VERSION 24 print 25 26 try: 27 sorted 28 except NameError: 29 # Python 2.3

30 - def sorted(seq):

31 seq = list(seq) 32 seq.sort() 33 return seq

34

35 -class ETreeOnlyTestCase(HelperTestCase):

36 """Tests only for etree, not ElementTree""" 37 etree = etree 38

39 - def test_version(self):

40 self.assert_(isinstance(etree.__version__, str)) 41 self.assert_(isinstance(etree.LXML_VERSION, tuple)) 42 self.assertEqual(len(etree.LXML_VERSION), 4) 43 self.assert_(isinstance(etree.LXML_VERSION[0], int)) 44 self.assert_(isinstance(etree.LXML_VERSION[1], int)) 45 self.assert_(isinstance(etree.LXML_VERSION[2], int)) 46 self.assert_(isinstance(etree.LXML_VERSION[3], int)) 47 self.assert_(etree.__version__.startswith( 48 str(etree.LXML_VERSION[0])))

49

50 - def test_c_api(self):

51 if hasattr(self.etree, '__pyx_capi__'): 52 # newer Pyrex compatible C-API 53 self.assert_(isinstance(self.etree.__pyx_capi__, dict)) 54 self.assert_(len(self.etree.__pyx_capi__) > 0) 55 else: 56 # older C-API mechanism 57 self.assert_(hasattr(self.etree, '_import_c_api'))

58

59 - def test_element_names(self):

60 Element = self.etree.Element 61 el = Element('name') 62 self.assertEquals(el.tag, 'name') 63 el = Element('{}name') 64 self.assertEquals(el.tag, 'name')

65

66 - def test_element_name_empty(self):

67 Element = self.etree.Element 68 el = Element('name') 69 self.assertRaises(ValueError, Element, '{}') 70 self.assertRaises(ValueError, setattr, el, 'tag', '{}') 71 72 self.assertRaises(ValueError, Element, '{test}') 73 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')

74

75 - def test_element_name_colon(self):

76 Element = self.etree.Element 77 self.assertRaises(ValueError, Element, 'p:name') 78 self.assertRaises(ValueError, Element, '{test}p:name') 79 80 el = Element('name') 81 self.assertRaises(ValueError, setattr, el, 'tag', 'p:name')

82

83 - def test_element_name_quote(self):

84 Element = self.etree.Element 85 self.assertRaises(ValueError, Element, "p'name") 86 self.assertRaises(ValueError, Element, 'p"name') 87 88 self.assertRaises(ValueError, Element, "{test}p'name") 89 self.assertRaises(ValueError, Element, '{test}p"name') 90 91 el = Element('name') 92 self.assertRaises(ValueError, setattr, el, 'tag', "p'name") 93 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')

94

95 - def test_element_name_space(self):

96 Element = self.etree.Element 97 self.assertRaises(ValueError, Element, ' name ') 98 self.assertRaises(ValueError, Element, 'na me') 99 self.assertRaises(ValueError, Element, '{test} name') 100 101 el = Element('name') 102 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')

103

104 - def test_subelement_name_empty(self):

105 Element = self.etree.Element 106 SubElement = self.etree.SubElement 107 108 el = Element('name') 109 self.assertRaises(ValueError, SubElement, el, '{}') 110 self.assertRaises(ValueError, SubElement, el, '{test}')

111

112 - def test_subelement_name_colon(self):

113 Element = self.etree.Element 114 SubElement = self.etree.SubElement 115 116 el = Element('name') 117 self.assertRaises(ValueError, SubElement, el, 'p:name') 118 self.assertRaises(ValueError, SubElement, el, '{test}p:name')

119

120 - def test_subelement_name_quote(self):

121 Element = self.etree.Element 122 SubElement = self.etree.SubElement 123 124 el = Element('name') 125 self.assertRaises(ValueError, SubElement, el, "p'name") 126 self.assertRaises(ValueError, SubElement, el, "{test}p'name") 127 128 self.assertRaises(ValueError, SubElement, el, 'p"name') 129 self.assertRaises(ValueError, SubElement, el, '{test}p"name')

130

131 - def test_subelement_name_space(self):

132 Element = self.etree.Element 133 SubElement = self.etree.SubElement 134 135 el = Element('name') 136 self.assertRaises(ValueError, SubElement, el, ' name ') 137 self.assertRaises(ValueError, SubElement, el, 'na me') 138 self.assertRaises(ValueError, SubElement, el, '{test} name')

139

140 - def test_qname_empty(self):

141 QName = self.etree.QName 142 self.assertRaises(ValueError, QName, '') 143 self.assertRaises(ValueError, QName, 'test', '')

144

145 - def test_qname_colon(self):

146 QName = self.etree.QName 147 self.assertRaises(ValueError, QName, 'p:name') 148 self.assertRaises(ValueError, QName, 'test', 'p:name')

149

150 - def test_qname_space(self):

151 QName = self.etree.QName 152 self.assertRaises(ValueError, QName, ' name ') 153 self.assertRaises(ValueError, QName, 'na me') 154 self.assertRaises(ValueError, QName, 'test', ' name')

155

156 - def test_qname_text_resolve(self):

157 # ET doesn't resove QNames as text values 158 etree = self.etree 159 qname = etree.QName('http://myns', 'a') 160 a = etree.Element(qname, nsmap={'p' : 'http://myns'}) 161 a.text = qname 162 163 self.assertEquals("p:a", a.text)

164

165 - def test_attribute_set(self):

166 Element = self.etree.Element 167 root = Element("root") 168 root.set("attr", "TEST") 169 self.assertEquals("TEST", root.get("attr"))

170

171 - def test_attribute_set_invalid(self):

172 # ElementTree accepts arbitrary attribute values 173 # lxml.etree allows only strings 174 Element = self.etree.Element 175 root = Element("root") 176 self.assertRaises(TypeError, root.set, "newattr", 5) 177 self.assertRaises(TypeError, root.set, "newattr", None)

178

179 - def test_attrib_pop(self):

180 ElementTree = self.etree.ElementTree 181 182 f = StringIO('<doc one="One" two="Two"/>') 183 doc = ElementTree(file=f) 184 root = doc.getroot() 185 self.assertEquals('One', root.attrib['one']) 186 self.assertEquals('Two', root.attrib['two']) 187 188 self.assertEquals('One', root.attrib.pop('one')) 189 190 self.assertEquals(None, root.attrib.get('one')) 191 self.assertEquals('Two', root.attrib['two'])

192

193 - def test_attrib_pop_unknown(self):

194 root = self.etree.XML('<doc one="One" two="Two"/>') 195 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 196 197 self.assertEquals('One', root.attrib['one']) 198 self.assertEquals('Two', root.attrib['two'])

199

200 - def test_attrib_pop_default(self):

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

203

204 - def test_attrib_pop_empty_default(self):

205 root = self.etree.XML('<doc/>') 206 self.assertEquals('Three', root.attrib.pop('three', 'Three'))

207

208 - def test_attrib_pop_invalid_args(self):

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

211

212 - def test_pi(self):

213 # lxml.etree separates target and text 214 Element = self.etree.Element 215 SubElement = self.etree.SubElement 216 ProcessingInstruction = self.etree.ProcessingInstruction 217 218 a = Element('a') 219 a.append(ProcessingInstruction('foo', 'some more text')) 220 self.assertEquals(a[0].target, 'foo') 221 self.assertEquals(a[0].text, 'some more text')

222

223 - def test_pi_parse(self):

224 XML = self.etree.XML 225 root = XML("<test><?mypi my test ?></test>") 226 self.assertEquals(root[0].target, "mypi") 227 self.assertEquals(root[0].text, "my test ")

228

229 - def test_deepcopy_pi(self):

230 # previously caused a crash 231 ProcessingInstruction = self.etree.ProcessingInstruction 232 233 a = ProcessingInstruction("PI", "ONE") 234 b = copy.deepcopy(a) 235 b.text = "ANOTHER" 236 237 self.assertEquals('ONE', a.text) 238 self.assertEquals('ANOTHER', b.text)

239

240 - def test_deepcopy_comment(self):

241 # previously caused a crash 242 # not supported by ET! 243 Comment = self.etree.Comment 244 245 a = Comment("ONE") 246 b = copy.deepcopy(a) 247 b.text = "ANOTHER" 248 249 self.assertEquals('ONE', a.text) 250 self.assertEquals('ANOTHER', b.text)

251

252 - def test_attribute_set(self):

253 # ElementTree accepts arbitrary attribute values 254 # lxml.etree allows only strings 255 Element = self.etree.Element 256 257 root = Element("root") 258 root.set("attr", "TEST") 259 self.assertEquals("TEST", root.get("attr")) 260 self.assertRaises(TypeError, root.set, "newattr", 5)

261

262 - def test_parse_error(self):

263 # ET raises ExpatError 264 parse = self.etree.parse 265 # from StringIO 266 f = StringIO('<a></c></a>') 267 self.assertRaises(SyntaxError, parse, f) 268 f.close()

269

270 - def test_parse_remove_comments(self):

271 fromstring = self.etree.fromstring 272 tostring = self.etree.tostring 273 XMLParser = self.etree.XMLParser 274 275 xml = '<a><c/></a>' 276 parser = XMLParser(remove_comments=True) 277 root = fromstring(xml, parser) 278 self.assertEquals( 279 '<a><c/></a>', 280 tostring(root))

281

282 - def test_parse_remove_pis(self):

283 parse = self.etree.parse 284 tostring = self.etree.tostring 285 XMLParser = self.etree.XMLParser 286 287 xml = '<?test?><a><?A?><?B?><c/><?C?></a><?tail?>' 288 289 f = StringIO(xml) 290 tree = parse(f) 291 self.assertEquals( 292 xml, 293 tostring(tree)) 294 295 parser = XMLParser(remove_pis=True) 296 tree = parse(f, parser) 297 self.assertEquals( 298 '<a><c/></a>', 299 tostring(tree))

300

301 - def test_parse_parser_type_error(self):

302 # ET raises IOError only 303 parse = self.etree.parse 304 self.assertRaises(TypeError, parse, 'notthere.xml', object())

305

306 - def test_parse_error_logging(self):

307 parse = self.etree.parse 308 # from StringIO 309 f = StringIO('<a></c></a>') 310 self.etree.clearErrorLog() 311 try: 312 parse(f) 313 logs = None 314 except SyntaxError, e: 315 logs = e.error_log 316 f.close() 317 self.assert_([ log for log in logs 318 if 'mismatch' in log.message ]) 319 self.assert_([ log for log in logs 320 if 'PARSER' in log.domain_name]) 321 self.assert_([ log for log in logs 322 if 'TAG_NAME_MISMATCH' in log.type_name ]) 323 self.assert_([ log for log in logs 324 if 1 == log.line ]) 325 self.assert_([ log for log in logs 326 if 15 == log.column ])

327

328 - def test_parse_error_from_file(self):

329 parse = self.etree.parse 330 # from file 331 f = open(fileInTestDir('test_broken.xml'), 'r') 332 self.assertRaises(SyntaxError, parse, f) 333 f.close()

334

335 - def test_iterparse_comments(self):

336 # ET removes comments 337 iterparse = self.etree.iterparse 338 tostring = self.etree.tostring 339 340 f = StringIO('<a><c/></a>') 341 events = list(iterparse(f)) 342 root = events[-1][1] 343 self.assertEquals(3, len(events)) 344 self.assertEquals( 345 '<a><c/></a>', 346 tostring(root))

347

348 - def test_iterparse_remove_comments(self):

349 iterparse = self.etree.iterparse 350 tostring = self.etree.tostring 351 352 f = StringIO('<a><c/></a>') 353 events = list(iterparse(f, remove_comments=True)) 354 root = events[-1][1] 355 self.assertEquals( 356 '<a><c/></a>', 357 tostring(root))

358

359 - def test_iterparse_broken(self):

360 iterparse = self.etree.iterparse 361 f = StringIO('<a><c/></a>') 362 # ET raises ExpatError, lxml raises XMLSyntaxError 363 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))

364

365 - def test_iterparse_strip(self):

366 iterparse = self.etree.iterparse 367 f = StringIO(""" 368 <a> \n \n b test \n 369 370 \n\t <c> \n </c> </a> \n """) 371 iterator = iterparse(f, remove_blank_text=True) 372 text = [ (element.text, element.tail) 373 for event, element in iterator ] 374 self.assertEquals( 375 [(" b test ", None), (" \n ", None), (None, None)], 376 text)

377

378 - def test_iterparse_tag(self):

379 iterparse = self.etree.iterparse 380 f = StringIO('<a><d/><c/></a>') 381 382 iterator = iterparse(f, tag="b", events=('start', 'end')) 383 events = list(iterator) 384 root = iterator.root 385 self.assertEquals( 386 [('start', root[0]), ('end', root[0])], 387 events)

388

389 - def test_iterparse_tag_all(self):

390 iterparse = self.etree.iterparse 391 f = StringIO('<a><d/><c/></a>') 392 393 iterator = iterparse(f, tag="*", events=('start', 'end')) 394 events = list(iterator) 395 self.assertEquals( 396 8, 397 len(events))

398

399 - def test_iterparse_encoding_8bit_override(self):

400 text = u'Søk på nettet' 401 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 402 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 403 ).encode('iso-8859-1') 404 405 self.assertRaises(self.etree.ParseError, 406 list, self.etree.iterparse(StringIO(xml_latin1))) 407 408 iterator = self.etree.iterparse(StringIO(xml_latin1), 409 encoding="iso-8859-1") 410 self.assertEquals(1, len(list(iterator))) 411 412 a = iterator.root 413 self.assertEquals(a.text, text)

414

415 - def test_parser_encoding_unknown(self):

416 self.assertRaises( 417 LookupError, self.etree.XMLParser, encoding="hopefully unknown")

418

419 - def test_elementtree_parser_target_type_error(self):

420 assertEquals = self.assertEquals 421 assertFalse = self.assertFalse 422 423 events = [] 424 class Target(object): 425 def start(self, tag, attrib): 426 events.append("start") 427 assertFalse(attrib) 428 assertEquals("TAG", tag)

429 def end(self, tag): 430 events.append("end") 431 assertEquals("TAG", tag)

432 def close(self): 433 return "DONE" # no Element! 434 435 parser = self.etree.XMLParser(target=Target()) 436 tree = self.etree.ElementTree() 437 438 self.assertRaises(TypeError, 439 tree.parse, StringIO("<TAG/>"), parser=parser) 440 self.assertEquals(["start", "end"], events) 441

442 - def test_parser_target_recover(self):

443 events = [] 444 class Target(object): 445 def start(self, tag, attrib): 446 events.append("start-" + tag)

447 def end(self, tag): 448 events.append("end-" + tag) 449 def data(self, data): 450 events.append("data-" + data) 451 def close(self): 452 events.append("close") 453 return "DONE" 454 455 parser = self.etree.XMLParser(target=Target(), 456 recover=True) 457 458 parser.feed('<root>A<a>ca</a>B</not-root>') 459 done = parser.close() 460 461 self.assertEquals("DONE", done) 462 self.assertEquals(["start-root", "data-A", "start-a", 463 "data-ca", "end-a", "data-B", 464 "end-root", "close"], 465 events) 466

467 - def test_iterwalk_tag(self):

468 iterwalk = self.etree.iterwalk 469 root = self.etree.XML('<a><d/><c/></a>') 470 471 iterator = iterwalk(root, tag="b", events=('start', 'end')) 472 events = list(iterator) 473 self.assertEquals( 474 [('start', root[0]), ('end', root[0])], 475 events)

476

477 - def test_iterwalk_tag_all(self):

478 iterwalk = self.etree.iterwalk 479 root = self.etree.XML('<a><d/><c/></a>') 480 481 iterator = iterwalk(root, tag="*", events=('start', 'end')) 482 events = list(iterator) 483 self.assertEquals( 484 8, 485 len(events))

486

487 - def test_iterwalk(self):

488 iterwalk = self.etree.iterwalk 489 root = self.etree.XML('<a><c/></a>') 490 491 events = list(iterwalk(root)) 492 self.assertEquals( 493 [('end', root[0]), ('end', root[1]), ('end', root)], 494 events)

495

496 - def test_iterwalk_start(self):

497 iterwalk = self.etree.iterwalk 498 root = self.etree.XML('<a><c/></a>') 499 500 iterator = iterwalk(root, events=('start',)) 501 events = list(iterator) 502 self.assertEquals( 503 [('start', root), ('start', root[0]), ('start', root[1])], 504 events)

505

506 - def test_iterwalk_start_end(self):

507 iterwalk = self.etree.iterwalk 508 root = self.etree.XML('<a><c/></a>') 509 510 iterator = iterwalk(root, events=('start','end')) 511 events = list(iterator) 512 self.assertEquals( 513 [('start', root), ('start', root[0]), ('end', root[0]), 514 ('start', root[1]), ('end', root[1]), ('end', root)], 515 events)

516

517 - def test_iterwalk_clear(self):

518 iterwalk = self.etree.iterwalk 519 root = self.etree.XML('<a><c/></a>') 520 521 iterator = iterwalk(root) 522 for event, elem in iterator: 523 elem.clear() 524 525 self.assertEquals(0, 526 len(root))

527

528 - def test_iterwalk_attrib_ns(self):

529 iterwalk = self.etree.iterwalk 530 root = self.etree.XML('<a xmlns="ns1"><c xmlns="ns2"/></a>') 531 532 attr_name = '{testns}bla' 533 events = [] 534 iterator = iterwalk(root, events=('start','end','start-ns','end-ns')) 535 for event, elem in iterator: 536 events.append(event) 537 if event == 'start': 538 if elem.tag != '{ns1}a': 539 elem.set(attr_name, 'value') 540 541 self.assertEquals( 542 ['start-ns', 'start', 'start', 'start-ns', 'start', 543 'end', 'end-ns', 'end', 'end', 'end-ns'], 544 events) 545 546 self.assertEquals( 547 None, 548 root.get(attr_name)) 549 self.assertEquals( 550 'value', 551 root[0].get(attr_name))

552

553 - def test_iterwalk_getiterator(self):

554 iterwalk = self.etree.iterwalk 555 root = self.etree.XML('<a><d/><c/></a>') 556 557 counts = [] 558 for event, elem in iterwalk(root): 559 counts.append(len(list(elem.getiterator()))) 560 self.assertEquals( 561 [1,2,1,4], 562 counts)

563

564 - def test_resolve_string_dtd(self):

565 parse = self.etree.parse 566 parser = self.etree.XMLParser(dtd_validation=True) 567 assertEqual = self.assertEqual 568 test_url = u"__nosuch.dtd" 569 570 class MyResolver(self.etree.Resolver): 571 def resolve(self, url, id, context): 572 assertEqual(url, test_url) 573 return self.resolve_string( 574 u'''<!ENTITY myentity "%s"> 575 <!ELEMENT doc ANY>''' % url, context)

576 577 parser.resolvers.add(MyResolver()) 578 579 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url 580 tree = parse(StringIO(xml), parser) 581 root = tree.getroot() 582 self.assertEquals(root.text, test_url) 583

584 - def test_resolve_filename_dtd(self):

585 parse = self.etree.parse 586 parser = self.etree.XMLParser(attribute_defaults=True) 587 assertEqual = self.assertEqual 588 test_url = u"__nosuch.dtd" 589 590 class MyResolver(self.etree.Resolver): 591 def resolve(self, url, id, context): 592 assertEqual(url, test_url) 593 return self.resolve_filename( 594 fileInTestDir('test.dtd'), context)

595 596 parser.resolvers.add(MyResolver()) 597 598 xml = u'<!DOCTYPE a SYSTEM "%s"><a></a>' % test_url 599 tree = parse(StringIO(xml), parser) 600 root = tree.getroot() 601 self.assertEquals( 602 root.attrib, {'default': 'valueA'}) 603 self.assertEquals( 604 root[0].attrib, {'default': 'valueB'}) 605

606 - def test_resolve_empty(self):

607 parse = self.etree.parse 608 parser = self.etree.XMLParser(load_dtd=True) 609 assertEqual = self.assertEqual 610 test_url = u"__nosuch.dtd" 611 612 class check(object): 613 resolved = False

614 615 class MyResolver(self.etree.Resolver): 616 def resolve(self, url, id, context): 617 assertEqual(url, test_url) 618 check.resolved = True 619 return self.resolve_empty(context) 620 621 parser.resolvers.add(MyResolver()) 622 623 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url 624 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser) 625 self.assert_(check.resolved) 626

627 - def test_resolve_error(self):

628 parse = self.etree.parse 629 parser = self.etree.XMLParser(dtd_validation=True) 630 test_url = u"__nosuch.dtd" 631 632 class _LocalException(Exception): 633 pass

634 635 class MyResolver(self.etree.Resolver): 636 def resolve(self, url, id, context): 637 raise _LocalException 638 639 parser.resolvers.add(MyResolver()) 640 641 xml = u'<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 642 self.assertRaises(_LocalException, parse, StringIO(xml), parser) 643 644 if etree.LIBXML_VERSION > (2,6,20):

645 - def test_entity_parse(self):

646 parse = self.etree.parse 647 tostring = self.etree.tostring 648 parser = self.etree.XMLParser(resolve_entities=False) 649 Entity = self.etree.Entity 650 651 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 652 tree = parse(StringIO(xml), parser) 653 root = tree.getroot() 654 self.assertEquals(root[0].tag, Entity) 655 self.assertEquals(root[0].text, "&myentity;") 656 self.assertEquals(root[0].tail, None) 657 self.assertEquals(root[0].name, "myentity") 658 659 self.assertEquals('<doc>&myentity;</doc>', 660 tostring(root))

661

662 - def test_entity_append(self):

663 Entity = self.etree.Entity 664 Element = self.etree.Element 665 tostring = self.etree.tostring 666 667 root = Element("root") 668 root.append( Entity("test") ) 669 670 self.assertEquals(root[0].tag, Entity) 671 self.assertEquals(root[0].text, "&test;") 672 self.assertEquals(root[0].tail, None) 673 self.assertEquals(root[0].name, "test") 674 675 self.assertEquals('<root>&test;</root>', 676 tostring(root))

677

678 - def test_entity_values(self):

679 Entity = self.etree.Entity 680 self.assertEquals(Entity("test").text, '&test;') 681 self.assertEquals(Entity("#17683").text, '䔓') 682 self.assertEquals(Entity("#x1768").text, 'ᝨ') 683 self.assertEquals(Entity("#x98AF").text, '颯')

684

685 - def test_entity_error(self):

686 Entity = self.etree.Entity 687 self.assertRaises(ValueError, Entity, 'a b c') 688 self.assertRaises(ValueError, Entity, 'a,b') 689 self.assertRaises(AssertionError, Entity, 'a\0b') 690 self.assertRaises(ValueError, Entity, '#abc') 691 self.assertRaises(ValueError, Entity, '#xxyz')

692 693 # TypeError in etree, AssertionError in ElementTree;

694 - def test_setitem_assert(self):

695 Element = self.etree.Element 696 SubElement = self.etree.SubElement 697 698 a = Element('a') 699 b = SubElement(a, 'b') 700 701 self.assertRaises(TypeError, 702 a.__setitem__, 0, 'foo')

703

704 - def test_append_None(self):

705 # raises AssertionError in ElementTree 706 Element = self.etree.Element 707 self.assertRaises(TypeError, Element('a').append, None)

708

709 - def test_addnext(self):

710 Element = self.etree.Element 711 SubElement = self.etree.SubElement 712 root = Element('root') 713 SubElement(root, 'a') 714 SubElement(root, 'b') 715 716 self.assertEquals(['a', 'b'], 717 [c.tag for c in root]) 718 root[1].addnext(root[0]) 719 self.assertEquals(['b', 'a'], 720 [c.tag for c in root])

721

722 - def test_addprevious(self):

723 Element = self.etree.Element 724 SubElement = self.etree.SubElement 725 root = Element('root') 726 SubElement(root, 'a') 727 SubElement(root, 'b') 728 729 self.assertEquals(['a', 'b'], 730 [c.tag for c in root]) 731 root[0].addprevious(root[1]) 732 self.assertEquals(['b', 'a'], 733 [c.tag for c in root])

734

735 - def test_addnext_root(self):

736 Element = self.etree.Element 737 a = Element('a') 738 b = Element('b') 739 self.assertRaises(TypeError, a.addnext, b)

740

741 - def test_addnext_root(self):

742 Element = self.etree.Element 743 a = Element('a') 744 b = Element('b') 745 self.assertRaises(TypeError, a.addnext, b)

746

747 - def test_addprevious_pi(self):

748 Element = self.etree.Element 749 SubElement = self.etree.SubElement 750 PI = self.etree.PI 751 root = Element('root') 752 SubElement(root, 'a') 753 pi = PI('TARGET', 'TEXT') 754 pi.tail = "TAIL" 755 756 self.assertEquals('<root><a></a></root>', 757 self._writeElement(root)) 758 root[0].addprevious(pi) 759 self.assertEquals('<root><?TARGET TEXT?>TAIL<a></a></root>', 760 self._writeElement(root))

761

762 - def test_addprevious_root_pi(self):

763 Element = self.etree.Element 764 PI = self.etree.PI 765 root = Element('root') 766 pi = PI('TARGET', 'TEXT') 767 pi.tail = "TAIL" 768 769 self.assertEquals('<root></root>', 770 self._writeElement(root)) 771 root.addprevious(pi) 772 self.assertEquals('<?TARGET TEXT?>\n<root></root>', 773 self._writeElement(root))

774

775 - def test_addnext_pi(self):

776 Element = self.etree.Element 777 SubElement = self.etree.SubElement 778 PI = self.etree.PI 779 root = Element('root') 780 SubElement(root, 'a') 781 pi = PI('TARGET', 'TEXT') 782 pi.tail = "TAIL" 783 784 self.assertEquals('<root><a></a></root>', 785 self._writeElement(root)) 786 root[0].addnext(pi) 787 self.assertEquals('<root><a></a><?TARGET TEXT?>TAIL</root>', 788 self._writeElement(root))

789

790 - def test_addnext_root_pi(self):

791 Element = self.etree.Element 792 PI = self.etree.PI 793 root = Element('root') 794 pi = PI('TARGET', 'TEXT') 795 pi.tail = "TAIL" 796 797 self.assertEquals('<root></root>', 798 self._writeElement(root)) 799 root.addnext(pi) 800 self.assertEquals('<root></root>\n<?TARGET TEXT?>', 801 self._writeElement(root))

802

803 - def test_addnext_comment(self):

804 Element = self.etree.Element 805 SubElement = self.etree.SubElement 806 Comment = self.etree.Comment 807 root = Element('root') 808 SubElement(root, 'a') 809 comment = Comment('TEXT ') 810 comment.tail = "TAIL" 811 812 self.assertEquals('<root><a></a></root>', 813 self._writeElement(root)) 814 root[0].addnext(comment) 815 self.assertEquals('<root><a></a>TAIL</root>', 816 self._writeElement(root))

817

818 - def test_addnext_root_comment(self):

819 Element = self.etree.Element 820 Comment = self.etree.Comment 821 root = Element('root') 822 comment = Comment('TEXT ') 823 comment.tail = "TAIL" 824 825 self.assertEquals('<root></root>', 826 self._writeElement(root)) 827 root.addnext(comment) 828 self.assertEquals('<root></root>\n', 829 self._writeElement(root))

830

831 - def test_addprevious_comment(self):

832 Element = self.etree.Element 833 SubElement = self.etree.SubElement 834 Comment = self.etree.Comment 835 root = Element('root') 836 SubElement(root, 'a') 837 comment = Comment('TEXT ') 838 comment.tail = "TAIL" 839 840 self.assertEquals('<root><a></a></root>', 841 self._writeElement(root)) 842 root[0].addprevious(comment) 843 self.assertEquals('<root>TAIL<a></a></root>', 844 self._writeElement(root))

845

846 - def test_addprevious_root_comment(self):

847 Element = self.etree.Element 848 Comment = self.etree.Comment 849 root = Element('root') 850 comment = Comment('TEXT ') 851 comment.tail = "TAIL" 852 853 self.assertEquals('<root></root>', 854 self._writeElement(root)) 855 root.addprevious(comment) 856 self.assertEquals('\n<root></root>', 857 self._writeElement(root))

858 859 # ET's Elements have items() and key(), but not values()

860 - def test_attribute_values(self):

861 XML = self.etree.XML 862 863 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 864 values = root.values() 865 values.sort() 866 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)

867 868 # gives error in ElementTree

869 - def test_comment_empty(self):

870 Element = self.etree.Element 871 Comment = self.etree.Comment 872 873 a = Element('a') 874 a.append(Comment()) 875 self.assertEquals( 876 '<a></a>', 877 self._writeElement(a))

878 879 # ElementTree ignores comments

880 - def test_comment_parse_empty(self):

881 ElementTree = self.etree.ElementTree 882 tostring = self.etree.tostring 883 884 xml = '<a><c/></a>' 885 f = StringIO(xml) 886 doc = ElementTree(file=f) 887 a = doc.getroot() 888 self.assertEquals( 889 '', 890 a[1].text) 891 self.assertEquals( 892 xml, 893 tostring(a))

894 895 # ElementTree ignores comments

896 - def test_comment_no_proxy_yet(self):

897 ElementTree = self.etree.ElementTree 898 899 f = StringIO('<a><c></c></a>') 900 doc = ElementTree(file=f) 901 a = doc.getroot() 902 self.assertEquals( 903 ' hoi ', 904 a[1].text)

905 906 # ElementTree adds whitespace around comments

907 - def test_comment_text(self):

908 Element = self.etree.Element 909 Comment = self.etree.Comment 910 tostring = self.etree.tostring 911 912 a = Element('a') 913 a.append(Comment('foo')) 914 self.assertEquals( 915 '<a></a>', 916 tostring(a)) 917 918 a[0].text = "TEST" 919 self.assertEquals( 920 '<a></a>', 921 tostring(a))

922 923 # ElementTree adds whitespace around comments

924 - def test_comment_whitespace(self):

925 Element = self.etree.Element 926 Comment = self.etree.Comment 927 tostring = self.etree.tostring 928 929 a = Element('a') 930 a.append(Comment(' foo ')) 931 self.assertEquals( 932 '<a></a>', 933 tostring(a))

934 935 # does not raise an exception in ElementTree

936 - def test_comment_immutable(self):

937 Element = self.etree.Element 938 Comment = self.etree.Comment 939 940 c = Comment() 941 el = Element('myel') 942 943 self.assertRaises(TypeError, c.append, el) 944 self.assertRaises(TypeError, c.insert, 0, el) 945 self.assertRaises(TypeError, c.set, "myattr", "test")

946 947 # test weird dictionary interaction leading to segfault previously

948 - def test_weird_dict_interaction(self):

949 root = self.etree.Element('root') 950 add = self.etree.ElementTree(file=StringIO('<foo>Foo</foo>')) 951 root.append(self.etree.Element('baz'))

952 953 # test passing 'None' to dump

954 - def test_dump_none(self):

955 self.assertRaises(TypeError, etree.dump, None)

956

957 - def test_prefix(self):

958 ElementTree = self.etree.ElementTree 959 960 f = StringIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') 961 doc = ElementTree(file=f) 962 a = doc.getroot() 963 self.assertEquals( 964 None, 965 a.prefix) 966 self.assertEquals( 967 'foo', 968 a[0].prefix)

969

970 - def test_prefix_default_ns(self):

971 ElementTree = self.etree.ElementTree 972 973 f = StringIO('<a xmlns="http://www.infrae.com/ns/1"></a>') 974 doc = ElementTree(file=f) 975 a = doc.getroot() 976 self.assertEquals( 977 None, 978 a.prefix) 979 self.assertEquals( 980 None, 981 a[0].prefix)

982

983 - def test_getparent(self):

984 Element = self.etree.Element 985 SubElement = self.etree.SubElement 986 987 a = Element('a') 988 b = SubElement(a, 'b') 989 c = SubElement(a, 'c') 990 d = SubElement(b, 'd') 991 self.assertEquals( 992 None, 993 a.getparent()) 994 self.assertEquals( 995 a, 996 b.getparent()) 997 self.assertEquals( 998 b.getparent(), 999 c.getparent()) 1000 self.assertEquals( 1001 b, 1002 d.getparent())

1003

1004 - def test_iterchildren(self):

1005 XML = self.etree.XML 1006 1007 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 1008 result = [] 1009 for el in root.iterchildren(): 1010 result.append(el.tag) 1011 self.assertEquals(['one', 'two', 'three'], result)

1012

1013 - def test_iterchildren_reversed(self):

1014 XML = self.etree.XML 1015 1016 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 1017 result = [] 1018 for el in root.iterchildren(reversed=True): 1019 result.append(el.tag) 1020 self.assertEquals(['three', 'two', 'one'], result)

1021

1022 - def test_iterchildren_tag(self):

1023 XML = self.etree.XML 1024 1025 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>') 1026 result = [] 1027 for el in root.iterchildren(tag='two'): 1028 result.append(el.text) 1029 self.assertEquals(['Two', 'Bla'], result)

1030

1031 - def test_iterchildren_tag_reversed(self):

1032 XML = self.etree.XML 1033 1034 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>') 1035 result = [] 1036 for el in root.iterchildren(reversed=True, tag='two'): 1037 result.append(el.text) 1038 self.assertEquals(['Bla', 'Two'], result)

1039

1040 - def test_iterancestors(self):

1041 Element = self.etree.Element 1042 SubElement = self.etree.SubElement 1043 1044 a = Element('a') 1045 b = SubElement(a, 'b') 1046 c = SubElement(a, 'c') 1047 d = SubElement(b, 'd') 1048 self.assertEquals( 1049 [], 1050 list(a.iterancestors())) 1051 self.assertEquals( 1052 [a], 1053 list(b.iterancestors())) 1054 self.assertEquals( 1055 a, 1056 c.iterancestors().next()) 1057 self.assertEquals( 1058 [b, a], 1059 list(d.iterancestors()))

1060

1061 - def test_iterancestors_tag(self):

1062 Element = self.etree.Element 1063 SubElement = self.etree.SubElement 1064 1065 a = Element('a') 1066 b = SubElement(a, 'b') 1067 c = SubElement(a, 'c') 1068 d = SubElement(b, 'd') 1069 self.assertEquals( 1070 [a], 1071 list(d.iterancestors(tag='a')))

1072

1073 - def test_iterdescendants(self):

1074 Element = self.etree.Element 1075 SubElement = self.etree.SubElement 1076 1077 a = Element('a') 1078 b = SubElement(a, 'b') 1079 c = SubElement(a, 'c') 1080 d = SubElement(b, 'd') 1081 e = SubElement(c, 'e') 1082 1083 self.assertEquals( 1084 [b, d, c, e], 1085 list(a.iterdescendants())) 1086 self.assertEquals( 1087 [], 1088 list(d.iterdescendants()))

1089

1090 - def test_iterdescendants_tag(self):

1091 Element = self.etree.Element 1092 SubElement = self.etree.SubElement 1093 1094 a = Element('a') 1095 b = SubElement(a, 'b') 1096 c = SubElement(a, 'c') 1097 d = SubElement(b, 'd') 1098 e = SubElement(c, 'e') 1099 1100 self.assertEquals( 1101 [], 1102 list(a.iterdescendants('a'))) 1103 a2 = SubElement(e, 'a') 1104 self.assertEquals( 1105 [a2], 1106 list(a.iterdescendants('a'))) 1107 self.assertEquals( 1108 [a2], 1109 list(c.iterdescendants('a')))

1110

1111 - def test_getroottree(self):

1112 Element = self.etree.Element 1113 SubElement = self.etree.SubElement 1114 1115 a = Element('a') 1116 b = SubElement(a, 'b') 1117 c = SubElement(a, 'c') 1118 d = SubElement(b, 'd') 1119 self.assertEquals( 1120 a, 1121 a.getroottree().getroot()) 1122 self.assertEquals( 1123 a, 1124 b.getroottree().getroot()) 1125 self.assertEquals( 1126 a, 1127 d.getroottree().getroot())

1128

1129 - def test_getnext(self):

1130 Element = self.etree.Element 1131 SubElement = self.etree.SubElement 1132 1133 a = Element('a') 1134 b = SubElement(a, 'b') 1135 c = SubElement(a, 'c') 1136 self.assertEquals( 1137 None, 1138 a.getnext()) 1139 self.assertEquals( 1140 c, 1141 b.getnext()) 1142 self.assertEquals( 1143 None, 1144 c.getnext())

1145

1146 - def test_getprevious(self):

1147 Element = self.etree.Element 1148 SubElement = self.etree.SubElement 1149 1150 a = Element('a') 1151 b = SubElement(a, 'b') 1152 c = SubElement(a, 'c') 1153 d = SubElement(b, 'd') 1154 self.assertEquals( 1155 None, 1156 a.getprevious()) 1157 self.assertEquals( 1158 b, 1159 c.getprevious()) 1160 self.assertEquals( 1161 None, 1162 b.getprevious())

1163

1164 - def test_itersiblings(self):

1165 Element = self.etree.Element 1166 SubElement = self.etree.SubElement 1167 1168 a = Element('a') 1169 b = SubElement(a, 'b') 1170 c = SubElement(a, 'c') 1171 d = SubElement(b, 'd') 1172 self.assertEquals( 1173 [], 1174 list(a.itersiblings())) 1175 self.assertEquals( 1176 [c], 1177 list(b.itersiblings())) 1178 self.assertEquals( 1179 c, 1180 b.itersiblings().next()) 1181 self.assertEquals( 1182 [], 1183 list(c.itersiblings())) 1184 self.assertEquals( 1185 [b], 1186 list(c.itersiblings(preceding=True))) 1187 self.assertEquals( 1188 [], 1189 list(b.itersiblings(preceding=True)))

1190

1191 - def test_itersiblings_tag(self):

1192 Element = self.etree.Element 1193 SubElement = self.etree.SubElement 1194 1195 a = Element('a') 1196 b = SubElement(a, 'b') 1197 c = SubElement(a, 'c') 1198 d = SubElement(b, 'd') 1199 self.assertEquals( 1200 [], 1201 list(a.itersiblings(tag='XXX'))) 1202 self.assertEquals( 1203 [c], 1204 list(b.itersiblings(tag='c'))) 1205 self.assertEquals( 1206 [b], 1207 list(c.itersiblings(preceding=True, tag='b'))) 1208 self.assertEquals( 1209 [], 1210 list(c.itersiblings(preceding=True, tag='c')))

1211

1212 - def test_parseid(self):

1213 parseid = self.etree.parseid 1214 XML = self.etree.XML 1215 xml_text = ''' 1216 <!DOCTYPE document [ 1217 <!ELEMENT document (h1,p)*> 1218 <!ELEMENT h1 (#PCDATA)> 1219 <!ATTLIST h1 myid ID #REQUIRED> 1220 <!ELEMENT p (#PCDATA)> 1221 <!ATTLIST p someid ID #REQUIRED> 1222 ]> 1223 <document> 1224 <h1 myid="chapter1">...</h1> 1225 ... 1226 Regular paragraph. 1227 XML:ID paragraph. 1228 ... 1229 </document> 1230 ''' 1231 1232 tree, dic = parseid(StringIO(xml_text)) 1233 root = tree.getroot() 1234 root2 = XML(xml_text) 1235 self.assertEquals(self._writeElement(root), 1236 self._writeElement(root2)) 1237 expected = { 1238 "chapter1" : root[0], 1239 "xmlid" : root[3], 1240 "warn1" : root[4] 1241 } 1242 self.assert_("chapter1" in dic) 1243 self.assert_("warn1" in dic) 1244 self.assert_("xmlid" in dic) 1245 self._checkIDDict(dic, expected)

1246

1247 - def test_XMLDTDID(self):

1248 XMLDTDID = self.etree.XMLDTDID 1249 XML = self.etree.XML 1250 xml_text = ''' 1251 <!DOCTYPE document [ 1252 <!ELEMENT document (h1,p)*> 1253 <!ELEMENT h1 (#PCDATA)> 1254 <!ATTLIST h1 myid ID #REQUIRED> 1255 <!ELEMENT p (#PCDATA)> 1256 <!ATTLIST p someid ID #REQUIRED> 1257 ]> 1258 <document> 1259 <h1 myid="chapter1">...</h1> 1260 ... 1261 Regular paragraph. 1262 XML:ID paragraph. 1263 ... 1264 </document> 1265 ''' 1266 1267 root, dic = XMLDTDID(xml_text) 1268 root2 = XML(xml_text) 1269 self.assertEquals(self._writeElement(root), 1270 self._writeElement(root2)) 1271 expected = { 1272 "chapter1" : root[0], 1273 "xmlid" : root[3], 1274 "warn1" : root[4] 1275 } 1276 self.assert_("chapter1" in dic) 1277 self.assert_("warn1" in dic) 1278 self.assert_("xmlid" in dic) 1279 self._checkIDDict(dic, expected)

1280

1281 - def test_XMLDTDID_empty(self):

1282 XMLDTDID = self.etree.XMLDTDID 1283 XML = self.etree.XML 1284 xml_text = ''' 1285 <document> 1286 <h1 myid="chapter1">...</h1> 1287 ... 1288 Regular paragraph. 1289 ... 1290 </document> 1291 ''' 1292 1293 root, dic = XMLDTDID(xml_text) 1294 root2 = XML(xml_text) 1295 self.assertEquals(self._writeElement(root), 1296 self._writeElement(root2)) 1297 expected = {} 1298 self._checkIDDict(dic, expected)

1299

1300 - def _checkIDDict(self, dic, expected):

1301 self.assertEquals(dic, expected) 1302 self.assertEquals(len(dic), 1303 len(expected)) 1304 self.assertEquals(sorted(dic.items()), 1305 sorted(expected.items())) 1306 self.assertEquals(sorted(dic.iteritems()), 1307 sorted(expected.iteritems())) 1308 self.assertEquals(sorted(dic.keys()), 1309 sorted(expected.keys())) 1310 self.assertEquals(sorted(dic.iterkeys()), 1311 sorted(expected.iterkeys())) 1312 self.assertEquals(sorted(dic.values()), 1313 sorted(expected.values())) 1314 self.assertEquals(sorted(dic.itervalues()), 1315 sorted(expected.itervalues()))

1316

1317 - def test_namespaces(self):

1318 etree = self.etree 1319 1320 r = {'foo': 'http://ns.infrae.com/foo'} 1321 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1322 self.assertEquals( 1323 'foo', 1324 e.prefix) 1325 self.assertEquals( 1326 '<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>', 1327 self._writeElement(e))

1328

1329 - def test_namespaces_default(self):

1330 etree = self.etree 1331 1332 r = {None: 'http://ns.infrae.com/foo'} 1333 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1334 self.assertEquals( 1335 None, 1336 e.prefix) 1337 self.assertEquals( 1338 '{http://ns.infrae.com/foo}bar', 1339 e.tag) 1340 self.assertEquals( 1341 '<bar xmlns="http://ns.infrae.com/foo"></bar>', 1342 self._writeElement(e))

1343

1344 - def test_namespaces_default_and_attr(self):

1345 etree = self.etree 1346 1347 r = {None: 'http://ns.infrae.com/foo', 1348 'hoi': 'http://ns.infrae.com/hoi'} 1349 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1350 e.set('{http://ns.infrae.com/hoi}test', 'value') 1351 self.assertEquals( 1352 '<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>', 1353 self._writeElement(e))

1354

1355 - def test_namespaces_elementtree(self):

1356 etree = self.etree 1357 r = {None: 'http://ns.infrae.com/foo', 1358 'hoi': 'http://ns.infrae.com/hoi'} 1359 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) 1360 tree = etree.ElementTree(element=e) 1361 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') 1362 self.assertEquals( 1363 '<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>', 1364 self._writeElement(e))

1365

1366 - def test_namespaces_default_copy_element(self):

1367 etree = self.etree 1368 1369 r = {None: 'http://ns.infrae.com/foo'} 1370 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1371 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1372 1373 e1.append(e2) 1374 1375 self.assertEquals( 1376 None, 1377 e1.prefix) 1378 self.assertEquals( 1379 None, 1380 e1[0].prefix) 1381 self.assertEquals( 1382 '{http://ns.infrae.com/foo}bar', 1383 e1.tag) 1384 self.assertEquals( 1385 '{http://ns.infrae.com/foo}bar', 1386 e1[0].tag)

1387

1388 - def test_namespaces_copy_element(self):

1389 etree = self.etree 1390 1391 r = {None: 'http://ns.infrae.com/BAR'} 1392 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) 1393 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1394 1395 e1.append(e2) 1396 1397 self.assertEquals( 1398 None, 1399 e1.prefix) 1400 self.assertNotEquals( 1401 None, 1402 e2.prefix) 1403 self.assertEquals( 1404 '{http://ns.infrae.com/BAR}bar', 1405 e1.tag) 1406 self.assertEquals( 1407 '{http://ns.infrae.com/foo}bar', 1408 e2.tag)

1409

1410 - def test_namespaces_reuse_after_move(self):

1411 ns_href = "http://a.b.c" 1412 one = self.etree.fromstring( 1413 '<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href) 1414 baz = one[0][0] 1415 1416 two = self.etree.fromstring( 1417 '<root xmlns:ns="%s"/>' % ns_href) 1418 two.append(baz) 1419 del one # make sure the source document is deallocated 1420 1421 self.assertEquals('{%s}baz' % ns_href, baz.tag) 1422 self.assertEquals( 1423 '<root xmlns:ns="%s"><ns:baz/></root>' % ns_href, 1424 self.etree.tostring(two))

1425

1426 - def test_namespaces_after_serialize(self):

1427 parse = self.etree.parse 1428 tostring = self.etree.tostring 1429 1430 ns_href = "http://a.b.c" 1431 one = parse( 1432 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 1433 baz = one.getroot()[0][0] 1434 1435 parsed = parse(StringIO( tostring(baz) )).getroot() 1436 self.assertEquals('{%s}baz' % ns_href, parsed.tag)

1437

1438 - def test_element_nsmap(self):

1439 etree = self.etree 1440 1441 r = {None: 'http://ns.infrae.com/foo', 1442 'hoi': 'http://ns.infrae.com/hoi'} 1443 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1444 self.assertEquals( 1445 r, 1446 e.nsmap)

1447

1448 - def test_subelement_nsmap(self):

1449 etree = self.etree 1450 1451 re = {None: 'http://ns.infrae.com/foo', 1452 'hoi': 'http://ns.infrae.com/hoi'} 1453 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) 1454 1455 rs = {None: 'http://ns.infrae.com/honk', 1456 'top': 'http://ns.infrae.com/top'} 1457 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) 1458 1459 r = re.copy() 1460 r.update(rs) 1461 self.assertEquals( 1462 re, 1463 e.nsmap) 1464 self.assertEquals( 1465 r, 1466 s.nsmap)

1467

1468 - def test_getiterator_filter_namespace(self):

1469 Element = self.etree.Element 1470 SubElement = self.etree.SubElement 1471 1472 a = Element('{a}a') 1473 b = SubElement(a, '{a}b') 1474 c = SubElement(a, '{a}c') 1475 d = SubElement(b, '{b}d') 1476 e = SubElement(c, '{a}e') 1477 f = SubElement(c, '{b}f') 1478 1479 self.assertEquals( 1480 [a], 1481 list(a.getiterator('{a}a'))) 1482 self.assertEquals( 1483 [], 1484 list(a.getiterator('{b}a'))) 1485 self.assertEquals( 1486 [], 1487 list(a.getiterator('a'))) 1488 self.assertEquals( 1489 [f], 1490 list(c.getiterator('{b}*'))) 1491 self.assertEquals( 1492 [d, f], 1493 list(a.getiterator('{b}*')))

1494

1495 - def test_getiterator_filter_entities(self):

1496 Element = self.etree.Element 1497 Entity = self.etree.Entity 1498 SubElement = self.etree.SubElement 1499 1500 a = Element('a') 1501 b = SubElement(a, 'b') 1502 entity_b = Entity("TEST-b") 1503 b.append(entity_b) 1504 1505 self.assertEquals( 1506 [entity_b], 1507 list(a.getiterator(Entity))) 1508 1509 entity_a = Entity("TEST-a") 1510 a.append(entity_a) 1511 1512 self.assertEquals( 1513 [entity_b, entity_a], 1514 list(a.getiterator(Entity))) 1515 1516 self.assertEquals( 1517 [entity_b], 1518 list(b.getiterator(Entity)))

1519

1520 - def test_getiterator_filter_element(self):

1521 Element = self.etree.Element 1522 Comment = self.etree.Comment 1523 PI = self.etree.PI 1524 SubElement = self.etree.SubElement 1525 1526 a = Element('a') 1527 b = SubElement(a, 'b') 1528 a.append(Comment("test")) 1529 a.append(PI("pi", "content")) 1530 c = SubElement(a, 'c') 1531 1532 self.assertEquals( 1533 [a, b, c], 1534 list(a.getiterator(Element)))

1535

1536 - def test_getiterator_filter_all_comment_pi(self):

1537 # ElementTree iterates over everything here 1538 Element = self.etree.Element 1539 Comment = self.etree.Comment 1540 PI = self.etree.PI 1541 SubElement = self.etree.SubElement 1542 1543 a = Element('a') 1544 b = SubElement(a, 'b') 1545 a.append(Comment("test")) 1546 a.append(PI("pi", "content")) 1547 c = SubElement(a, 'c') 1548 1549 self.assertEquals( 1550 [a, b, c], 1551 list(a.getiterator('*')))

1552

1553 - def test_itertext(self):

1554 # ET 1.3+ 1555 XML = self.etree.XML 1556 root = XML("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>") 1557 1558 text = list(root.itertext()) 1559 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 1560 text)

1561

1562 - def test_itertext_child(self):

1563 # ET 1.3+ 1564 XML = self.etree.XML 1565 root = XML("<root>RTEXT<a></a>ATAIL<c>CTEXT</c>CTAIL</root>") 1566 1567 text = list(root[2].itertext()) 1568 self.assertEquals(["CTEXT"], 1569 text)

1570

1571 - def test_elementtree_find_qname(self):

1572 XML = self.etree.XML 1573 ElementTree = self.etree.ElementTree 1574 QName = self.etree.QName 1575 tree = ElementTree(XML('<a><c/><c></c></a>')) 1576 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])

1577

1578 - def test_elementtree_findall_qname(self):

1579 XML = self.etree.XML 1580 ElementTree = self.etree.ElementTree 1581 QName = self.etree.QName 1582 tree = ElementTree(XML('<a><c/><c></c></a>')) 1583 self.assertEquals(len(list(tree.findall(QName("c")))), 1)

1584

1585 - def test_elementtree_findall_ns_qname(self):

1586 XML = self.etree.XML 1587 ElementTree = self.etree.ElementTree 1588 QName = self.etree.QName 1589 tree = ElementTree(XML( 1590 '<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 1591 self.assertEquals(len(list(tree.findall(QName("b")))), 2) 1592 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)

1593

1594 - def test_findall_ns(self):

1595 XML = self.etree.XML 1596 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 1597 self.assertEquals(len(root.findall(".//{X}b")), 2) 1598 self.assertEquals(len(root.findall(".//{X}*")), 2) 1599 self.assertEquals(len(root.findall(".//b")), 3)

1600

1601 - def test_index(self):

1602 etree = self.etree 1603 e = etree.Element('foo') 1604 for i in range(10): 1605 etree.SubElement(e, 'a%s' % i) 1606 for i in range(10): 1607 self.assertEquals( 1608 i, 1609 e.index(e[i])) 1610 self.assertEquals( 1611 3, e.index(e[3], 3)) 1612 self.assertRaises( 1613 ValueError, e.index, e[3], 4) 1614 self.assertRaises( 1615 ValueError, e.index, e[3], 0, 2) 1616 self.assertRaises( 1617 ValueError, e.index, e[8], 0, -3) 1618 self.assertRaises( 1619 ValueError, e.index, e[8], -5, -3) 1620 self.assertEquals( 1621 8, e.index(e[8], 0, -1)) 1622 self.assertEquals( 1623 8, e.index(e[8], -12, -1)) 1624 self.assertEquals( 1625 0, e.index(e[0], -12, -1))

1626

1627 - def test_replace(self):

1628 etree = self.etree 1629 e = etree.Element('foo') 1630 for i in range(10): 1631 el = etree.SubElement(e, 'a%s' % i) 1632 el.text = "text%d" % i 1633 el.tail = "tail%d" % i 1634 1635 child0 = e[0] 1636 child1 = e[1] 1637 child2 = e[2] 1638 1639 e.replace(e[0], e[1]) 1640 self.assertEquals( 1641 9, len(e)) 1642 self.assertEquals( 1643 child1, e[0]) 1644 self.assertEquals( 1645 child1.text, "text1") 1646 self.assertEquals( 1647 child1.tail, "tail1") 1648 self.assertEquals( 1649 child0.tail, "tail0") 1650 self.assertEquals( 1651 child2, e[1]) 1652 1653 e.replace(e[-1], e[0]) 1654 self.assertEquals( 1655 child1, e[-1]) 1656 self.assertEquals( 1657 child1.text, "text1") 1658 self.assertEquals( 1659 child1.tail, "tail1") 1660 self.assertEquals( 1661 child2, e[0])

1662

1663 - def test_replace_new(self):

1664 etree = self.etree 1665 e = etree.Element('foo') 1666 for i in range(10): 1667 etree.SubElement(e, 'a%s' % i) 1668 1669 new_element = etree.Element("test") 1670 new_element.text = "TESTTEXT" 1671 new_element.tail = "TESTTAIL" 1672 child1 = e[1] 1673 e.replace(e[0], new_element) 1674 self.assertEquals( 1675 new_element, e[0]) 1676 self.assertEquals( 1677 "TESTTEXT", 1678 e[0].text) 1679 self.assertEquals( 1680 "TESTTAIL", 1681 e[0].tail) 1682 self.assertEquals( 1683 child1, e[1])

1684

1685 - def test_setslice_all_empty_reversed(self):

1686 Element = self.etree.Element 1687 SubElement = self.etree.SubElement 1688 1689 a = Element('a') 1690 1691 e = Element('e') 1692 f = Element('f') 1693 g = Element('g') 1694 1695 s = [e, f, g] 1696 a[::-1] = s 1697 self.assertEquals( 1698 [g, f, e], 1699 list(a))

1700

1701 - def test_setslice_step(self):

1702 Element = self.etree.Element 1703 SubElement = self.etree.SubElement 1704 1705 a = Element('a') 1706 b = SubElement(a, 'b') 1707 c = SubElement(a, 'c') 1708 d = SubElement(a, 'd') 1709 e = SubElement(a, 'e') 1710 1711 x = Element('x') 1712 y = Element('y') 1713 1714 a[1::2] = [x, y] 1715 self.assertEquals( 1716 [b, x, d, y], 1717 list(a))

1718

1719 - def test_setslice_step_negative(self):

1720 Element = self.etree.Element 1721 SubElement = self.etree.SubElement 1722 1723 a = Element('a') 1724 b = SubElement(a, 'b') 1725 c = SubElement(a, 'c') 1726 d = SubElement(a, 'd') 1727 e = SubElement(a, 'e') 1728 1729 x = Element('x') 1730 y = Element('y') 1731 1732 a[1::-1] = [x, y] 1733 self.assertEquals( 1734 [y, x, d, e], 1735 list(a))

1736

1737 - def test_setslice_step_negative2(self):

1738 Element = self.etree.Element 1739 SubElement = self.etree.SubElement 1740 1741 a = Element('a') 1742 b = SubElement(a, 'b') 1743 c = SubElement(a, 'c') 1744 d = SubElement(a, 'd') 1745 e = SubElement(a, 'e') 1746 1747 x = Element('x') 1748 y = Element('y') 1749 1750 a[::-2] = [x, y] 1751 self.assertEquals( 1752 [b, y, d, x], 1753 list(a))

1754

1755 - def test_setslice_step_overrun(self):

1756 Element = self.etree.Element 1757 SubElement = self.etree.SubElement 1758 try: 1759 slice 1760 except NameError: 1761 print "slice() not found" 1762 return 1763 1764 a = Element('a') 1765 b = SubElement(a, 'b') 1766 c = SubElement(a, 'c') 1767 d = SubElement(a, 'd') 1768 e = SubElement(a, 'e') 1769 1770 x = Element('x') 1771 y = Element('y') 1772 z = Element('z') 1773 1774 self.assertRaises( 1775 ValueError, 1776 operator.setitem, a, slice(1,None,2), [x, y, z]) 1777 1778 self.assertEquals( 1779 [b, c, d, e], 1780 list(a))

1781

1782 - def test_extend(self):

1783 etree = self.etree 1784 root = etree.Element('foo') 1785 for i in range(3): 1786 element = etree.SubElement(root, 'a%s' % i) 1787 element.text = "text%d" % i 1788 element.tail = "tail%d" % i 1789 1790 elements = [] 1791 for i in range(3): 1792 new_element = etree.Element("test%s" % i) 1793 new_element.text = "TEXT%s" % i 1794 new_element.tail = "TAIL%s" % i 1795 elements.append(new_element) 1796 1797 root.extend(elements) 1798 1799 self.assertEquals( 1800 ["a0", "a1", "a2", "test0", "test1", "test2"], 1801 [ el.tag for el in root ]) 1802 self.assertEquals( 1803 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1804 [ el.text for el in root ]) 1805 self.assertEquals( 1806 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1807 [ el.tail for el in root ])

1808

1809 - def test_sourceline_XML(self):

1810 XML = self.etree.XML 1811 root = XML('''<?xml version="1.0"?> 1812 <root><test> 1813 1814 <bla/></test> 1815 </root> 1816 ''') 1817 1818 self.assertEquals( 1819 [2, 2, 4], 1820 [ el.sourceline for el in root.getiterator() ])

1821

1822 - def test_sourceline_parse(self):

1823 parse = self.etree.parse 1824 tree = parse(fileInTestDir('include/test_xinclude.xml')) 1825 1826 self.assertEquals( 1827 [1, 2, 3], 1828 [ el.sourceline for el in tree.getiterator() ])

1829

1830 - def test_sourceline_iterparse_end(self):

1831 iterparse = self.etree.iterparse 1832 lines = [ el.sourceline for (event, el) in 1833 iterparse(fileInTestDir('include/test_xinclude.xml')) ] 1834 1835 self.assertEquals( 1836 [2, 3, 1], 1837 lines)

1838

1839 - def test_sourceline_iterparse_start(self):

1840 iterparse = self.etree.iterparse 1841 lines = [ el.sourceline for (event, el) in 1842 iterparse(fileInTestDir('include/test_xinclude.xml'), 1843 events=("start",)) ] 1844 1845 self.assertEquals( 1846 [1, 2, 3], 1847 lines)

1848

1849 - def test_sourceline_element(self):

1850 Element = self.etree.Element 1851 SubElement = self.etree.SubElement 1852 el = Element("test") 1853 self.assertEquals(None, el.sourceline) 1854 1855 child = SubElement(el, "test") 1856 self.assertEquals(None, el.sourceline) 1857 self.assertEquals(None, child.sourceline)

1858

1859 - def test_XML_base_url_docinfo(self):

1860 etree = self.etree 1861 root = etree.XML("<root/>", base_url="http://no/such/url") 1862 docinfo = root.getroottree().docinfo 1863 self.assertEquals(docinfo.URL, "http://no/such/url")

1864

1865 - def test_parse_stringio_base_url(self):

1866 etree = self.etree 1867 tree = etree.parse(StringIO("<root/>"), base_url="http://no/such/url") 1868 docinfo = tree.docinfo 1869 self.assertEquals(docinfo.URL, "http://no/such/url")

1870

1871 - def test_parse_base_url_docinfo(self):

1872 etree = self.etree 1873 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 1874 base_url="http://no/such/url") 1875 docinfo = tree.docinfo 1876 self.assertEquals(docinfo.URL, "http://no/such/url")

1877

1878 - def test_HTML_base_url_docinfo(self):

1879 etree = self.etree 1880 root = etree.HTML("<html/>", base_url="http://no/such/url") 1881 docinfo = root.getroottree().docinfo 1882 self.assertEquals(docinfo.URL, "http://no/such/url")

1883

1884 - def test_docinfo_public(self):

1885 etree = self.etree 1886 xml_header = '<?xml version="1.0" encoding="ascii"?>' 1887 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 1888 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 1889 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) 1890 1891 xml = xml_header + doctype_string + '<html><body></body></html>' 1892 1893 tree = etree.parse(StringIO(xml)) 1894 docinfo = tree.docinfo 1895 self.assertEquals(docinfo.encoding, "ascii") 1896 self.assertEquals(docinfo.xml_version, "1.0") 1897 self.assertEquals(docinfo.public_id, pub_id) 1898 self.assertEquals(docinfo.system_url, sys_id) 1899 self.assertEquals(docinfo.root_name, 'html') 1900 self.assertEquals(docinfo.doctype, doctype_string)

1901

1902 - def test_docinfo_system(self):

1903 etree = self.etree 1904 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' 1905 sys_id = "some.dtd" 1906 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id 1907 xml = xml_header + doctype_string + '<html><body></body></html>' 1908 1909 tree = etree.parse(StringIO(xml)) 1910 docinfo = tree.docinfo 1911 self.assertEquals(docinfo.encoding, "UTF-8") 1912 self.assertEquals(docinfo.xml_version, "1.0") 1913 self.assertEquals(docinfo.public_id, None) 1914 self.assertEquals(docinfo.system_url, sys_id) 1915 self.assertEquals(docinfo.root_name, 'html') 1916 self.assertEquals(docinfo.doctype, doctype_string)

1917

1918 - def test_docinfo_empty(self):

1919 etree = self.etree 1920 xml = '<html><body></body></html>' 1921 tree = etree.parse(StringIO(xml)) 1922 docinfo = tree.docinfo 1923 self.assertEquals(docinfo.encoding, "UTF-8") 1924 self.assertEquals(docinfo.xml_version, "1.0") 1925 self.assertEquals(docinfo.public_id, None) 1926 self.assertEquals(docinfo.system_url, None) 1927 self.assertEquals(docinfo.root_name, 'html') 1928 self.assertEquals(docinfo.doctype, '')

1929

1930 - def test_dtd_io(self):

1931 # check that DTDs that go in also go back out 1932 xml = '''\ 1933 <!DOCTYPE test SYSTEM "test.dtd" [ 1934 <!ENTITY entity "tasty"> 1935 <!ELEMENT test (a)> 1936 <!ELEMENT a (#PCDATA)> 1937 ]> 1938 <test><a>test-test</a></test>\ 1939 ''' 1940 tree = self.etree.parse(StringIO(xml)) 1941 self.assertEqual(self.etree.tostring(tree).replace(" ", ""), 1942 xml.replace(" ", ""))

1943

1944 - def test_byte_zero(self):

1945 Element = self.etree.Element 1946 1947 a = Element('a') 1948 self.assertRaises(AssertionError, setattr, a, "text", 'ha\0ho') 1949 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\0ho') 1950 1951 self.assertRaises(AssertionError, Element, 'ha\0ho')

1952

1953 - def test_unicode_byte_zero(self):

1954 Element = self.etree.Element 1955 1956 a = Element('a') 1957 self.assertRaises(AssertionError, setattr, a, "text", u'ha\0ho') 1958 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\0ho') 1959 1960 self.assertRaises(AssertionError, Element, u'ha\0ho')

1961

1962 - def test_byte_invalid(self):

1963 Element = self.etree.Element 1964 1965 a = Element('a') 1966 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x07ho') 1967 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x02ho') 1968 1969 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x07ho') 1970 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x02ho') 1971 1972 self.assertRaises(AssertionError, Element, 'ha\x07ho') 1973 self.assertRaises(AssertionError, Element, 'ha\x02ho')

1974

1975 - def test_unicode_byte_invalid(self):

1976 Element = self.etree.Element 1977 1978 a = Element('a') 1979 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x07ho') 1980 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x02ho') 1981 1982 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x07ho') 1983 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x02ho') 1984 1985 self.assertRaises(AssertionError, Element, u'ha\x07ho') 1986 self.assertRaises(AssertionError, Element, u'ha\x02ho')

1987

1988 - def test_encoding_tostring_utf16(self):

1989 # ElementTree fails to serialize this 1990 tostring = self.etree.tostring 1991 Element = self.etree.Element 1992 SubElement = self.etree.SubElement 1993 1994 a = Element('a') 1995 b = SubElement(a, 'b') 1996 c = SubElement(a, 'c') 1997 1998 result = unicode(tostring(a, encoding='UTF-16'), 'UTF-16') 1999 self.assertEquals('<a><c></c></a>', 2000 canonicalize(result))

2001

2002 - def test_tostring_none(self):

2003 # ElementTree raises an AssertionError here 2004 tostring = self.etree.tostring 2005 self.assertRaises(TypeError, self.etree.tostring, None)

2006

2007 - def test_tostring_pretty(self):

2008 tostring = self.etree.tostring 2009 Element = self.etree.Element 2010 SubElement = self.etree.SubElement 2011 2012 a = Element('a') 2013 b = SubElement(a, 'b') 2014 c = SubElement(a, 'c') 2015 2016 result = tostring(a) 2017 self.assertEquals(result, "<a><c/></a>") 2018 2019 result = tostring(a, pretty_print=False) 2020 self.assertEquals(result, "<a><c/></a>") 2021 2022 result = tostring(a, pretty_print=True) 2023 self.assertEquals(result, "<a>\n \n <c/>\n</a>\n")

2024

2025 - def test_tostring_with_tail(self):

2026 tostring = self.etree.tostring 2027 Element = self.etree.Element 2028 SubElement = self.etree.SubElement 2029 2030 a = Element('a') 2031 a.tail = "aTAIL" 2032 b = SubElement(a, 'b') 2033 b.tail = "bTAIL" 2034 c = SubElement(a, 'c') 2035 2036 result = tostring(a) 2037 self.assertEquals(result, "<a>bTAIL<c/></a>aTAIL") 2038 2039 result = tostring(a, with_tail=False) 2040 self.assertEquals(result, "<a>bTAIL<c/></a>") 2041 2042 result = tostring(a, with_tail=True) 2043 self.assertEquals(result, "<a>bTAIL<c/></a>aTAIL")

2044

2045 - def test_tostring_method_text_encoding(self):

2046 tostring = self.etree.tostring 2047 Element = self.etree.Element 2048 SubElement = self.etree.SubElement 2049 2050 a = Element('a') 2051 a.text = "A" 2052 a.tail = "tail" 2053 b = SubElement(a, 'b') 2054 b.text = "B" 2055 b.tail = u"Søk på nettet" 2056 c = SubElement(a, 'c') 2057 c.text = "C" 2058 2059 result = tostring(a, method="text", encoding="UTF-16") 2060 2061 self.assertEquals(u'ABSøk på nettetCtail'.encode("UTF-16"), 2062 result)

2063

2064 - def test_tounicode(self):

2065 tounicode = self.etree.tounicode 2066 Element = self.etree.Element 2067 SubElement = self.etree.SubElement 2068 2069 a = Element('a') 2070 b = SubElement(a, 'b') 2071 c = SubElement(a, 'c') 2072 2073 self.assert_(isinstance(tounicode(a), unicode)) 2074 self.assertEquals('<a><c></c></a>', 2075 canonicalize(tounicode(a)))

2076

2077 - def test_tounicode_element(self):

2078 tounicode = self.etree.tounicode 2079 Element = self.etree.Element 2080 SubElement = self.etree.SubElement 2081 2082 a = Element('a') 2083 b = SubElement(a, 'b') 2084 c = SubElement(a, 'c') 2085 d = SubElement(c, 'd') 2086 self.assert_(isinstance(tounicode(b), unicode)) 2087 self.assert_(isinstance(tounicode(c), unicode)) 2088 self.assertEquals('', 2089 canonicalize(tounicode(b))) 2090 self.assertEquals('<c><d></d></c>', 2091 canonicalize(tounicode(c)))

2092

2093 - def test_tounicode_none(self):

2094 tounicode = self.etree.tounicode 2095 self.assertRaises(TypeError, self.etree.tounicode, None)

2096

2097 - def test_tounicode_element_tail(self):

2098 tounicode = self.etree.tounicode 2099 Element = self.etree.Element 2100 SubElement = self.etree.SubElement 2101 2102 a = Element('a') 2103 b = SubElement(a, 'b') 2104 c = SubElement(a, 'c') 2105 d = SubElement(c, 'd') 2106 b.tail = 'Foo' 2107 2108 self.assert_(isinstance(tounicode(b), unicode)) 2109 self.assert_(tounicode(b) == 'Foo' or 2110 tounicode(b) == 'Foo')

2111

2112 - def test_tounicode_pretty(self):

2113 tounicode = self.etree.tounicode 2114 Element = self.etree.Element 2115 SubElement = self.etree.SubElement 2116 2117 a = Element('a') 2118 b = SubElement(a, 'b') 2119 c = SubElement(a, 'c') 2120 2121 result = tounicode(a) 2122 self.assertEquals(result, "<a><c/></a>") 2123 2124 result = tounicode(a, pretty_print=False) 2125 self.assertEquals(result, "<a><c/></a>") 2126 2127 result = tounicode(a, pretty_print=True) 2128 self.assertEquals(result, "<a>\n \n <c/>\n</a>\n")

2129

2130 - def test_tostring_unicode(self):

2131 tostring = self.etree.tostring 2132 Element = self.etree.Element 2133 SubElement = self.etree.SubElement 2134 2135 a = Element('a') 2136 b = SubElement(a, 'b') 2137 c = SubElement(a, 'c') 2138 2139 self.assert_(isinstance(tostring(a, encoding=unicode), unicode)) 2140 self.assertEquals('<a><c></c></a>', 2141 canonicalize(tostring(a, encoding=unicode)))

2142

2143 - def test_tostring_unicode_element(self):

2144 tostring = self.etree.tostring 2145 Element = self.etree.Element 2146 SubElement = self.etree.SubElement 2147 2148 a = Element('a') 2149 b = SubElement(a, 'b') 2150 c = SubElement(a, 'c') 2151 d = SubElement(c, 'd') 2152 self.assert_(isinstance(tostring(b, encoding=unicode), unicode)) 2153 self.assert_(isinstance(tostring(c, encoding=unicode), unicode)) 2154 self.assertEquals('', 2155 canonicalize(tostring(b, encoding=unicode))) 2156 self.assertEquals('<c><d></d></c>', 2157 canonicalize(tostring(c, encoding=unicode)))

2158

2159 - def test_tostring_unicode_none(self):

2160 tostring = self.etree.tostring 2161 self.assertRaises(TypeError, self.etree.tostring, 2162 None, encoding=unicode)

2163

2164 - def test_tostring_unicode_element_tail(self):

2165 tostring = self.etree.tostring 2166 Element = self.etree.Element 2167 SubElement = self.etree.SubElement 2168 2169 a = Element('a') 2170 b = SubElement(a, 'b') 2171 c = SubElement(a, 'c') 2172 d = SubElement(c, 'd') 2173 b.tail = 'Foo' 2174 2175 self.assert_(isinstance(tostring(b, encoding=unicode), unicode)) 2176 self.assert_(tostring(b, encoding=unicode) == 'Foo' or 2177 tostring(b, encoding=unicode) == 'Foo')

2178

2179 - def test_tostring_unicode_pretty(self):

2180 tostring = self.etree.tostring 2181 Element = self.etree.Element 2182 SubElement = self.etree.SubElement 2183 2184 a = Element('a') 2185 b = SubElement(a, 'b') 2186 c = SubElement(a, 'c') 2187 2188 result = tostring(a, encoding=unicode) 2189 self.assertEquals(result, "<a><c/></a>") 2190 2191 result = tostring(a, encoding=unicode, pretty_print=False) 2192 self.assertEquals(result, "<a><c/></a>") 2193 2194 result = tostring(a, encoding=unicode, pretty_print=True) 2195 self.assertEquals(result, "<a>\n \n <c/>\n</a>\n")

2196 2197 # helper methods 2198

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

2200 """Write out element for comparison. 2201 """ 2202 ElementTree = self.etree.ElementTree 2203 f = StringIO() 2204 tree = ElementTree(element=element) 2205 tree.write(f, encoding=encoding) 2206 data = f.getvalue() 2207 return canonicalize(data)

2208 2209

2210 -class XIncludeTestCase(HelperTestCase):

2211 - def test_xinclude_text(self):

2212 filename = fileInTestDir('test_broken.xml') 2213 root = etree.XML('''\ 2214 <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 2215 <xi:include href="%s" parse="text"/> 2216 </doc> 2217 ''' % filename) 2218 old_text = root.text 2219 content = open(filename).read() 2220 old_tail = root[0].tail 2221 2222 self.include( etree.ElementTree(root) ) 2223 self.assertEquals(old_text + content + old_tail, 2224 root.text)

2225

2226 - def test_xinclude(self):

2227 tree = etree.parse(fileInTestDir('include/test_xinclude.xml')) 2228 self.assertNotEquals( 2229 'a', 2230 tree.getroot()[1].tag) 2231 # process xincludes 2232 self.include( tree ) 2233 # check whether we find it replaced with included data 2234 self.assertEquals( 2235 'a', 2236 tree.getroot()[1].tag)

2237

2238 -class ETreeXIncludeTestCase(XIncludeTestCase):

2239 - def include(self, tree):

2240 tree.xinclude()

2241 2242

2243 -class ElementIncludeTestCase(XIncludeTestCase):

2244 from lxml import ElementInclude

2245 - def include(self, tree):

2246 self.ElementInclude.include(tree.getroot())

2247 2248

2249 -class ETreeC14NTestCase(HelperTestCase):

2250 - def test_c14n(self):

2251 tree = self.parse('<a></a>') 2252 f = StringIO() 2253 tree.write_c14n(f) 2254 s = f.getvalue() 2255 self.assertEquals('<a></a>', 2256 s)

2257

2258 -def test_suite():

2259 suite = unittest.TestSuite() 2260 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)]) 2261 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)]) 2262 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)]) 2263 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)]) 2264 suite.addTests( 2265 [doctest.DocFileSuite('../../../doc/tutorial.txt')]) 2266 suite.addTests( 2267 [doctest.DocFileSuite('../../../doc/api.txt')]) 2268 suite.addTests( 2269 [doctest.DocFileSuite('../../../doc/parsing.txt')]) 2270 suite.addTests( 2271 [doctest.DocFileSuite('../../../doc/resolvers.txt')]) 2272 return suite

2273 2274 if __name__ == '__main__': 2275 print 'to test use test.py %s' % __file__ 2276

Source Code for Module lxml.tests.test_etree