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