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