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