Package lxml :: Package tests :: Module test_etree
[hide private]
[frames] | no frames]

Source Code for Module lxml.tests.test_etree

   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 
  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 self.assert_(hasattr(self.etree, '_import_c_api'))
52
53 - def test_element_names(self):
54 Element = self.etree.Element 55 el = Element('name') 56 self.assertEquals(el.tag, 'name') 57 el = Element('{}name') 58 self.assertEquals(el.tag, 'name')
59
60 - def test_element_name_empty(self):
61 Element = self.etree.Element 62 el = Element('name') 63 self.assertRaises(ValueError, Element, '{}') 64 self.assertRaises(ValueError, setattr, el, 'tag', '{}') 65 66 self.assertRaises(ValueError, Element, '{test}') 67 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')
68
69 - def test_element_name_colon(self):
70 Element = self.etree.Element 71 self.assertRaises(ValueError, Element, 'p:name') 72 self.assertRaises(ValueError, Element, '{test}p:name') 73 74 el = Element('name') 75 self.assertRaises(ValueError, setattr, el, 'tag', 'p:name')
76
77 - def test_element_name_quote(self):
78 Element = self.etree.Element 79 self.assertRaises(ValueError, Element, "p'name") 80 self.assertRaises(ValueError, Element, 'p"name') 81 82 self.assertRaises(ValueError, Element, "{test}p'name") 83 self.assertRaises(ValueError, Element, '{test}p"name') 84 85 el = Element('name') 86 self.assertRaises(ValueError, setattr, el, 'tag', "p'name") 87 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')
88
89 - def test_element_name_space(self):
90 Element = self.etree.Element 91 self.assertRaises(ValueError, Element, ' name ') 92 self.assertRaises(ValueError, Element, 'na me') 93 self.assertRaises(ValueError, Element, '{test} name') 94 95 el = Element('name') 96 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
97
99 Element = self.etree.Element 100 SubElement = self.etree.SubElement 101 102 el = Element('name') 103 self.assertRaises(ValueError, SubElement, el, '{}') 104 self.assertRaises(ValueError, SubElement, el, '{test}')
105
106 - def test_subelement_name_colon(self):
107 Element = self.etree.Element 108 SubElement = self.etree.SubElement 109 110 el = Element('name') 111 self.assertRaises(ValueError, SubElement, el, 'p:name') 112 self.assertRaises(ValueError, SubElement, el, '{test}p:name')
113
114 - def test_subelement_name_quote(self):
115 Element = self.etree.Element 116 SubElement = self.etree.SubElement 117 118 el = Element('name') 119 self.assertRaises(ValueError, SubElement, el, "p'name") 120 self.assertRaises(ValueError, SubElement, el, "{test}p'name") 121 122 self.assertRaises(ValueError, SubElement, el, 'p"name') 123 self.assertRaises(ValueError, SubElement, el, '{test}p"name')
124
125 - def test_subelement_name_space(self):
126 Element = self.etree.Element 127 SubElement = self.etree.SubElement 128 129 el = Element('name') 130 self.assertRaises(ValueError, SubElement, el, ' name ') 131 self.assertRaises(ValueError, SubElement, el, 'na me') 132 self.assertRaises(ValueError, SubElement, el, '{test} name')
133
134 - def test_qname_empty(self):
135 QName = self.etree.QName 136 self.assertRaises(ValueError, QName, '') 137 self.assertRaises(ValueError, QName, 'test', '')
138
139 - def test_qname_colon(self):
140 QName = self.etree.QName 141 self.assertRaises(ValueError, QName, 'p:name') 142 self.assertRaises(ValueError, QName, 'test', 'p:name')
143
144 - def test_qname_space(self):
145 QName = self.etree.QName 146 self.assertRaises(ValueError, QName, ' name ') 147 self.assertRaises(ValueError, QName, 'na me') 148 self.assertRaises(ValueError, QName, 'test', ' name')
149
150 - def test_qname_text_resolve(self):
151 # ET doesn't resove QNames as text values 152 etree = self.etree 153 qname = etree.QName('http://myns', 'a') 154 a = etree.Element(qname, nsmap={'p' : 'http://myns'}) 155 a.text = qname 156 157 self.assertEquals("p:a", a.text)
158
159 - def test_attribute_set(self):
160 Element = self.etree.Element 161 root = Element("root") 162 root.set("attr", "TEST") 163 self.assertEquals("TEST", root.get("attr"))
164
165 - def test_attribute_set_invalid(self):
166 # ElementTree accepts arbitrary attribute values 167 # lxml.etree allows only strings 168 Element = self.etree.Element 169 root = Element("root") 170 self.assertRaises(TypeError, root.set, "newattr", 5) 171 self.assertRaises(TypeError, root.set, "newattr", None)
172
173 - def test_attrib_pop(self):
174 ElementTree = self.etree.ElementTree 175 176 f = StringIO('<doc one="One" two="Two"/>') 177 doc = ElementTree(file=f) 178 root = doc.getroot() 179 self.assertEquals('One', root.attrib['one']) 180 self.assertEquals('Two', root.attrib['two']) 181 182 self.assertEquals('One', root.attrib.pop('one')) 183 184 self.assertEquals(None, root.attrib.get('one')) 185 self.assertEquals('Two', root.attrib['two'])
186
187 - def test_attrib_pop_unknown(self):
188 root = self.etree.XML('<doc one="One" two="Two"/>') 189 self.assertRaises(KeyError, root.attrib.pop, 'NONE') 190 191 self.assertEquals('One', root.attrib['one']) 192 self.assertEquals('Two', root.attrib['two'])
193
194 - def test_attrib_pop_default(self):
195 root = self.etree.XML('<doc one="One" two="Two"/>') 196 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
197
199 root = self.etree.XML('<doc/>') 200 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
201
203 root = self.etree.XML('<doc one="One" two="Two"/>') 204 self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)
205
206 - def test_pi(self):
207 # lxml.etree separates target and text 208 Element = self.etree.Element 209 SubElement = self.etree.SubElement 210 ProcessingInstruction = self.etree.ProcessingInstruction 211 212 a = Element('a') 213 a.append(ProcessingInstruction('foo', 'some more text')) 214 self.assertEquals(a[0].target, 'foo') 215 self.assertEquals(a[0].text, 'some more text')
216
217 - def test_pi_parse(self):
218 XML = self.etree.XML 219 root = XML("<test><?mypi my test ?></test>") 220 self.assertEquals(root[0].target, "mypi") 221 self.assertEquals(root[0].text, "my test ")
222
223 - def test_deepcopy_pi(self):
224 # previously caused a crash 225 ProcessingInstruction = self.etree.ProcessingInstruction 226 227 a = ProcessingInstruction("PI", "ONE") 228 b = copy.deepcopy(a) 229 b.text = "ANOTHER" 230 231 self.assertEquals('ONE', a.text) 232 self.assertEquals('ANOTHER', b.text)
233
234 - def test_deepcopy_comment(self):
235 # previously caused a crash 236 # not supported by ET! 237 Comment = self.etree.Comment 238 239 a = Comment("ONE") 240 b = copy.deepcopy(a) 241 b.text = "ANOTHER" 242 243 self.assertEquals('ONE', a.text) 244 self.assertEquals('ANOTHER', b.text)
245
246 - def test_attribute_set(self):
247 # ElementTree accepts arbitrary attribute values 248 # lxml.etree allows only strings 249 Element = self.etree.Element 250 251 root = Element("root") 252 root.set("attr", "TEST") 253 self.assertEquals("TEST", root.get("attr")) 254 self.assertRaises(TypeError, root.set, "newattr", 5)
255
256 - def test_parse_error(self):
257 # ET raises ExpatError 258 parse = self.etree.parse 259 # from StringIO 260 f = StringIO('<a><b></c></b></a>') 261 self.assertRaises(SyntaxError, parse, f) 262 f.close()
263
264 - def test_parse_remove_comments(self):
265 parse = self.etree.parse 266 tostring = self.etree.tostring 267 XMLParser = self.etree.XMLParser 268 269 f = StringIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 270 parser = XMLParser(remove_comments=True) 271 tree = parse(f, parser) 272 self.assertEquals( 273 '<a><b><c/></b></a>', 274 tostring(tree))
275
276 - def test_parse_remove_pis(self):
277 parse = self.etree.parse 278 tostring = self.etree.tostring 279 XMLParser = self.etree.XMLParser 280 281 xml = '<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>' 282 283 f = StringIO(xml) 284 tree = parse(f) 285 self.assertEquals( 286 xml, 287 tostring(tree)) 288 289 f = StringIO(xml) 290 parser = XMLParser(remove_pis=True) 291 tree = parse(f, parser) 292 self.assertEquals( 293 '<a><b><c/></b></a>', 294 tostring(tree))
295
297 # ET raises IOError only 298 parse = self.etree.parse 299 self.assertRaises(TypeError, parse, 'notthere.xml', object())
300
301 - def test_parse_error_logging(self):
302 parse = self.etree.parse 303 # from StringIO 304 f = StringIO('<a><b></c></b></a>') 305 self.etree.clearErrorLog() 306 try: 307 parse(f) 308 logs = None 309 except SyntaxError, e: 310 logs = e.error_log 311 f.close() 312 self.assert_([ log for log in logs 313 if 'mismatch' in log.message ]) 314 self.assert_([ log for log in logs 315 if 'PARSER' in log.domain_name]) 316 self.assert_([ log for log in logs 317 if 'TAG_NAME_MISMATCH' in log.type_name ]) 318 self.assert_([ log for log in logs 319 if 1 == log.line ]) 320 self.assert_([ log for log in logs 321 if 15 == log.column ])
322
323 - def test_parse_error_from_file(self):
324 parse = self.etree.parse 325 # from file 326 f = open(fileInTestDir('test_broken.xml'), 'r') 327 self.assertRaises(SyntaxError, parse, f) 328 f.close()
329
330 - def test_iterparse_comments(self):
331 # ET removes comments 332 iterparse = self.etree.iterparse 333 tostring = self.etree.tostring 334 335 f = StringIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 336 events = list(iterparse(f)) 337 root = events[-1][1] 338 self.assertEquals(3, len(events)) 339 self.assertEquals( 340 '<a><!--A--><b><!-- B --><c/></b><!--C--></a>', 341 tostring(root))
342
344 iterparse = self.etree.iterparse 345 tostring = self.etree.tostring 346 347 f = StringIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 348 events = list(iterparse(f, remove_comments=True)) 349 root = events[-1][1] 350 self.assertEquals( 351 '<a><b><c/></b></a>', 352 tostring(root))
353
354 - def test_iterparse_broken(self):
355 iterparse = self.etree.iterparse 356 f = StringIO('<a><b><c/></a>') 357 # ET raises ExpatError, lxml raises XMLSyntaxError 358 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))
359
360 - def test_iterparse_strip(self):
361 iterparse = self.etree.iterparse 362 f = StringIO(""" 363 <a> \n \n <b> b test </b> \n 364 365 \n\t <c> \n </c> </a> \n """) 366 iterator = iterparse(f, remove_blank_text=True) 367 text = [ (element.text, element.tail) 368 for event, element in iterator ] 369 self.assertEquals( 370 [(" b test ", None), (" \n ", None), (None, None)], 371 text)
372
373 - def test_iterparse_tag(self):
374 iterparse = self.etree.iterparse 375 f = StringIO('<a><b><d/></b><c/></a>') 376 377 iterator = iterparse(f, tag="b", events=('start', 'end')) 378 events = list(iterator) 379 root = iterator.root 380 self.assertEquals( 381 [('start', root[0]), ('end', root[0])], 382 events)
383
384 - def test_iterparse_tag_all(self):
385 iterparse = self.etree.iterparse 386 f = StringIO('<a><b><d/></b><c/></a>') 387 388 iterator = iterparse(f, tag="*", events=('start', 'end')) 389 events = list(iterator) 390 self.assertEquals( 391 8, 392 len(events))
393
395 text = u'Søk på nettet' 396 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 397 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text) 398 ).encode('iso-8859-1') 399 400 self.assertRaises(self.etree.ParseError, 401 list, self.etree.iterparse(StringIO(xml_latin1))) 402 403 iterator = self.etree.iterparse(StringIO(xml_latin1), 404 encoding="iso-8859-1") 405 self.assertEquals(1, len(list(iterator))) 406 407 a = iterator.root 408 self.assertEquals(a.text, text)
409
411 self.assertRaises( 412 LookupError, self.etree.XMLParser, encoding="hopefully unknown")
413
414 - def test_iterwalk_tag(self):
415 iterwalk = self.etree.iterwalk 416 root = self.etree.XML('<a><b><d/></b><c/></a>') 417 418 iterator = iterwalk(root, tag="b", events=('start', 'end')) 419 events = list(iterator) 420 self.assertEquals( 421 [('start', root[0]), ('end', root[0])], 422 events)
423
424 - def test_iterwalk_tag_all(self):
425 iterwalk = self.etree.iterwalk 426 root = self.etree.XML('<a><b><d/></b><c/></a>') 427 428 iterator = iterwalk(root, tag="*", events=('start', 'end')) 429 events = list(iterator) 430 self.assertEquals( 431 8, 432 len(events))
433
434 - def test_iterwalk(self):
435 iterwalk = self.etree.iterwalk 436 root = self.etree.XML('<a><b></b><c/></a>') 437 438 events = list(iterwalk(root)) 439 self.assertEquals( 440 [('end', root[0]), ('end', root[1]), ('end', root)], 441 events)
442
443 - def test_iterwalk_start(self):
444 iterwalk = self.etree.iterwalk 445 root = self.etree.XML('<a><b></b><c/></a>') 446 447 iterator = iterwalk(root, events=('start',)) 448 events = list(iterator) 449 self.assertEquals( 450 [('start', root), ('start', root[0]), ('start', root[1])], 451 events)
452
453 - def test_iterwalk_start_end(self):
454 iterwalk = self.etree.iterwalk 455 root = self.etree.XML('<a><b></b><c/></a>') 456 457 iterator = iterwalk(root, events=('start','end')) 458 events = list(iterator) 459 self.assertEquals( 460 [('start', root), ('start', root[0]), ('end', root[0]), 461 ('start', root[1]), ('end', root[1]), ('end', root)], 462 events)
463
464 - def test_iterwalk_clear(self):
465 iterwalk = self.etree.iterwalk 466 root = self.etree.XML('<a><b></b><c/></a>') 467 468 iterator = iterwalk(root) 469 for event, elem in iterator: 470 elem.clear() 471 472 self.assertEquals(0, 473 len(root))
474
475 - def test_iterwalk_attrib_ns(self):
476 iterwalk = self.etree.iterwalk 477 root = self.etree.XML('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>') 478 479 attr_name = '{testns}bla' 480 events = [] 481 iterator = iterwalk(root, events=('start','end','start-ns','end-ns')) 482 for event, elem in iterator: 483 events.append(event) 484 if event == 'start': 485 if elem.tag != '{ns1}a': 486 elem.set(attr_name, 'value') 487 488 self.assertEquals( 489 ['start-ns', 'start', 'start', 'start-ns', 'start', 490 'end', 'end-ns', 'end', 'end', 'end-ns'], 491 events) 492 493 self.assertEquals( 494 None, 495 root.get(attr_name)) 496 self.assertEquals( 497 'value', 498 root[0].get(attr_name))
499
500 - def test_iterwalk_getiterator(self):
501 iterwalk = self.etree.iterwalk 502 root = self.etree.XML('<a><b><d/></b><c/></a>') 503 504 counts = [] 505 for event, elem in iterwalk(root): 506 counts.append(len(list(elem.getiterator()))) 507 self.assertEquals( 508 [1,2,1,4], 509 counts)
510
511 - def test_resolve_string_dtd(self):
512 parse = self.etree.parse 513 parser = self.etree.XMLParser(dtd_validation=True) 514 assertEqual = self.assertEqual 515 test_url = u"__nosuch.dtd" 516 517 class MyResolver(self.etree.Resolver): 518 def resolve(self, url, id, context): 519 assertEqual(url, test_url) 520 return self.resolve_string( 521 u'''<!ENTITY myentity "%s"> 522 <!ELEMENT doc ANY>''' % url, context)
523 524 parser.resolvers.add(MyResolver()) 525 526 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url 527 tree = parse(StringIO(xml), parser) 528 root = tree.getroot() 529 self.assertEquals(root.text, test_url) 530
531 - def test_resolve_empty(self):
532 parse = self.etree.parse 533 parser = self.etree.XMLParser(load_dtd=True) 534 assertEqual = self.assertEqual 535 test_url = u"__nosuch.dtd" 536 537 class check(object): 538 resolved = False
539 540 class MyResolver(self.etree.Resolver): 541 def resolve(self, url, id, context): 542 assertEqual(url, test_url) 543 check.resolved = True 544 return self.resolve_empty(context) 545 546 parser.resolvers.add(MyResolver()) 547 548 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url 549 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser) 550 self.assert_(check.resolved) 551
552 - def test_resolve_error(self):
553 parse = self.etree.parse 554 parser = self.etree.XMLParser(dtd_validation=True) 555 test_url = u"__nosuch.dtd" 556 557 class _LocalException(Exception): 558 pass
559 560 class MyResolver(self.etree.Resolver): 561 def resolve(self, url, id, context): 562 raise _LocalException 563 564 parser.resolvers.add(MyResolver()) 565 566 xml = u'<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 567 self.assertRaises(_LocalException, parse, StringIO(xml), parser) 568 569 if etree.LIBXML_VERSION > (2,6,20):
570 - def test_entity_parse(self):
571 parse = self.etree.parse 572 tostring = self.etree.tostring 573 parser = self.etree.XMLParser(resolve_entities=False) 574 Entity = self.etree.Entity 575 576 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 577 tree = parse(StringIO(xml), parser) 578 root = tree.getroot() 579 self.assertEquals(root[0].tag, Entity) 580 self.assertFalse(root[0].text) 581 self.assertEquals(root[0].tail, None) 582 self.assertEquals(root[0].name, "myentity") 583 584 self.assertEquals('<doc>&myentity;</doc>', 585 tostring(root))
586
587 - def test_entity_append(self):
588 Entity = self.etree.Entity 589 Element = self.etree.Element 590 tostring = self.etree.tostring 591 592 root = Element("root") 593 root.append( Entity("test") ) 594 595 self.assertEquals(root[0].tag, Entity) 596 self.assertFalse(root[0].text) 597 self.assertEquals(root[0].tail, None) 598 self.assertEquals(root[0].name, "test") 599 600 self.assertEquals('<root>&test;</root>', 601 tostring(root))
602 603 # TypeError in etree, AssertionError in ElementTree;
604 - def test_setitem_assert(self):
605 Element = self.etree.Element 606 SubElement = self.etree.SubElement 607 608 a = Element('a') 609 b = SubElement(a, 'b') 610 611 self.assertRaises(TypeError, 612 a.__setitem__, 0, 'foo')
613
614 - def test_append_None(self):
615 # raises AssertionError in ElementTree 616 Element = self.etree.Element 617 self.assertRaises(TypeError, Element('a').append, None)
618
619 - def test_addnext(self):
620 Element = self.etree.Element 621 SubElement = self.etree.SubElement 622 root = Element('root') 623 SubElement(root, 'a') 624 SubElement(root, 'b') 625 626 self.assertEquals(['a', 'b'], 627 [c.tag for c in root]) 628 root[1].addnext(root[0]) 629 self.assertEquals(['b', 'a'], 630 [c.tag for c in root])
631
632 - def test_addprevious(self):
633 Element = self.etree.Element 634 SubElement = self.etree.SubElement 635 root = Element('root') 636 SubElement(root, 'a') 637 SubElement(root, 'b') 638 639 self.assertEquals(['a', 'b'], 640 [c.tag for c in root]) 641 root[0].addprevious(root[1]) 642 self.assertEquals(['b', 'a'], 643 [c.tag for c in root])
644
645 - def test_addnext_root(self):
646 Element = self.etree.Element 647 a = Element('a') 648 b = Element('b') 649 self.assertRaises(TypeError, a.addnext, b)
650
651 - def test_addnext_root(self):
652 Element = self.etree.Element 653 a = Element('a') 654 b = Element('b') 655 self.assertRaises(TypeError, a.addnext, b)
656
657 - def test_addprevious_pi(self):
658 Element = self.etree.Element 659 SubElement = self.etree.SubElement 660 PI = self.etree.PI 661 root = Element('root') 662 SubElement(root, 'a') 663 pi = PI('TARGET', 'TEXT') 664 pi.tail = "TAIL" 665 666 self.assertEquals('<root><a></a></root>', 667 self._writeElement(root)) 668 root[0].addprevious(pi) 669 self.assertEquals('<root><?TARGET TEXT?>TAIL<a></a></root>', 670 self._writeElement(root))
671
672 - def test_addprevious_root_pi(self):
673 Element = self.etree.Element 674 PI = self.etree.PI 675 root = Element('root') 676 pi = PI('TARGET', 'TEXT') 677 pi.tail = "TAIL" 678 679 self.assertEquals('<root></root>', 680 self._writeElement(root)) 681 root.addprevious(pi) 682 self.assertEquals('<?TARGET TEXT?>\n<root></root>', 683 self._writeElement(root))
684
685 - def test_addnext_pi(self):
686 Element = self.etree.Element 687 SubElement = self.etree.SubElement 688 PI = self.etree.PI 689 root = Element('root') 690 SubElement(root, 'a') 691 pi = PI('TARGET', 'TEXT') 692 pi.tail = "TAIL" 693 694 self.assertEquals('<root><a></a></root>', 695 self._writeElement(root)) 696 root[0].addnext(pi) 697 self.assertEquals('<root><a></a><?TARGET TEXT?>TAIL</root>', 698 self._writeElement(root))
699
700 - def test_addnext_root_pi(self):
701 Element = self.etree.Element 702 PI = self.etree.PI 703 root = Element('root') 704 pi = PI('TARGET', 'TEXT') 705 pi.tail = "TAIL" 706 707 self.assertEquals('<root></root>', 708 self._writeElement(root)) 709 root.addnext(pi) 710 self.assertEquals('<root></root>\n<?TARGET TEXT?>', 711 self._writeElement(root))
712
713 - def test_addnext_comment(self):
714 Element = self.etree.Element 715 SubElement = self.etree.SubElement 716 Comment = self.etree.Comment 717 root = Element('root') 718 SubElement(root, 'a') 719 comment = Comment('TEXT ') 720 comment.tail = "TAIL" 721 722 self.assertEquals('<root><a></a></root>', 723 self._writeElement(root)) 724 root[0].addnext(comment) 725 self.assertEquals('<root><a></a><!--TEXT -->TAIL</root>', 726 self._writeElement(root))
727
728 - def test_addnext_root_comment(self):
729 Element = self.etree.Element 730 Comment = self.etree.Comment 731 root = Element('root') 732 comment = Comment('TEXT ') 733 comment.tail = "TAIL" 734 735 self.assertEquals('<root></root>', 736 self._writeElement(root)) 737 root.addnext(comment) 738 self.assertEquals('<root></root>\n<!--TEXT -->', 739 self._writeElement(root))
740
741 - def test_addprevious_comment(self):
742 Element = self.etree.Element 743 SubElement = self.etree.SubElement 744 Comment = self.etree.Comment 745 root = Element('root') 746 SubElement(root, 'a') 747 comment = Comment('TEXT ') 748 comment.tail = "TAIL" 749 750 self.assertEquals('<root><a></a></root>', 751 self._writeElement(root)) 752 root[0].addprevious(comment) 753 self.assertEquals('<root><!--TEXT -->TAIL<a></a></root>', 754 self._writeElement(root))
755
756 - def test_addprevious_root_comment(self):
757 Element = self.etree.Element 758 Comment = self.etree.Comment 759 root = Element('root') 760 comment = Comment('TEXT ') 761 comment.tail = "TAIL" 762 763 self.assertEquals('<root></root>', 764 self._writeElement(root)) 765 root.addprevious(comment) 766 self.assertEquals('<!--TEXT -->\n<root></root>', 767 self._writeElement(root))
768 769 # ET's Elements have items() and key(), but not values()
770 - def test_attribute_values(self):
771 XML = self.etree.XML 772 773 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>') 774 values = root.values() 775 values.sort() 776 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
777 778 # gives error in ElementTree
779 - def test_comment_empty(self):
780 Element = self.etree.Element 781 Comment = self.etree.Comment 782 783 a = Element('a') 784 a.append(Comment()) 785 self.assertEquals( 786 '<a><!----></a>', 787 self._writeElement(a))
788 789 # ElementTree ignores comments
790 - def test_comment_parse_empty(self):
791 ElementTree = self.etree.ElementTree 792 tostring = self.etree.tostring 793 794 xml = '<a><b/><!----><c/></a>' 795 f = StringIO(xml) 796 doc = ElementTree(file=f) 797 a = doc.getroot() 798 self.assertEquals( 799 '', 800 a[1].text) 801 self.assertEquals( 802 xml, 803 tostring(a))
804 805 # ElementTree ignores comments
806 - def test_comment_no_proxy_yet(self):
807 ElementTree = self.etree.ElementTree 808 809 f = StringIO('<a><b></b><!-- hoi --><c></c></a>') 810 doc = ElementTree(file=f) 811 a = doc.getroot() 812 self.assertEquals( 813 ' hoi ', 814 a[1].text)
815 816 # ElementTree adds whitespace around comments
817 - def test_comment_text(self):
818 Element = self.etree.Element 819 Comment = self.etree.Comment 820 tostring = self.etree.tostring 821 822 a = Element('a') 823 a.append(Comment('foo')) 824 self.assertEquals( 825 '<a><!--foo--></a>', 826 tostring(a)) 827 828 a[0].text = "TEST" 829 self.assertEquals( 830 '<a><!--TEST--></a>', 831 tostring(a))
832 833 # ElementTree adds whitespace around comments
834 - def test_comment_whitespace(self):
835 Element = self.etree.Element 836 Comment = self.etree.Comment 837 tostring = self.etree.tostring 838 839 a = Element('a') 840 a.append(Comment(' foo ')) 841 self.assertEquals( 842 '<a><!-- foo --></a>', 843 tostring(a))
844 845 # does not raise an exception in ElementTree
846 - def test_comment_immutable(self):
847 Element = self.etree.Element 848 Comment = self.etree.Comment 849 850 c = Comment() 851 el = Element('myel') 852 853 self.assertRaises(TypeError, c.append, el) 854 self.assertRaises(TypeError, c.insert, 0, el) 855 self.assertRaises(TypeError, c.set, "myattr", "test")
856 857 # test weird dictionary interaction leading to segfault previously
858 - def test_weird_dict_interaction(self):
859 root = self.etree.Element('root') 860 add = self.etree.ElementTree(file=StringIO('<foo>Foo</foo>')) 861 root.append(self.etree.Element('baz'))
862 863 # test passing 'None' to dump
864 - def test_dump_none(self):
865 self.assertRaises(TypeError, etree.dump, None)
866
867 - def test_prefix(self):
868 ElementTree = self.etree.ElementTree 869 870 f = StringIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') 871 doc = ElementTree(file=f) 872 a = doc.getroot() 873 self.assertEquals( 874 None, 875 a.prefix) 876 self.assertEquals( 877 'foo', 878 a[0].prefix)
879
880 - def test_prefix_default_ns(self):
881 ElementTree = self.etree.ElementTree 882 883 f = StringIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>') 884 doc = ElementTree(file=f) 885 a = doc.getroot() 886 self.assertEquals( 887 None, 888 a.prefix) 889 self.assertEquals( 890 None, 891 a[0].prefix)
892
893 - def test_getparent(self):
894 Element = self.etree.Element 895 SubElement = self.etree.SubElement 896 897 a = Element('a') 898 b = SubElement(a, 'b') 899 c = SubElement(a, 'c') 900 d = SubElement(b, 'd') 901 self.assertEquals( 902 None, 903 a.getparent()) 904 self.assertEquals( 905 a, 906 b.getparent()) 907 self.assertEquals( 908 b.getparent(), 909 c.getparent()) 910 self.assertEquals( 911 b, 912 d.getparent())
913
914 - def test_iterchildren(self):
915 XML = self.etree.XML 916 917 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 918 result = [] 919 for el in root.iterchildren(): 920 result.append(el.tag) 921 self.assertEquals(['one', 'two', 'three'], result)
922
923 - def test_iterchildren_reversed(self):
924 XML = self.etree.XML 925 926 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>') 927 result = [] 928 for el in root.iterchildren(reversed=True): 929 result.append(el.tag) 930 self.assertEquals(['three', 'two', 'one'], result)
931
932 - def test_iterchildren_tag(self):
933 XML = self.etree.XML 934 935 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>') 936 result = [] 937 for el in root.iterchildren(tag='two'): 938 result.append(el.text) 939 self.assertEquals(['Two', 'Bla'], result)
940
941 - def test_iterchildren_tag_reversed(self):
942 XML = self.etree.XML 943 944 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>') 945 result = [] 946 for el in root.iterchildren(reversed=True, tag='two'): 947 result.append(el.text) 948 self.assertEquals(['Bla', 'Two'], result)
949
950 - def test_iterancestors(self):
951 Element = self.etree.Element 952 SubElement = self.etree.SubElement 953 954 a = Element('a') 955 b = SubElement(a, 'b') 956 c = SubElement(a, 'c') 957 d = SubElement(b, 'd') 958 self.assertEquals( 959 [], 960 list(a.iterancestors())) 961 self.assertEquals( 962 [a], 963 list(b.iterancestors())) 964 self.assertEquals( 965 a, 966 c.iterancestors().next()) 967 self.assertEquals( 968 [b, a], 969 list(d.iterancestors()))
970
971 - def test_iterancestors_tag(self):
972 Element = self.etree.Element 973 SubElement = self.etree.SubElement 974 975 a = Element('a') 976 b = SubElement(a, 'b') 977 c = SubElement(a, 'c') 978 d = SubElement(b, 'd') 979 self.assertEquals( 980 [a], 981 list(d.iterancestors(tag='a')))
982
983 - def test_iterdescendants(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 e = SubElement(c, 'e') 992 993 self.assertEquals( 994 [b, d, c, e], 995 list(a.iterdescendants())) 996 self.assertEquals( 997 [], 998 list(d.iterdescendants()))
999
1000 - def test_iterdescendants_tag(self):
1001 Element = self.etree.Element 1002 SubElement = self.etree.SubElement 1003 1004 a = Element('a') 1005 b = SubElement(a, 'b') 1006 c = SubElement(a, 'c') 1007 d = SubElement(b, 'd') 1008 e = SubElement(c, 'e') 1009 1010 self.assertEquals( 1011 [], 1012 list(a.iterdescendants('a'))) 1013 a2 = SubElement(e, 'a') 1014 self.assertEquals( 1015 [a2], 1016 list(a.iterdescendants('a'))) 1017 self.assertEquals( 1018 [a2], 1019 list(c.iterdescendants('a')))
1020
1021 - def test_getroottree(self):
1022 Element = self.etree.Element 1023 SubElement = self.etree.SubElement 1024 1025 a = Element('a') 1026 b = SubElement(a, 'b') 1027 c = SubElement(a, 'c') 1028 d = SubElement(b, 'd') 1029 self.assertEquals( 1030 a, 1031 a.getroottree().getroot()) 1032 self.assertEquals( 1033 a, 1034 b.getroottree().getroot()) 1035 self.assertEquals( 1036 a, 1037 d.getroottree().getroot())
1038
1039 - def test_getnext(self):
1040 Element = self.etree.Element 1041 SubElement = self.etree.SubElement 1042 1043 a = Element('a') 1044 b = SubElement(a, 'b') 1045 c = SubElement(a, 'c') 1046 self.assertEquals( 1047 None, 1048 a.getnext()) 1049 self.assertEquals( 1050 c, 1051 b.getnext()) 1052 self.assertEquals( 1053 None, 1054 c.getnext())
1055
1056 - def test_getprevious(self):
1057 Element = self.etree.Element 1058 SubElement = self.etree.SubElement 1059 1060 a = Element('a') 1061 b = SubElement(a, 'b') 1062 c = SubElement(a, 'c') 1063 d = SubElement(b, 'd') 1064 self.assertEquals( 1065 None, 1066 a.getprevious()) 1067 self.assertEquals( 1068 b, 1069 c.getprevious()) 1070 self.assertEquals( 1071 None, 1072 b.getprevious())
1073
1074 - def test_itersiblings(self):
1075 Element = self.etree.Element 1076 SubElement = self.etree.SubElement 1077 1078 a = Element('a') 1079 b = SubElement(a, 'b') 1080 c = SubElement(a, 'c') 1081 d = SubElement(b, 'd') 1082 self.assertEquals( 1083 [], 1084 list(a.itersiblings())) 1085 self.assertEquals( 1086 [c], 1087 list(b.itersiblings())) 1088 self.assertEquals( 1089 c, 1090 b.itersiblings().next()) 1091 self.assertEquals( 1092 [], 1093 list(c.itersiblings())) 1094 self.assertEquals( 1095 [b], 1096 list(c.itersiblings(preceding=True))) 1097 self.assertEquals( 1098 [], 1099 list(b.itersiblings(preceding=True)))
1100
1101 - def test_itersiblings_tag(self):
1102 Element = self.etree.Element 1103 SubElement = self.etree.SubElement 1104 1105 a = Element('a') 1106 b = SubElement(a, 'b') 1107 c = SubElement(a, 'c') 1108 d = SubElement(b, 'd') 1109 self.assertEquals( 1110 [], 1111 list(a.itersiblings(tag='XXX'))) 1112 self.assertEquals( 1113 [c], 1114 list(b.itersiblings(tag='c'))) 1115 self.assertEquals( 1116 [b], 1117 list(c.itersiblings(preceding=True, tag='b'))) 1118 self.assertEquals( 1119 [], 1120 list(c.itersiblings(preceding=True, tag='c')))
1121
1122 - def test_parseid(self):
1123 parseid = self.etree.parseid 1124 XML = self.etree.XML 1125 xml_text = ''' 1126 <!DOCTYPE document [ 1127 <!ELEMENT document (h1,p)*> 1128 <!ELEMENT h1 (#PCDATA)> 1129 <!ATTLIST h1 myid ID #REQUIRED> 1130 <!ELEMENT p (#PCDATA)> 1131 <!ATTLIST p someid ID #REQUIRED> 1132 ]> 1133 <document> 1134 <h1 myid="chapter1">...</h1> 1135 <p id="note1" class="note">...</p> 1136 <p>Regular paragraph.</p> 1137 <p xml:id="xmlid">XML:ID paragraph.</p> 1138 <p someid="warn1" class="warning">...</p> 1139 </document> 1140 ''' 1141 1142 tree, dic = parseid(StringIO(xml_text)) 1143 root = tree.getroot() 1144 root2 = XML(xml_text) 1145 self.assertEquals(self._writeElement(root), 1146 self._writeElement(root2)) 1147 expected = { 1148 "chapter1" : root[0], 1149 "xmlid" : root[3], 1150 "warn1" : root[4] 1151 } 1152 self.assert_("chapter1" in dic) 1153 self.assert_("warn1" in dic) 1154 self.assert_("xmlid" in dic) 1155 self._checkIDDict(dic, expected)
1156
1157 - def test_XMLDTDID(self):
1158 XMLDTDID = self.etree.XMLDTDID 1159 XML = self.etree.XML 1160 xml_text = ''' 1161 <!DOCTYPE document [ 1162 <!ELEMENT document (h1,p)*> 1163 <!ELEMENT h1 (#PCDATA)> 1164 <!ATTLIST h1 myid ID #REQUIRED> 1165 <!ELEMENT p (#PCDATA)> 1166 <!ATTLIST p someid ID #REQUIRED> 1167 ]> 1168 <document> 1169 <h1 myid="chapter1">...</h1> 1170 <p id="note1" class="note">...</p> 1171 <p>Regular paragraph.</p> 1172 <p xml:id="xmlid">XML:ID paragraph.</p> 1173 <p someid="warn1" class="warning">...</p> 1174 </document> 1175 ''' 1176 1177 root, dic = XMLDTDID(xml_text) 1178 root2 = XML(xml_text) 1179 self.assertEquals(self._writeElement(root), 1180 self._writeElement(root2)) 1181 expected = { 1182 "chapter1" : root[0], 1183 "xmlid" : root[3], 1184 "warn1" : root[4] 1185 } 1186 self.assert_("chapter1" in dic) 1187 self.assert_("warn1" in dic) 1188 self.assert_("xmlid" in dic) 1189 self._checkIDDict(dic, expected)
1190
1191 - def test_XMLDTDID_empty(self):
1192 XMLDTDID = self.etree.XMLDTDID 1193 XML = self.etree.XML 1194 xml_text = ''' 1195 <document> 1196 <h1 myid="chapter1">...</h1> 1197 <p id="note1" class="note">...</p> 1198 <p>Regular paragraph.</p> 1199 <p someid="warn1" class="warning">...</p> 1200 </document> 1201 ''' 1202 1203 root, dic = XMLDTDID(xml_text) 1204 root2 = XML(xml_text) 1205 self.assertEquals(self._writeElement(root), 1206 self._writeElement(root2)) 1207 expected = {} 1208 self._checkIDDict(dic, expected)
1209
1210 - def _checkIDDict(self, dic, expected):
1211 self.assertEquals(dic, expected) 1212 self.assertEquals(len(dic), 1213 len(expected)) 1214 self.assertEquals(sorted(dic.items()), 1215 sorted(expected.items())) 1216 self.assertEquals(sorted(dic.iteritems()), 1217 sorted(expected.iteritems())) 1218 self.assertEquals(sorted(dic.keys()), 1219 sorted(expected.keys())) 1220 self.assertEquals(sorted(dic.iterkeys()), 1221 sorted(expected.iterkeys())) 1222 self.assertEquals(sorted(dic.values()), 1223 sorted(expected.values())) 1224 self.assertEquals(sorted(dic.itervalues()), 1225 sorted(expected.itervalues()))
1226
1227 - def test_namespaces(self):
1228 etree = self.etree 1229 1230 r = {'foo': 'http://ns.infrae.com/foo'} 1231 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1232 self.assertEquals( 1233 'foo', 1234 e.prefix) 1235 self.assertEquals( 1236 '<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>', 1237 self._writeElement(e))
1238
1239 - def test_namespaces_default(self):
1240 etree = self.etree 1241 1242 r = {None: 'http://ns.infrae.com/foo'} 1243 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1244 self.assertEquals( 1245 None, 1246 e.prefix) 1247 self.assertEquals( 1248 '{http://ns.infrae.com/foo}bar', 1249 e.tag) 1250 self.assertEquals( 1251 '<bar xmlns="http://ns.infrae.com/foo"></bar>', 1252 self._writeElement(e))
1253
1254 - def test_namespaces_default_and_attr(self):
1255 etree = self.etree 1256 1257 r = {None: 'http://ns.infrae.com/foo', 1258 'hoi': 'http://ns.infrae.com/hoi'} 1259 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1260 e.set('{http://ns.infrae.com/hoi}test', 'value') 1261 self.assertEquals( 1262 '<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>', 1263 self._writeElement(e))
1264
1265 - def test_namespaces_elementtree(self):
1266 etree = self.etree 1267 r = {None: 'http://ns.infrae.com/foo', 1268 'hoi': 'http://ns.infrae.com/hoi'} 1269 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) 1270 tree = etree.ElementTree(element=e) 1271 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') 1272 self.assertEquals( 1273 '<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>', 1274 self._writeElement(e))
1275
1276 - def test_namespaces_default_copy_element(self):
1277 etree = self.etree 1278 1279 r = {None: 'http://ns.infrae.com/foo'} 1280 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1281 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1282 1283 e1.append(e2) 1284 1285 self.assertEquals( 1286 None, 1287 e1.prefix) 1288 self.assertEquals( 1289 None, 1290 e1[0].prefix) 1291 self.assertEquals( 1292 '{http://ns.infrae.com/foo}bar', 1293 e1.tag) 1294 self.assertEquals( 1295 '{http://ns.infrae.com/foo}bar', 1296 e1[0].tag)
1297
1298 - def test_namespaces_copy_element(self):
1299 etree = self.etree 1300 1301 r = {None: 'http://ns.infrae.com/BAR'} 1302 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) 1303 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1304 1305 e1.append(e2) 1306 1307 self.assertEquals( 1308 None, 1309 e1.prefix) 1310 self.assertNotEquals( 1311 None, 1312 e2.prefix) 1313 self.assertEquals( 1314 '{http://ns.infrae.com/BAR}bar', 1315 e1.tag) 1316 self.assertEquals( 1317 '{http://ns.infrae.com/foo}bar', 1318 e2.tag)
1319
1320 - def test_namespaces_reuse_after_move(self):
1321 ns_href = "http://a.b.c" 1322 one = self.etree.parse( 1323 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 1324 baz = one.getroot()[0][0] 1325 1326 two = self.etree.parse( 1327 StringIO('<root xmlns:ns="%s"/>' % ns_href)) 1328 two.getroot().append(baz) 1329 del one # make sure the source document is deallocated 1330 1331 self.assertEquals('{%s}baz' % ns_href, baz.tag) 1332 self.assertEquals( 1333 '<root xmlns:ns="%s"><ns:baz/></root>' % ns_href, 1334 self.etree.tostring(two))
1335
1336 - def _test_namespaces_after_serialize(self):
1337 # FIXME: this currently fails - fix serializer.pxi! 1338 parse = self.etree.parse 1339 tostring = self.etree.tostring 1340 1341 ns_href = "http://a.b.c" 1342 one = parse( 1343 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 1344 baz = one.getroot()[0][0] 1345 1346 print tostring(baz) 1347 parsed = parse(StringIO( tostring(baz) )).getroot() 1348 1349 self.assertEquals('{%s}baz' % ns_href, parsed.tag)
1350
1351 - def test_element_nsmap(self):
1352 etree = self.etree 1353 1354 r = {None: 'http://ns.infrae.com/foo', 1355 'hoi': 'http://ns.infrae.com/hoi'} 1356 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1357 self.assertEquals( 1358 r, 1359 e.nsmap)
1360
1361 - def test_subelement_nsmap(self):
1362 etree = self.etree 1363 1364 re = {None: 'http://ns.infrae.com/foo', 1365 'hoi': 'http://ns.infrae.com/hoi'} 1366 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) 1367 1368 rs = {None: 'http://ns.infrae.com/honk', 1369 'top': 'http://ns.infrae.com/top'} 1370 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) 1371 1372 r = re.copy() 1373 r.update(rs) 1374 self.assertEquals( 1375 re, 1376 e.nsmap) 1377 self.assertEquals( 1378 r, 1379 s.nsmap)
1380
1381 - def test_getiterator_filter_namespace(self):
1382 Element = self.etree.Element 1383 SubElement = self.etree.SubElement 1384 1385 a = Element('{a}a') 1386 b = SubElement(a, '{a}b') 1387 c = SubElement(a, '{a}c') 1388 d = SubElement(b, '{b}d') 1389 e = SubElement(c, '{a}e') 1390 f = SubElement(c, '{b}f') 1391 1392 self.assertEquals( 1393 [a], 1394 list(a.getiterator('{a}a'))) 1395 self.assertEquals( 1396 [], 1397 list(a.getiterator('{b}a'))) 1398 self.assertEquals( 1399 [], 1400 list(a.getiterator('a'))) 1401 self.assertEquals( 1402 [f], 1403 list(c.getiterator('{b}*'))) 1404 self.assertEquals( 1405 [d, f], 1406 list(a.getiterator('{b}*')))
1407
1408 - def test_getiterator_filter_entities(self):
1409 Element = self.etree.Element 1410 Entity = self.etree.Entity 1411 SubElement = self.etree.SubElement 1412 1413 a = Element('a') 1414 b = SubElement(a, 'b') 1415 entity_b = Entity("TEST-b") 1416 b.append(entity_b) 1417 1418 self.assertEquals( 1419 [entity_b], 1420 list(a.getiterator(Entity))) 1421 1422 entity_a = Entity("TEST-a") 1423 a.append(entity_a) 1424 1425 self.assertEquals( 1426 [entity_b, entity_a], 1427 list(a.getiterator(Entity))) 1428 1429 self.assertEquals( 1430 [entity_b], 1431 list(b.getiterator(Entity)))
1432
1433 - def test_getiterator_filter_element(self):
1434 Element = self.etree.Element 1435 Comment = self.etree.Comment 1436 PI = self.etree.PI 1437 SubElement = self.etree.SubElement 1438 1439 a = Element('a') 1440 b = SubElement(a, 'b') 1441 a.append(Comment("test")) 1442 a.append(PI("pi", "content")) 1443 c = SubElement(a, 'c') 1444 1445 self.assertEquals( 1446 [a, b, c], 1447 list(a.getiterator(Element)))
1448
1449 - def test_getiterator_filter_all_comment_pi(self):
1450 # ElementTree iterates over everything here 1451 Element = self.etree.Element 1452 Comment = self.etree.Comment 1453 PI = self.etree.PI 1454 SubElement = self.etree.SubElement 1455 1456 a = Element('a') 1457 b = SubElement(a, 'b') 1458 a.append(Comment("test")) 1459 a.append(PI("pi", "content")) 1460 c = SubElement(a, 'c') 1461 1462 self.assertEquals( 1463 [a, b, c], 1464 list(a.getiterator('*')))
1465
1466 - def test_itertext(self):
1467 # ET 1.3+ 1468 XML = self.etree.XML 1469 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>") 1470 1471 text = list(root.itertext()) 1472 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 1473 text)
1474
1475 - def test_itertext_child(self):
1476 # ET 1.3+ 1477 XML = self.etree.XML 1478 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>") 1479 1480 text = list(root[2].itertext()) 1481 self.assertEquals(["CTEXT"], 1482 text)
1483
1484 - def test_findall_ns(self):
1485 XML = self.etree.XML 1486 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 1487 self.assertEquals(len(root.findall(".//{X}b")), 2) 1488 self.assertEquals(len(root.findall(".//{X}*")), 2) 1489 self.assertEquals(len(root.findall(".//b")), 3)
1490
1491 - def test_index(self):
1492 etree = self.etree 1493 e = etree.Element('foo') 1494 for i in range(10): 1495 etree.SubElement(e, 'a%s' % i) 1496 for i in range(10): 1497 self.assertEquals( 1498 i, 1499 e.index(e[i])) 1500 self.assertEquals( 1501 3, e.index(e[3], 3)) 1502 self.assertRaises( 1503 ValueError, e.index, e[3], 4) 1504 self.assertRaises( 1505 ValueError, e.index, e[3], 0, 2) 1506 self.assertRaises( 1507 ValueError, e.index, e[8], 0, -3) 1508 self.assertRaises( 1509 ValueError, e.index, e[8], -5, -3) 1510 self.assertEquals( 1511 8, e.index(e[8], 0, -1)) 1512 self.assertEquals( 1513 8, e.index(e[8], -12, -1)) 1514 self.assertEquals( 1515 0, e.index(e[0], -12, -1))
1516
1517 - def test_replace(self):
1518 etree = self.etree 1519 e = etree.Element('foo') 1520 for i in range(10): 1521 el = etree.SubElement(e, 'a%s' % i) 1522 el.text = "text%d" % i 1523 el.tail = "tail%d" % i 1524 1525 child0 = e[0] 1526 child1 = e[1] 1527 child2 = e[2] 1528 1529 e.replace(e[0], e[1]) 1530 self.assertEquals( 1531 9, len(e)) 1532 self.assertEquals( 1533 child1, e[0]) 1534 self.assertEquals( 1535 child1.text, "text1") 1536 self.assertEquals( 1537 child1.tail, "tail1") 1538 self.assertEquals( 1539 child0.tail, "tail0") 1540 self.assertEquals( 1541 child2, e[1]) 1542 1543 e.replace(e[-1], e[0]) 1544 self.assertEquals( 1545 child1, e[-1]) 1546 self.assertEquals( 1547 child1.text, "text1") 1548 self.assertEquals( 1549 child1.tail, "tail1") 1550 self.assertEquals( 1551 child2, e[0])
1552
1553 - def test_replace_new(self):
1554 etree = self.etree 1555 e = etree.Element('foo') 1556 for i in range(10): 1557 etree.SubElement(e, 'a%s' % i) 1558 1559 new_element = etree.Element("test") 1560 new_element.text = "TESTTEXT" 1561 new_element.tail = "TESTTAIL" 1562 child1 = e[1] 1563 e.replace(e[0], new_element) 1564 self.assertEquals( 1565 new_element, e[0]) 1566 self.assertEquals( 1567 "TESTTEXT", 1568 e[0].text) 1569 self.assertEquals( 1570 "TESTTAIL", 1571 e[0].tail) 1572 self.assertEquals( 1573 child1, e[1])
1574
1575 - def test_extend(self):
1576 etree = self.etree 1577 root = etree.Element('foo') 1578 for i in range(3): 1579 element = etree.SubElement(root, 'a%s' % i) 1580 element.text = "text%d" % i 1581 element.tail = "tail%d" % i 1582 1583 elements = [] 1584 for i in range(3): 1585 new_element = etree.Element("test%s" % i) 1586 new_element.text = "TEXT%s" % i 1587 new_element.tail = "TAIL%s" % i 1588 elements.append(new_element) 1589 1590 root.extend(elements) 1591 1592 self.assertEquals( 1593 ["a0", "a1", "a2", "test0", "test1", "test2"], 1594 [ el.tag for el in root ]) 1595 self.assertEquals( 1596 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 1597 [ el.text for el in root ]) 1598 self.assertEquals( 1599 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 1600 [ el.tail for el in root ])
1601
1602 - def test_sourceline_XML(self):
1603 XML = self.etree.XML 1604 root = XML('''<?xml version="1.0"?> 1605 <root><test> 1606 1607 <bla/></test> 1608 </root> 1609 ''') 1610 1611 self.assertEquals( 1612 [2, 2, 4], 1613 [ el.sourceline for el in root.getiterator() ])
1614
1615 - def test_sourceline_parse(self):
1616 parse = self.etree.parse 1617 tree = parse(fileInTestDir('include/test_xinclude.xml')) 1618 1619 self.assertEquals( 1620 [1, 2, 3], 1621 [ el.sourceline for el in tree.getiterator() ])
1622
1623 - def test_sourceline_iterparse_end(self):
1624 iterparse = self.etree.iterparse 1625 lines = list( 1626 el.sourceline for (event, el) in 1627 iterparse(fileInTestDir('include/test_xinclude.xml'))) 1628 1629 self.assertEquals( 1630 [2, 3, 1], 1631 lines)
1632
1633 - def test_sourceline_iterparse_start(self):
1634 iterparse = self.etree.iterparse 1635 lines = list( 1636 el.sourceline for (event, el) in 1637 iterparse(fileInTestDir('include/test_xinclude.xml'), 1638 events=("start",))) 1639 1640 self.assertEquals( 1641 [1, 2, 3], 1642 lines)
1643
1644 - def test_sourceline_element(self):
1645 Element = self.etree.Element 1646 SubElement = self.etree.SubElement 1647 el = Element("test") 1648 self.assertEquals(None, el.sourceline) 1649 1650 child = SubElement(el, "test") 1651 self.assertEquals(None, el.sourceline) 1652 self.assertEquals(None, child.sourceline)
1653
1654 - def test_XML_base_url_docinfo(self):
1655 etree = self.etree 1656 root = etree.XML("<root/>", base_url="http://no/such/url") 1657 docinfo = root.getroottree().docinfo 1658 self.assertEquals(docinfo.URL, "http://no/such/url")
1659
1660 - def test_HTML_base_url_docinfo(self):
1661 etree = self.etree 1662 root = etree.HTML("<html/>", base_url="http://no/such/url") 1663 docinfo = root.getroottree().docinfo 1664 self.assertEquals(docinfo.URL, "http://no/such/url")
1665
1666 - def test_docinfo_public(self):
1667 etree = self.etree 1668 xml_header = '<?xml version="1.0" encoding="ascii"?>' 1669 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 1670 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 1671 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) 1672 1673 xml = xml_header + doctype_string + '<html><body></body></html>' 1674 1675 tree = etree.parse(StringIO(xml)) 1676 docinfo = tree.docinfo 1677 self.assertEquals(docinfo.encoding, "ascii") 1678 self.assertEquals(docinfo.xml_version, "1.0") 1679 self.assertEquals(docinfo.public_id, pub_id) 1680 self.assertEquals(docinfo.system_url, sys_id) 1681 self.assertEquals(docinfo.root_name, 'html') 1682 self.assertEquals(docinfo.doctype, doctype_string)
1683
1684 - def test_docinfo_system(self):
1685 etree = self.etree 1686 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' 1687 sys_id = "some.dtd" 1688 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id 1689 xml = xml_header + doctype_string + '<html><body></body></html>' 1690 1691 tree = etree.parse(StringIO(xml)) 1692 docinfo = tree.docinfo 1693 self.assertEquals(docinfo.encoding, "UTF-8") 1694 self.assertEquals(docinfo.xml_version, "1.0") 1695 self.assertEquals(docinfo.public_id, None) 1696 self.assertEquals(docinfo.system_url, sys_id) 1697 self.assertEquals(docinfo.root_name, 'html') 1698 self.assertEquals(docinfo.doctype, doctype_string)
1699
1700 - def test_docinfo_empty(self):
1701 etree = self.etree 1702 xml = '<html><body></body></html>' 1703 tree = etree.parse(StringIO(xml)) 1704 docinfo = tree.docinfo 1705 self.assertEquals(docinfo.encoding, None) 1706 self.assertEquals(docinfo.xml_version, "1.0") 1707 self.assertEquals(docinfo.public_id, None) 1708 self.assertEquals(docinfo.system_url, None) 1709 self.assertEquals(docinfo.root_name, 'html') 1710 self.assertEquals(docinfo.doctype, '')
1711
1712 - def test_dtd_io(self):
1713 # check that DTDs that go in also go back out 1714 xml = '''\ 1715 <!DOCTYPE test SYSTEM "test.dtd" [ 1716 <!ENTITY entity "tasty"> 1717 <!ELEMENT test (a)> 1718 <!ELEMENT a (#PCDATA)> 1719 ]> 1720 <test><a>test-test</a></test>\ 1721 ''' 1722 root = self.etree.parse(StringIO(xml)) 1723 self.assertEqual(self.etree.tostring(root).replace(" ", ""), 1724 xml.replace(" ", ""))
1725
1726 - def test_byte_zero(self):
1727 Element = self.etree.Element 1728 1729 a = Element('a') 1730 self.assertRaises(AssertionError, setattr, a, "text", 'ha\0ho') 1731 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\0ho') 1732 1733 self.assertRaises(AssertionError, Element, 'ha\0ho')
1734
1735 - def test_unicode_byte_zero(self):
1736 Element = self.etree.Element 1737 1738 a = Element('a') 1739 self.assertRaises(AssertionError, setattr, a, "text", u'ha\0ho') 1740 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\0ho') 1741 1742 self.assertRaises(AssertionError, Element, u'ha\0ho')
1743
1744 - def test_byte_invalid(self):
1745 Element = self.etree.Element 1746 1747 a = Element('a') 1748 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x07ho') 1749 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x02ho') 1750 1751 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x07ho') 1752 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x02ho') 1753 1754 self.assertRaises(AssertionError, Element, 'ha\x07ho') 1755 self.assertRaises(AssertionError, Element, 'ha\x02ho')
1756
1757 - def test_unicode_byte_invalid(self):
1758 Element = self.etree.Element 1759 1760 a = Element('a') 1761 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x07ho') 1762 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x02ho') 1763 1764 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x07ho') 1765 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x02ho') 1766 1767 self.assertRaises(AssertionError, Element, u'ha\x07ho') 1768 self.assertRaises(AssertionError, Element, u'ha\x02ho')
1769
1770 - def test_encoding_tostring_utf16(self):
1771 # ElementTree fails to serialize this 1772 tostring = self.etree.tostring 1773 Element = self.etree.Element 1774 SubElement = self.etree.SubElement 1775 1776 a = Element('a') 1777 b = SubElement(a, 'b') 1778 c = SubElement(a, 'c') 1779 1780 result = unicode(tostring(a, 'UTF-16'), 'UTF-16') 1781 self.assertEquals('<a><b></b><c></c></a>', 1782 canonicalize(result))
1783
1784 - def test_tostring_none(self):
1785 # ElementTree raises an AssertionError here 1786 tostring = self.etree.tostring 1787 self.assertRaises(TypeError, self.etree.tostring, None)
1788
1789 - def test_tostring_pretty(self):
1790 tostring = self.etree.tostring 1791 Element = self.etree.Element 1792 SubElement = self.etree.SubElement 1793 1794 a = Element('a') 1795 b = SubElement(a, 'b') 1796 c = SubElement(a, 'c') 1797 1798 result = tostring(a) 1799 self.assertEquals(result, "<a><b/><c/></a>") 1800 1801 result = tostring(a, pretty_print=False) 1802 self.assertEquals(result, "<a><b/><c/></a>") 1803 1804 result = tostring(a, pretty_print=True) 1805 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>")
1806
1807 - def test_tostring_method_text_encoding(self):
1808 tostring = self.etree.tostring 1809 Element = self.etree.Element 1810 SubElement = self.etree.SubElement 1811 1812 a = Element('a') 1813 a.text = "A" 1814 a.tail = "tail" 1815 b = SubElement(a, 'b') 1816 b.text = "B" 1817 b.tail = u"Søk på nettet" 1818 c = SubElement(a, 'c') 1819 c.text = "C" 1820 1821 result = tostring(a, method="text", encoding="UTF-16") 1822 1823 self.assertEquals(u'ABSøk på nettetCtail'.encode("UTF-16"), 1824 result)
1825
1826 - def test_tounicode(self):
1827 tounicode = self.etree.tounicode 1828 Element = self.etree.Element 1829 SubElement = self.etree.SubElement 1830 1831 a = Element('a') 1832 b = SubElement(a, 'b') 1833 c = SubElement(a, 'c') 1834 1835 self.assert_(isinstance(tounicode(a), unicode)) 1836 self.assertEquals('<a><b></b><c></c></a>', 1837 canonicalize(tounicode(a)))
1838
1839 - def test_tounicode_element(self):
1840 tounicode = self.etree.tounicode 1841 Element = self.etree.Element 1842 SubElement = self.etree.SubElement 1843 1844 a = Element('a') 1845 b = SubElement(a, 'b') 1846 c = SubElement(a, 'c') 1847 d = SubElement(c, 'd') 1848 self.assert_(isinstance(tounicode(b), unicode)) 1849 self.assert_(isinstance(tounicode(c), unicode)) 1850 self.assertEquals('<b></b>', 1851 canonicalize(tounicode(b))) 1852 self.assertEquals('<c><d></d></c>', 1853 canonicalize(tounicode(c)))
1854
1855 - def test_tounicode_none(self):
1856 tounicode = self.etree.tounicode 1857 self.assertRaises(TypeError, self.etree.tounicode, None)
1858
1859 - def test_tounicode_element_tail(self):
1860 tounicode = self.etree.tounicode 1861 Element = self.etree.Element 1862 SubElement = self.etree.SubElement 1863 1864 a = Element('a') 1865 b = SubElement(a, 'b') 1866 c = SubElement(a, 'c') 1867 d = SubElement(c, 'd') 1868 b.tail = 'Foo' 1869 1870 self.assert_(isinstance(tounicode(b), unicode)) 1871 self.assert_(tounicode(b) == '<b/>Foo' or 1872 tounicode(b) == '<b />Foo')
1873
1874 - def test_tounicode_pretty(self):
1875 tounicode = self.etree.tounicode 1876 Element = self.etree.Element 1877 SubElement = self.etree.SubElement 1878 1879 a = Element('a') 1880 b = SubElement(a, 'b') 1881 c = SubElement(a, 'c') 1882 1883 result = tounicode(a) 1884 self.assertEquals(result, "<a><b/><c/></a>") 1885 1886 result = tounicode(a, pretty_print=False) 1887 self.assertEquals(result, "<a><b/><c/></a>") 1888 1889 result = tounicode(a, pretty_print=True) 1890 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>")
1891
1892 - def _writeElement(self, element, encoding='us-ascii'):
1893 """Write out element for comparison. 1894 """ 1895 ElementTree = self.etree.ElementTree 1896 f = StringIO() 1897 tree = ElementTree(element=element) 1898 tree.write(f, encoding) 1899 data = f.getvalue() 1900 return canonicalize(data)
1901 1902
1903 -class XIncludeTestCase(HelperTestCase):
1904 - def test_xinclude_text(self):
1905 filename = fileInTestDir('test_broken.xml') 1906 root = etree.XML('''\ 1907 <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 1908 <xi:include href="%s" parse="text"/> 1909 </doc> 1910 ''' % filename) 1911 old_text = root.text 1912 content = open(filename).read() 1913 old_tail = root[0].tail 1914 1915 self.include( etree.ElementTree(root) ) 1916 self.assertEquals(old_text + content + old_tail, 1917 root.text)
1918
1919 - def test_xinclude(self):
1920 tree = etree.parse(fileInTestDir('include/test_xinclude.xml')) 1921 self.assertNotEquals( 1922 'a', 1923 tree.getroot()[1].tag) 1924 # process xincludes 1925 self.include( tree ) 1926 # check whether we find it replaced with included data 1927 self.assertEquals( 1928 'a', 1929 tree.getroot()[1].tag)
1930
1931 -class ETreeXIncludeTestCase(XIncludeTestCase):
1932 - def include(self, tree):
1933 tree.xinclude()
1934 1935
1936 -class ElementIncludeTestCase(XIncludeTestCase):
1937 from lxml import ElementInclude
1938 - def include(self, tree):
1939 self.ElementInclude.include(tree.getroot())
1940 1941
1942 -class ETreeC14NTestCase(HelperTestCase):
1943 - def test_c14n(self):
1944 tree = self.parse('<a><b/></a>') 1945 f = StringIO() 1946 tree.write_c14n(f) 1947 s = f.getvalue() 1948 self.assertEquals('<a><b></b></a>', 1949 s)
1950
1951 -def test_suite():
1952 suite = unittest.TestSuite() 1953 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)]) 1954 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)]) 1955 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)]) 1956 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)]) 1957 suite.addTests( 1958 [doctest.DocFileSuite('../../../doc/tutorial.txt')]) 1959 suite.addTests( 1960 [doctest.DocFileSuite('../../../doc/api.txt')]) 1961 suite.addTests( 1962 [doctest.DocFileSuite('../../../doc/parsing.txt')]) 1963 suite.addTests( 1964 [doctest.DocFileSuite('../../../doc/resolvers.txt')]) 1965 return suite
1966 1967 if __name__ == '__main__': 1968 print 'to test use test.py %s' % __file__ 1969