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

Source Code for Module lxml.tests.test_etree

   1  # -*- coding: utf-8 -*- 
   2   
   3  """ 
   4  Tests specific to the extended etree API 
   5   
   6  Tests that apply to the general ElementTree API should go into 
   7  test_elementtree 
   8  """ 
   9   
  10  import os.path 
  11  import unittest 
  12  import copy 
  13  import sys 
  14  import re 
  15  import operator 
  16  import tempfile 
  17  import gzip 
  18   
  19  this_dir = os.path.dirname(__file__) 
  20  if this_dir not in sys.path: 
  21      sys.path.insert(0, this_dir) # needed for Py3 
  22   
  23  from common_imports import etree, StringIO, BytesIO, HelperTestCase, fileInTestDir 
  24  from common_imports import SillyFileLike, LargeFileLikeUnicode, doctest, make_doctest 
  25  from common_imports import canonicalize, sorted, _str, _bytes 
  26   
  27  print("") 
  28  print("TESTED VERSION: %s" % etree.__version__) 
  29  print("    Python:           " + repr(sys.version_info)) 
  30  print("    lxml.etree:       " + repr(etree.LXML_VERSION)) 
  31  print("    libxml used:      " + repr(etree.LIBXML_VERSION)) 
  32  print("    libxml compiled:  " + repr(etree.LIBXML_COMPILED_VERSION)) 
  33  print("    libxslt used:     " + repr(etree.LIBXSLT_VERSION)) 
  34  print("    libxslt compiled: " + repr(etree.LIBXSLT_COMPILED_VERSION)) 
  35  print("") 
  36   
  37  try: 
  38      _unicode = unicode 
  39  except NameError: 
  40      # Python 3 
  41      _unicode = str 
  42   
43 -class ETreeOnlyTestCase(HelperTestCase):
44 """Tests only for etree, not ElementTree""" 45 etree = etree 46
47 - def test_version(self):
48 self.assert_(isinstance(etree.__version__, _unicode)) 49 self.assert_(isinstance(etree.LXML_VERSION, tuple)) 50 self.assertEqual(len(etree.LXML_VERSION), 4) 51 self.assert_(isinstance(etree.LXML_VERSION[0], int)) 52 self.assert_(isinstance(etree.LXML_VERSION[1], int)) 53 self.assert_(isinstance(etree.LXML_VERSION[2], int)) 54 self.assert_(isinstance(etree.LXML_VERSION[3], int)) 55 self.assert_(etree.__version__.startswith( 56 str(etree.LXML_VERSION[0])))
57
58 - def test_c_api(self):
59 if hasattr(self.etree, '__pyx_capi__'): 60 # newer Pyrex compatible C-API 61 self.assert_(isinstance(self.etree.__pyx_capi__, dict)) 62 self.assert_(len(self.etree.__pyx_capi__) > 0) 63 else: 64 # older C-API mechanism 65 self.assert_(hasattr(self.etree, '_import_c_api'))
66
67 - def test_element_names(self):
68 Element = self.etree.Element 69 el = Element('name') 70 self.assertEquals(el.tag, 'name') 71 el = Element('{}name') 72 self.assertEquals(el.tag, 'name')
73
74 - def test_element_name_empty(self):
75 Element = self.etree.Element 76 el = Element('name') 77 self.assertRaises(ValueError, Element, '{}') 78 self.assertRaises(ValueError, setattr, el, 'tag', '{}') 79 80 self.assertRaises(ValueError, Element, '{test}') 81 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')
82
83 - def test_element_name_colon(self):
84 Element = self.etree.Element 85 self.assertRaises(ValueError, Element, 'p:name') 86 self.assertRaises(ValueError, Element, '{test}p:name') 87 88 el = Element('name') 89 self.assertRaises(ValueError, setattr, el, 'tag', 'p:name')
90
91 - def test_element_name_quote(self):
92 Element = self.etree.Element 93 self.assertRaises(ValueError, Element, "p'name") 94 self.assertRaises(ValueError, Element, 'p"name') 95 96 self.assertRaises(ValueError, Element, "{test}p'name") 97 self.assertRaises(ValueError, Element, '{test}p"name') 98 99 el = Element('name') 100 self.assertRaises(ValueError, setattr, el, 'tag', "p'name") 101 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')
102
103 - def test_element_name_space(self):
104 Element = self.etree.Element 105 self.assertRaises(ValueError, Element, ' name ') 106 self.assertRaises(ValueError, Element, 'na me') 107 self.assertRaises(ValueError, Element, '{test} name') 108 109 el = Element('name') 110 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
111
112 - def test_subelement_name_empty(self):
113 Element = self.etree.Element 114 SubElement = self.etree.SubElement 115 116 el = Element('name') 117 self.assertRaises(ValueError, SubElement, el, '{}') 118 self.assertRaises(ValueError, SubElement, el, '{test}')
119
120 - def test_subelement_name_colon(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 - def test_subelement_name_quote(self):
129 Element = self.etree.Element 130 SubElement = self.etree.SubElement 131 132 el = Element('name') 133 self.assertRaises(ValueError, SubElement, el, "p'name") 134 self.assertRaises(ValueError, SubElement, el, "{test}p'name") 135 136 self.assertRaises(ValueError, SubElement, el, 'p"name') 137 self.assertRaises(ValueError, SubElement, el, '{test}p"name')
138
139 - def test_subelement_name_space(self):
140 Element = self.etree.Element 141 SubElement = self.etree.SubElement 142 143 el = Element('name') 144 self.assertRaises(ValueError, SubElement, el, ' name ') 145 self.assertRaises(ValueError, SubElement, el, 'na me') 146 self.assertRaises(ValueError, SubElement, el, '{test} name')
147
149 Element = self.etree.Element 150 SubElement = self.etree.SubElement 151 152 el = Element('name') 153 self.assertRaises(ValueError, SubElement, el, 'name', {'a b c' : 'abc'}) 154 self.assertRaises(ValueError, SubElement, el, 'name', {'a' : 'a\0\n'}) 155 self.assertEquals(0, len(el))
156
157 - def test_qname_empty(self):
158 QName = self.etree.QName 159 self.assertRaises(ValueError, QName, '') 160 self.assertRaises(ValueError, QName, 'test', '')
161
162 - def test_qname_colon(self):
163 QName = self.etree.QName 164 self.assertRaises(ValueError, QName, 'p:name') 165 self.assertRaises(ValueError, QName, 'test', 'p:name')
166
167 - def test_qname_space(self):
168 QName = self.etree.QName 169 self.assertRaises(ValueError, QName, ' name ') 170 self.assertRaises(ValueError, QName, 'na me') 171 self.assertRaises(ValueError, QName, 'test', ' name')
172
174 # ET doesn't have namespace/localname properties on QNames 175 QName = self.etree.QName 176 namespace, localname = 'http://myns', 'a' 177 qname = QName(namespace, localname) 178 self.assertEquals(namespace, qname.namespace) 179 self.assertEquals(localname, qname.localname)
180
181 - def test_qname_element(self):
182 # ET doesn't have namespace/localname properties on QNames 183 QName = self.etree.QName 184 qname1 = QName('http://myns', 'a') 185 a = self.etree.Element(qname1, nsmap={'p' : 'http://myns'}) 186 187 qname2 = QName(a) 188 self.assertEquals(a.tag, qname1.text) 189 self.assertEquals(qname1.text, qname2.text) 190 self.assertEquals(qname1, qname2)
191
192 - def test_qname_text_resolve(self):
193 # ET doesn't resove QNames as text values 194 etree = self.etree 195 qname = etree.QName('http://myns', 'a') 196 a = etree.Element(qname, nsmap={'p' : 'http://myns'}) 197 a.text = qname 198 199 self.assertEquals("p:a", a.text)
200
201 - def test_nsmap_prefix_invalid(self):
202 etree = self.etree 203 self.assertRaises(ValueError, 204 etree.Element, "root", nsmap={'"' : 'testns'}) 205 self.assertRaises(ValueError, 206 etree.Element, "root", nsmap={'&' : 'testns'}) 207 self.assertRaises(ValueError, 208 etree.Element, "root", nsmap={'a:b' : 'testns'})
209
210 - def test_attribute_set(self):
211 Element = self.etree.Element 212 root = Element("root") 213 root.set("attr", "TEST") 214 self.assertEquals("TEST", root.get("attr"))
215
216 - def test_attribute_set_invalid(self):
217 # ElementTree accepts arbitrary attribute values 218 # lxml.etree allows only strings 219 Element = self.etree.Element 220 root = Element("root") 221 self.assertRaises(TypeError, root.set, "newattr", 5) 222 self.assertRaises(TypeError, root.set, "newattr", None)
223
224 - def test_strip_attributes(self):
225 XML = self.etree.XML 226 xml = _bytes('<test a="5" b="10" c="20"><x a="4" b="2"/></test>') 227 228 root = XML(xml) 229 self.etree.strip_attributes(root, 'a') 230 self.assertEquals(_bytes('<test b="10" c="20"><x b="2"></x></test>'), 231 self._writeElement(root)) 232 233 root = XML(xml) 234 self.etree.strip_attributes(root, 'b', 'c') 235 self.assertEquals(_bytes('<test a="5"><x a="4"></x></test>'), 236 self._writeElement(root))
237
238 - def test_strip_attributes_ns(self):
239 XML = self.etree.XML 240 xml = _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20" n:a="5"><x a="4" n:b="2"/></test>') 241 242 root = XML(xml) 243 self.etree.strip_attributes(root, 'a') 244 self.assertEquals( 245 _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'), 246 self._writeElement(root)) 247 248 root = XML(xml) 249 self.etree.strip_attributes(root, '{http://test/ns}a', 'c') 250 self.assertEquals( 251 _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'), 252 self._writeElement(root)) 253 254 root = XML(xml) 255 self.etree.strip_attributes(root, '{http://test/ns}*') 256 self.assertEquals( 257 _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'), 258 self._writeElement(root))
259
260 - def test_strip_elements(self):
261 XML = self.etree.XML 262 xml = _bytes('<test><a><b><c/></b></a><x><a><b/><c/></a></x></test>') 263 264 root = XML(xml) 265 self.etree.strip_elements(root, 'a') 266 self.assertEquals(_bytes('<test><x></x></test>'), 267 self._writeElement(root)) 268 269 root = XML(xml) 270 self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z') 271 self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'), 272 self._writeElement(root)) 273 274 root = XML(xml) 275 self.etree.strip_elements(root, 'c') 276 self.assertEquals(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'), 277 self._writeElement(root))
278
279 - def test_strip_elements_ns(self):
280 XML = self.etree.XML 281 xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"/>C</b>BT</n:a>AT<x>X<a>A<b xmlns="urn:a"/>BT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 282 283 root = XML(xml) 284 self.etree.strip_elements(root, 'a') 285 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X</x>XT</test>'), 286 self._writeElement(root)) 287 288 root = XML(xml) 289 self.etree.strip_elements(root, '{urn:a}b', 'c') 290 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 291 self._writeElement(root)) 292 293 root = XML(xml) 294 self.etree.strip_elements(root, '{urn:a}*', 'c') 295 self.assertEquals(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 296 self._writeElement(root)) 297 298 root = XML(xml) 299 self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False) 300 self.assertEquals(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 301 self._writeElement(root))
302
303 - def test_strip_tags(self):
304 XML = self.etree.XML 305 xml = _bytes('<test>TEST<a>A<b>B<c/>CT</b>BT</a>AT<x>X<a>A<b/>BT<c/>CT</a>AT</x>XT</test>') 306 307 root = XML(xml) 308 self.etree.strip_tags(root, 'a') 309 self.assertEquals(_bytes('<test>TESTA<b>B<c></c>CT</b>BTAT<x>XA<b></b>BT<c></c>CTAT</x>XT</test>'), 310 self._writeElement(root)) 311 312 root = XML(xml) 313 self.etree.strip_tags(root, 'b', 'c', 'X', 'Y', 'Z') 314 self.assertEquals(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'), 315 self._writeElement(root)) 316 317 root = XML(xml) 318 self.etree.strip_tags(root, 'c') 319 self.assertEquals(_bytes('<test>TEST<a>A<b>BCT</b>BT</a>AT<x>X<a>A<b></b>BTCT</a>AT</x>XT</test>'), 320 self._writeElement(root))
321
322 - def test_strip_tags_pi_comment(self):
323 XML = self.etree.XML 324 PI = self.etree.ProcessingInstruction 325 Comment = self.etree.Comment 326 xml = _bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT<?PI2?></test>\n<!--comment3-->\n<?PI1?>') 327 328 root = XML(xml) 329 self.etree.strip_tags(root, PI) 330 self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->\n<?PI1?>'), 331 self._writeElement(root)) 332 333 root = XML(xml) 334 self.etree.strip_tags(root, Comment) 335 self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n<!--comment3-->\n<?PI1?>'), 336 self._writeElement(root)) 337 338 root = XML(xml) 339 self.etree.strip_tags(root, PI, Comment) 340 self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'), 341 self._writeElement(root)) 342 343 root = XML(xml) 344 self.etree.strip_tags(root, Comment, PI) 345 self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'), 346 self._writeElement(root))
347
349 XML = self.etree.XML 350 ElementTree = self.etree.ElementTree 351 PI = self.etree.ProcessingInstruction 352 Comment = self.etree.Comment 353 xml = _bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT<?PI2?></test>\n<!--comment3-->\n<?PI1?>') 354 355 root = XML(xml) 356 self.etree.strip_tags(ElementTree(root), PI) 357 self.assertEquals(_bytes('<!--comment1-->\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->'), 358 self._writeElement(root)) 359 360 root = XML(xml) 361 self.etree.strip_tags(ElementTree(root), Comment) 362 self.assertEquals(_bytes('<?PI1?>\n<test>TESTXT<?PI2?></test>\n<?PI1?>'), 363 self._writeElement(root)) 364 365 root = XML(xml) 366 self.etree.strip_tags(ElementTree(root), PI, Comment) 367 self.assertEquals(_bytes('<test>TESTXT</test>'), 368 self._writeElement(root)) 369 370 root = XML(xml) 371 self.etree.strip_tags(ElementTree(root), Comment, PI) 372 self.assertEquals(_bytes('<test>TESTXT</test>'), 373 self._writeElement(root))
374
375 - def test_strip_tags_doc_style(self):
376 XML = self.etree.XML 377 xml = _bytes(''' 378 <div> 379 <div> 380 I like <strong>sheep</strong>. 381 <br/> 382 I like lots of <strong>sheep</strong>. 383 <br/> 384 Click <a href="http://www.sheep.com">here</a> for <a href="http://www.sheep.com">those</a> sheep. 385 <br/> 386 </div> 387 </div> 388 '''.strip()) 389 390 root = XML(xml) 391 self.etree.strip_tags(root, 'a') 392 self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''), xml).replace(_bytes('<br/>'), _bytes('<br></br>')), 393 self._writeElement(root)) 394 395 root = XML(xml) 396 self.etree.strip_tags(root, 'a', 'br') 397 self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''), 398 re.sub(_bytes('<br[^>]*>'), _bytes(''), xml)), 399 self._writeElement(root))
400
401 - def test_strip_tags_ns(self):
402 XML = self.etree.XML 403 xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"/>CT</b>BT</n:a>AT<x>X<a>A<b xmlns="urn:a"/>BT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 404 405 root = XML(xml) 406 self.etree.strip_tags(root, 'a') 407 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>XA<b xmlns="urn:a"></b>BT<c xmlns="urn:x"></c>CTAT</x>XT</test>'), 408 self._writeElement(root)) 409 410 root = XML(xml) 411 self.etree.strip_tags(root, '{urn:a}b', 'c') 412 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 413 self._writeElement(root)) 414 415 root = XML(xml) 416 self.etree.strip_tags(root, '{urn:a}*', 'c') 417 self.assertEquals(_bytes('<test>TESTA<b>B<c xmlns="urn:c"></c>CT</b>BTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 418 self._writeElement(root))
419
420 - def test_pi(self):
421 # lxml.etree separates target and text 422 Element = self.etree.Element 423 SubElement = self.etree.SubElement 424 ProcessingInstruction = self.etree.ProcessingInstruction 425 426 a = Element('a') 427 a.append(ProcessingInstruction('foo', 'some more text')) 428 self.assertEquals(a[0].target, 'foo') 429 self.assertEquals(a[0].text, 'some more text')
430
431 - def test_pi_parse(self):
432 XML = self.etree.XML 433 root = XML(_bytes("<test><?mypi my test ?></test>")) 434 self.assertEquals(root[0].target, "mypi") 435 self.assertEquals(root[0].text, "my test ")
436
437 - def test_deepcopy_pi(self):
438 # previously caused a crash 439 ProcessingInstruction = self.etree.ProcessingInstruction 440 441 a = ProcessingInstruction("PI", "ONE") 442 b = copy.deepcopy(a) 443 b.text = "ANOTHER" 444 445 self.assertEquals('ONE', a.text) 446 self.assertEquals('ANOTHER', b.text)
447
449 XML = self.etree.XML 450 tostring = self.etree.tostring 451 root = XML(_bytes("<?mypi my test ?><test/><!--comment -->")) 452 tree1 = self.etree.ElementTree(root) 453 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"), 454 tostring(tree1)) 455 456 tree2 = copy.deepcopy(tree1) 457 self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"), 458 tostring(tree2)) 459 460 root2 = copy.deepcopy(tree1.getroot()) 461 self.assertEquals(_bytes("<test/>"), 462 tostring(root2))
463
465 XML = self.etree.XML 466 tostring = self.etree.tostring 467 xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>') 468 root = XML(xml) 469 tree1 = self.etree.ElementTree(root) 470 self.assertEquals(xml, tostring(tree1)) 471 472 tree2 = copy.deepcopy(tree1) 473 self.assertEquals(xml, tostring(tree2)) 474 475 root2 = copy.deepcopy(tree1.getroot()) 476 self.assertEquals(_bytes("<test/>"), 477 tostring(root2))
478
479 - def test_attribute_set(self):
480 # ElementTree accepts arbitrary attribute values 481 # lxml.etree allows only strings 482 Element = self.etree.Element 483 484 root = Element("root") 485 root.set("attr", "TEST") 486 self.assertEquals("TEST", root.get("attr")) 487 self.assertRaises(TypeError, root.set, "newattr", 5)
488
489 - def test_parse_remove_comments(self):
490 fromstring = self.etree.fromstring 491 tostring = self.etree.tostring 492 XMLParser = self.etree.XMLParser 493 494 xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 495 parser = XMLParser(remove_comments=True) 496 root = fromstring(xml, parser) 497 self.assertEquals( 498 _bytes('<a><b><c/></b></a>'), 499 tostring(root))
500
501 - def test_parse_remove_pis(self):
502 parse = self.etree.parse 503 tostring = self.etree.tostring 504 XMLParser = self.etree.XMLParser 505 506 xml = _bytes('<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>') 507 508 f = BytesIO(xml) 509 tree = parse(f) 510 self.assertEquals( 511 xml, 512 tostring(tree)) 513 514 parser = XMLParser(remove_pis=True) 515 tree = parse(f, parser) 516 self.assertEquals( 517 _bytes('<a><b><c/></b></a>'), 518 tostring(tree))
519
521 # ET raises IOError only 522 parse = self.etree.parse 523 self.assertRaises(TypeError, parse, 'notthere.xml', object())
524
526 # ET removes comments 527 iterparse = self.etree.iterparse 528 tostring = self.etree.tostring 529 530 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 531 events = list(iterparse(f)) 532 root = events[-1][1] 533 self.assertEquals(3, len(events)) 534 self.assertEquals( 535 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'), 536 tostring(root))
537
538 - def test_iterparse_comments(self):
539 # ET removes comments 540 iterparse = self.etree.iterparse 541 tostring = self.etree.tostring 542 543 def name(event, el): 544 if event == 'comment': 545 return el.text 546 else: 547 return el.tag
548 549 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 550 events = list(iterparse(f, events=('end', 'comment'))) 551 root = events[-1][1] 552 self.assertEquals(6, len(events)) 553 self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'], 554 [ name(*item) for item in events ]) 555 self.assertEquals( 556 _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'), 557 tostring(root))
558
559 - def test_iterparse_pis(self):
560 # ET removes pis 561 iterparse = self.etree.iterparse 562 tostring = self.etree.tostring 563 ElementTree = self.etree.ElementTree 564 565 def name(event, el): 566 if event == 'pi': 567 return (el.target, el.text) 568 else: 569 return el.tag
570 571 f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>') 572 events = list(iterparse(f, events=('end', 'pi'))) 573 root = events[-2][1] 574 self.assertEquals(8, len(events)) 575 self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b', 576 ('pid','d'), 'a', ('pie','e')], 577 [ name(*item) for item in events ]) 578 self.assertEquals( 579 _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'), 580 tostring(ElementTree(root))) 581
582 - def test_iterparse_remove_comments(self):
583 iterparse = self.etree.iterparse 584 tostring = self.etree.tostring 585 586 f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 587 events = list(iterparse(f, remove_comments=True, 588 events=('end', 'comment'))) 589 root = events[-1][1] 590 self.assertEquals(3, len(events)) 591 self.assertEquals(['c', 'b', 'a'], 592 [ el.tag for (event, el) in events ]) 593 self.assertEquals( 594 _bytes('<a><b><c/></b></a>'), 595 tostring(root))
596
597 - def test_iterparse_broken(self):
598 iterparse = self.etree.iterparse 599 f = BytesIO('<a><b><c/></a>') 600 # ET raises ExpatError, lxml raises XMLSyntaxError 601 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))
602
603 - def test_iterparse_strip(self):
604 iterparse = self.etree.iterparse 605 f = BytesIO(""" 606 <a> \n \n <b> b test </b> \n 607 608 \n\t <c> \n </c> </a> \n """) 609 iterator = iterparse(f, remove_blank_text=True) 610 text = [ (element.text, element.tail) 611 for event, element in iterator ] 612 self.assertEquals( 613 [(" b test ", None), (" \n ", None), (None, None)], 614 text)
615
616 - def test_iterparse_tag(self):
617 iterparse = self.etree.iterparse 618 f = BytesIO('<a><b><d/></b><c/></a>') 619 620 iterator = iterparse(f, tag="b", events=('start', 'end')) 621 events = list(iterator) 622 root = iterator.root 623 self.assertEquals( 624 [('start', root[0]), ('end', root[0])], 625 events)
626
627 - def test_iterparse_tag_all(self):
628 iterparse = self.etree.iterparse 629 f = BytesIO('<a><b><d/></b><c/></a>') 630 631 iterator = iterparse(f, tag="*", events=('start', 'end')) 632 events = list(iterator) 633 self.assertEquals( 634 8, 635 len(events))
636
637 - def test_iterparse_encoding_error(self):
638 text = _str('Søk på nettet') 639 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 640 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 641 ).encode('iso-8859-1') 642 643 self.assertRaises(self.etree.ParseError, 644 list, self.etree.iterparse(BytesIO(xml_latin1)))
645
646 - def test_iterparse_encoding_8bit_override(self):
647 text = _str('Søk på nettet', encoding="UTF-8") 648 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 649 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 650 ).encode('iso-8859-1') 651 652 iterator = self.etree.iterparse(BytesIO(xml_latin1), 653 encoding="iso-8859-1") 654 self.assertEquals(1, len(list(iterator))) 655 656 a = iterator.root 657 self.assertEquals(a.text, text)
658
659 - def test_iterparse_keep_cdata(self):
660 tostring = self.etree.tostring 661 f = BytesIO('<root><![CDATA[test]]></root>') 662 context = self.etree.iterparse(f, strip_cdata=False) 663 content = [ el.text for event,el in context ] 664 665 self.assertEquals(['test'], content) 666 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 667 tostring(context.root))
668
669 - def test_parser_encoding_unknown(self):
670 self.assertRaises( 671 LookupError, self.etree.XMLParser, encoding="hopefully unknown")
672
673 - def test_parser_encoding(self):
674 self.etree.XMLParser(encoding="ascii") 675 self.etree.XMLParser(encoding="utf-8") 676 self.etree.XMLParser(encoding="iso-8859-1")
677
678 - def test_feed_parser_recover(self):
679 parser = self.etree.XMLParser(recover=True) 680 681 parser.feed('<?xml version=') 682 parser.feed('"1.0"?><ro') 683 parser.feed('ot><') 684 parser.feed('a test="works"') 685 parser.feed('><othertag/></root') # <a> not closed! 686 parser.feed('>') 687 688 root = parser.close() 689 690 self.assertEquals(root.tag, "root") 691 self.assertEquals(len(root), 1) 692 self.assertEquals(root[0].tag, "a") 693 self.assertEquals(root[0].get("test"), "works") 694 self.assertEquals(len(root[0]), 1) 695 self.assertEquals(root[0][0].tag, "othertag")
696 # FIXME: would be nice to get some errors logged ... 697 #self.assert_(len(parser.error_log) > 0, "error log is empty") 698
699 - def test_elementtree_parser_target_type_error(self):
700 assertEquals = self.assertEquals 701 assertFalse = self.assertFalse 702 703 events = [] 704 class Target(object): 705 def start(self, tag, attrib): 706 events.append("start") 707 assertFalse(attrib) 708 assertEquals("TAG", tag)
709 def end(self, tag): 710 events.append("end") 711 assertEquals("TAG", tag) 712 def close(self): 713 return "DONE" # no Element! 714 715 parser = self.etree.XMLParser(target=Target()) 716 tree = self.etree.ElementTree() 717 718 self.assertRaises(TypeError, 719 tree.parse, BytesIO("<TAG/>"), parser=parser) 720 self.assertEquals(["start", "end"], events) 721
722 - def test_parser_target_feed_exception(self):
723 # ET doesn't call .close() on errors 724 events = [] 725 class Target(object): 726 def start(self, tag, attrib): 727 events.append("start-" + tag)
728 def end(self, tag): 729 events.append("end-" + tag) 730 if tag == 'a': 731 raise ValueError("dead and gone") 732 def data(self, data): 733 events.append("data-" + data) 734 def close(self): 735 events.append("close") 736 return "DONE" 737 738 parser = self.etree.XMLParser(target=Target()) 739 740 try: 741 parser.feed(_bytes('<root>A<a>ca</a>B</root>')) 742 done = parser.close() 743 self.fail("error expected, but parsing succeeded") 744 except ValueError: 745 done = 'value error received as expected' 746 747 self.assertEquals(["start-root", "data-A", "start-a", 748 "data-ca", "end-a", "close"], 749 events) 750
751 - def test_parser_target_fromstring_exception(self):
752 # ET doesn't call .close() on errors 753 events = [] 754 class Target(object): 755 def start(self, tag, attrib): 756 events.append("start-" + tag)
757 def end(self, tag): 758 events.append("end-" + tag) 759 if tag == 'a': 760 raise ValueError("dead and gone") 761 def data(self, data): 762 events.append("data-" + data) 763 def close(self): 764 events.append("close") 765 return "DONE" 766 767 parser = self.etree.XMLParser(target=Target()) 768 769 try: 770 done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'), 771 parser=parser) 772 self.fail("error expected, but parsing succeeded") 773 except ValueError: 774 done = 'value error received as expected' 775 776 self.assertEquals(["start-root", "data-A", "start-a", 777 "data-ca", "end-a", "close"], 778 events) 779
780 - def test_parser_target_comment(self):
781 events = [] 782 class Target(object): 783 def start(self, tag, attrib): 784 events.append("start-" + tag)
785 def end(self, tag): 786 events.append("end-" + tag) 787 def data(self, data): 788 events.append("data-" + data) 789 def comment(self, text): 790 events.append("comment-" + text) 791 def close(self): 792 return "DONE" 793 794 parser = self.etree.XMLParser(target=Target()) 795 796 parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->')) 797 done = parser.close() 798 799 self.assertEquals("DONE", done) 800 self.assertEquals(["comment-a", "start-root", "data-A", "comment-b", 801 "start-sub", "end-sub", "comment-c", "data-B", 802 "end-root", "comment-d"], 803 events) 804
805 - def test_parser_target_pi(self):
806 events = [] 807 class Target(object): 808 def start(self, tag, attrib): 809 events.append("start-" + tag)
810 def end(self, tag): 811 events.append("end-" + tag) 812 def data(self, data): 813 events.append("data-" + data) 814 def pi(self, target, data): 815 events.append("pi-" + target + "-" + data) 816 def close(self): 817 return "DONE" 818 819 parser = self.etree.XMLParser(target=Target()) 820 821 parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>')) 822 done = parser.close() 823 824 self.assertEquals("DONE", done) 825 self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b", 826 "data-B", "end-root", "pi-test-c"], 827 events) 828
829 - def test_parser_target_cdata(self):
830 events = [] 831 class Target(object): 832 def start(self, tag, attrib): 833 events.append("start-" + tag)
834 def end(self, tag): 835 events.append("end-" + tag) 836 def data(self, data): 837 events.append("data-" + data) 838 def close(self): 839 return "DONE" 840 841 parser = self.etree.XMLParser(target=Target(), 842 strip_cdata=False) 843 844 parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>')) 845 done = parser.close() 846 847 self.assertEquals("DONE", done) 848 self.assertEquals(["start-root", "data-A", "start-a", 849 "data-ca", "end-a", "data-B", "end-root"], 850 events) 851
852 - def test_parser_target_recover(self):
853 events = [] 854 class Target(object): 855 def start(self, tag, attrib): 856 events.append("start-" + tag)
857 def end(self, tag): 858 events.append("end-" + tag) 859 def data(self, data): 860 events.append("data-" + data) 861 def close(self): 862 events.append("close") 863 return "DONE" 864 865 parser = self.etree.XMLParser(target=Target(), 866 recover=True) 867 868 parser.feed(_bytes('<root>A<a>ca</a>B</not-root>')) 869 done = parser.close() 870 871 self.assertEquals("DONE", done) 872 self.assertEquals(["start-root", "data-A", "start-a", 873 "data-ca", "end-a", "data-B", 874 "end-root", "close"], 875 events) 876
877 - def test_iterwalk_tag(self):
878 iterwalk = self.etree.iterwalk 879 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 880 881 iterator = iterwalk(root, tag="b", events=('start', 'end')) 882 events = list(iterator) 883 self.assertEquals( 884 [('start', root[0]), ('end', root[0])], 885 events)
886
887 - def test_iterwalk_tag_all(self):
888 iterwalk = self.etree.iterwalk 889 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 890 891 iterator = iterwalk(root, tag="*", events=('start', 'end')) 892 events = list(iterator) 893 self.assertEquals( 894 8, 895 len(events))
896
897 - def test_iterwalk(self):
898 iterwalk = self.etree.iterwalk 899 root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 900 901 events = list(iterwalk(root)) 902 self.assertEquals( 903 [('end', root[0]), ('end', root[1]), ('end', root)], 904 events)
905
906 - def test_iterwalk_start(self):
907 iterwalk = self.etree.iterwalk 908 root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 909 910 iterator = iterwalk(root, events=('start',)) 911 events = list(iterator) 912 self.assertEquals( 913 [('start', root), ('start', root[0]), ('start', root[1])], 914 events)
915
916 - def test_iterwalk_start_end(self):
917 iterwalk = self.etree.iterwalk 918 root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 919 920 iterator = iterwalk(root, events=('start','end')) 921 events = list(iterator) 922 self.assertEquals( 923 [('start', root), ('start', root[0]), ('end', root[0]), 924 ('start', root[1]), ('end', root[1]), ('end', root)], 925 events)
926
927 - def test_iterwalk_clear(self):
928 iterwalk = self.etree.iterwalk 929 root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 930 931 iterator = iterwalk(root) 932 for event, elem in iterator: 933 elem.clear() 934 935 self.assertEquals(0, 936 len(root))
937
938 - def test_iterwalk_attrib_ns(self):
939 iterwalk = self.etree.iterwalk 940 root = self.etree.XML(_bytes('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')) 941 942 attr_name = '{testns}bla' 943 events = [] 944 iterator = iterwalk(root, events=('start','end','start-ns','end-ns')) 945 for event, elem in iterator: 946 events.append(event) 947 if event == 'start': 948 if elem.tag != '{ns1}a': 949 elem.set(attr_name, 'value') 950 951 self.assertEquals( 952 ['start-ns', 'start', 'start', 'start-ns', 'start', 953 'end', 'end-ns', 'end', 'end', 'end-ns'], 954 events) 955 956 self.assertEquals( 957 None, 958 root.get(attr_name)) 959 self.assertEquals( 960 'value', 961 root[0].get(attr_name))
962
963 - def test_iterwalk_getiterator(self):
964 iterwalk = self.etree.iterwalk 965 root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 966 967 counts = [] 968 for event, elem in iterwalk(root): 969 counts.append(len(list(elem.getiterator()))) 970 self.assertEquals( 971 [1,2,1,4], 972 counts)
973
974 - def test_resolve_string_dtd(self):
975 parse = self.etree.parse 976 parser = self.etree.XMLParser(dtd_validation=True) 977 assertEqual = self.assertEqual 978 test_url = _str("__nosuch.dtd") 979 980 class MyResolver(self.etree.Resolver): 981 def resolve(self, url, id, context): 982 assertEqual(url, test_url) 983 return self.resolve_string( 984 _str('''<!ENTITY myentity "%s"> 985 <!ELEMENT doc ANY>''') % url, context)
986 987 parser.resolvers.add(MyResolver()) 988 989 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 990 tree = parse(StringIO(xml), parser) 991 root = tree.getroot() 992 self.assertEquals(root.text, test_url) 993
994 - def test_resolve_bytes_dtd(self):
995 parse = self.etree.parse 996 parser = self.etree.XMLParser(dtd_validation=True) 997 assertEqual = self.assertEqual 998 test_url = _str("__nosuch.dtd") 999 1000 class MyResolver(self.etree.Resolver): 1001 def resolve(self, url, id, context): 1002 assertEqual(url, test_url) 1003 return self.resolve_string( 1004 (_str('''<!ENTITY myentity "%s"> 1005 <!ELEMENT doc ANY>''') % url).encode('utf-8'), 1006 context)
1007 1008 parser.resolvers.add(MyResolver()) 1009 1010 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1011 tree = parse(StringIO(xml), parser) 1012 root = tree.getroot() 1013 self.assertEquals(root.text, test_url) 1014
1015 - def test_resolve_filelike_dtd(self):
1016 parse = self.etree.parse 1017 parser = self.etree.XMLParser(dtd_validation=True) 1018 assertEqual = self.assertEqual 1019 test_url = _str("__nosuch.dtd") 1020 1021 class MyResolver(self.etree.Resolver): 1022 def resolve(self, url, id, context): 1023 assertEqual(url, test_url) 1024 return self.resolve_file( 1025 SillyFileLike( 1026 _str('''<!ENTITY myentity "%s"> 1027 <!ELEMENT doc ANY>''') % url), context)
1028 1029 parser.resolvers.add(MyResolver()) 1030 1031 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1032 tree = parse(StringIO(xml), parser) 1033 root = tree.getroot() 1034 self.assertEquals(root.text, test_url) 1035
1036 - def test_resolve_filename_dtd(self):
1037 parse = self.etree.parse 1038 parser = self.etree.XMLParser(attribute_defaults=True) 1039 assertEqual = self.assertEqual 1040 test_url = _str("__nosuch.dtd") 1041 1042 class MyResolver(self.etree.Resolver): 1043 def resolve(self, url, id, context): 1044 assertEqual(url, test_url) 1045 return self.resolve_filename( 1046 fileInTestDir('test.dtd'), context)
1047 1048 parser.resolvers.add(MyResolver()) 1049 1050 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 1051 tree = parse(StringIO(xml), parser) 1052 root = tree.getroot() 1053 self.assertEquals( 1054 root.attrib, {'default': 'valueA'}) 1055 self.assertEquals( 1056 root[0].attrib, {'default': 'valueB'}) 1057
1058 - def test_resolve_filename_dtd_relative(self):
1059 parse = self.etree.parse 1060 parser = self.etree.XMLParser(attribute_defaults=True) 1061 assertEqual = self.assertEqual 1062 test_url = _str("__nosuch.dtd") 1063 1064 class MyResolver(self.etree.Resolver): 1065 def resolve(self, url, id, context): 1066 assertEqual(url, fileInTestDir(test_url)) 1067 return self.resolve_filename( 1068 fileInTestDir('test.dtd'), context)
1069 1070 parser.resolvers.add(MyResolver()) 1071 1072 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 1073 tree = parse(StringIO(xml), parser, 1074 base_url=fileInTestDir('__test.xml')) 1075 root = tree.getroot() 1076 self.assertEquals( 1077 root.attrib, {'default': 'valueA'}) 1078 self.assertEquals( 1079 root[0].attrib, {'default': 'valueB'}) 1080
1081 - def test_resolve_file_dtd(self):
1082 parse = self.etree.parse 1083 parser = self.etree.XMLParser(attribute_defaults=True) 1084 assertEqual = self.assertEqual 1085 test_url = _str("__nosuch.dtd") 1086 1087 class MyResolver(self.etree.Resolver): 1088 def resolve(self, url, id, context): 1089 assertEqual(url, test_url) 1090 return self.resolve_file( 1091 open(fileInTestDir('test.dtd'), 'rb'), context)
1092 1093 parser.resolvers.add(MyResolver()) 1094 1095 xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 1096 tree = parse(StringIO(xml), parser) 1097 root = tree.getroot() 1098 self.assertEquals( 1099 root.attrib, {'default': 'valueA'}) 1100 self.assertEquals( 1101 root[0].attrib, {'default': 'valueB'}) 1102
1103 - def test_resolve_empty(self):
1104 parse = self.etree.parse 1105 parser = self.etree.XMLParser(load_dtd=True) 1106 assertEqual = self.assertEqual 1107 test_url = _str("__nosuch.dtd") 1108 1109 class check(object): 1110 resolved = False
1111 1112 class MyResolver(self.etree.Resolver): 1113 def resolve(self, url, id, context): 1114 assertEqual(url, test_url) 1115 check.resolved = True 1116 return self.resolve_empty(context) 1117 1118 parser.resolvers.add(MyResolver()) 1119 1120 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1121 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser) 1122 self.assert_(check.resolved) 1123
1124 - def test_resolve_error(self):
1125 parse = self.etree.parse 1126 parser = self.etree.XMLParser(dtd_validation=True) 1127 1128 class _LocalException(Exception): 1129 pass
1130 1131 class MyResolver(self.etree.Resolver): 1132 def resolve(self, url, id, context): 1133 raise _LocalException 1134 1135 parser.resolvers.add(MyResolver()) 1136 1137 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 1138 self.assertRaises(_LocalException, parse, BytesIO(xml), parser) 1139 1140 if etree.LIBXML_VERSION > (2,6,20):
1141 - def test_entity_parse(self):
1142 parse = self.etree.parse 1143 tostring = self.etree.tostring 1144 parser = self.etree.XMLParser(resolve_entities=False) 1145 Entity = self.etree.Entity 1146 1147 xml = _bytes('<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>') 1148 tree = parse(BytesIO(xml), parser) 1149 root = tree.getroot() 1150 self.assertEquals(root[0].tag, Entity) 1151 self.assertEquals(root[0].text, "&myentity;") 1152 self.assertEquals(root[0].tail, None) 1153 self.assertEquals(root[0].name, "myentity") 1154 1155 self.assertEquals(_bytes('<doc>&myentity;</doc>'), 1156 tostring(root))
1157
1158 - def test_entity_restructure(self):
1159 xml = _bytes('''<!DOCTYPE root [ <!ENTITY nbsp "&#160;"> ]> 1160 <root> 1161 <child1/> 1162 <child2/> 1163 <child3>&nbsp;</child3> 1164 </root>''') 1165 1166 parser = self.etree.XMLParser(resolve_entities=False) 1167 root = etree.fromstring(xml, parser) 1168 self.assertEquals([ el.tag for el in root ], 1169 ['child1', 'child2', 'child3']) 1170 1171 root[0] = root[-1] 1172 self.assertEquals([ el.tag for el in root ], 1173 ['child3', 'child2']) 1174 self.assertEquals(root[0][0].text, '&nbsp;') 1175 self.assertEquals(root[0][0].name, 'nbsp')
1176
1177 - def test_entity_append(self):
1178 Entity = self.etree.Entity 1179 Element = self.etree.Element 1180 tostring = self.etree.tostring 1181 1182 root = Element("root") 1183 root.append( Entity("test") ) 1184 1185 self.assertEquals(root[0].tag, Entity) 1186 self.assertEquals(root[0].text, "&test;") 1187 self.assertEquals(root[0].tail, None) 1188 self.assertEquals(root[0].name, "test") 1189 1190 self.assertEquals(_bytes('<root>&test;</root>'), 1191 tostring(root))
1192
1193 - def test_entity_values(self):
1194 Entity = self.etree.Entity 1195 self.assertEquals(Entity("test").text, '&test;') 1196 self.assertEquals(Entity("#17683").text, '&#17683;') 1197 self.assertEquals(Entity("#x1768").text, '&#x1768;') 1198 self.assertEquals(Entity("#x98AF").text, '&#x98AF;')
1199
1200 - def test_entity_error(self):
1201 Entity = self.etree.Entity 1202 self.assertRaises(ValueError, Entity, 'a b c') 1203 self.assertRaises(ValueError, Entity, 'a,b') 1204 self.assertRaises(ValueError, Entity, 'a\0b') 1205 self.assertRaises(ValueError, Entity, '#abc') 1206 self.assertRaises(ValueError, Entity, '#xxyz')
1207
1208 - def test_cdata(self):
1209 CDATA = self.etree.CDATA 1210 Element = self.etree.Element 1211 tostring = self.etree.tostring 1212 1213 root = Element("root") 1214 root.text = CDATA('test') 1215 1216 self.assertEquals('test', 1217 root.text) 1218 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1219 tostring(root))
1220
1221 - def test_cdata_type(self):
1222 CDATA = self.etree.CDATA 1223 Element = self.etree.Element 1224 root = Element("root") 1225 1226 root.text = CDATA("test") 1227 self.assertEquals('test', root.text) 1228 1229 root.text = CDATA(_str("test")) 1230 self.assertEquals('test', root.text) 1231 1232 self.assertRaises(TypeError, CDATA, 1)
1233
1234 - def test_cdata_errors(self):
1235 CDATA = self.etree.CDATA 1236 Element = self.etree.Element 1237 1238 root = Element("root") 1239 cdata = CDATA('test') 1240 1241 self.assertRaises(TypeError, 1242 setattr, root, 'tail', cdata) 1243 self.assertRaises(TypeError, 1244 root.set, 'attr', cdata) 1245 self.assertRaises(TypeError, 1246 operator.setitem, root.attrib, 'attr', cdata)
1247
1248 - def test_cdata_parser(self):
1249 tostring = self.etree.tostring 1250 parser = self.etree.XMLParser(strip_cdata=False) 1251 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 1252 1253 self.assertEquals('test', root.text) 1254 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1255 tostring(root))
1256
1257 - def test_cdata_xpath(self):
1258 tostring = self.etree.tostring 1259 parser = self.etree.XMLParser(strip_cdata=False) 1260 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 1261 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1262 tostring(root)) 1263 1264 self.assertEquals(['test'], root.xpath('//text()'))
1265 1266 # TypeError in etree, AssertionError in ElementTree;
1267 - def test_setitem_assert(self):
1268 Element = self.etree.Element 1269 SubElement = self.etree.SubElement 1270 1271 a = Element('a') 1272 b = SubElement(a, 'b') 1273 1274 self.assertRaises(TypeError, 1275 a.__setitem__, 0, 'foo')
1276
1277 - def test_append_None(self):
1278 # raises AssertionError in ElementTree 1279 Element = self.etree.Element 1280 self.assertRaises(TypeError, Element('a').append, None)
1281
1282 - def test_addnext(self):
1283 Element = self.etree.Element 1284 SubElement = self.etree.SubElement 1285 root = Element('root') 1286 SubElement(root, 'a') 1287 SubElement(root, 'b') 1288 1289 self.assertEquals(['a', 'b'], 1290 [c.tag for c in root]) 1291 root[1].addnext(root[0]) 1292 self.assertEquals(['b', 'a'], 1293 [c.tag for c in root])
1294
1295 - def test_addprevious(self):
1296 Element = self.etree.Element 1297 SubElement = self.etree.SubElement 1298 root = Element('root') 1299 SubElement(root, 'a') 1300 SubElement(root, 'b') 1301 1302 self.assertEquals(['a', 'b'], 1303 [c.tag for c in root]) 1304 root[0].addprevious(root[1]) 1305 self.assertEquals(['b', 'a'], 1306 [c.tag for c in root])
1307
1308 - def test_addnext_root(self):
1309 Element = self.etree.Element 1310 a = Element('a') 1311 b = Element('b') 1312 self.assertRaises(TypeError, a.addnext, b)
1313
1314 - def test_addnext_root(self):
1315 Element = self.etree.Element 1316 a = Element('a') 1317 b = Element('b') 1318 self.assertRaises(TypeError, a.addnext, b)
1319
1320 - def test_addprevious_pi(self):
1321 Element = self.etree.Element 1322 SubElement = self.etree.SubElement 1323 PI = self.etree.PI 1324 root = Element('root') 1325 SubElement(root, 'a') 1326 pi = PI('TARGET', 'TEXT') 1327 pi.tail = "TAIL" 1328 1329 self.assertEquals(_bytes('<root><a></a></root>'), 1330 self._writeElement(root)) 1331 root[0].addprevious(pi) 1332 self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'), 1333 self._writeElement(root))
1334
1335 - def test_addprevious_root_pi(self):
1336 Element = self.etree.Element 1337 PI = self.etree.PI 1338 root = Element('root') 1339 pi = PI('TARGET', 'TEXT') 1340 pi.tail = "TAIL" 1341 1342 self.assertEquals(_bytes('<root></root>'), 1343 self._writeElement(root)) 1344 root.addprevious(pi) 1345 self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'), 1346 self._writeElement(root))
1347
1348 - def test_addnext_pi(self):
1349 Element = self.etree.Element 1350 SubElement = self.etree.SubElement 1351 PI = self.etree.PI 1352 root = Element('root') 1353 SubElement(root, 'a') 1354 pi = PI('TARGET', 'TEXT') 1355 pi.tail = "TAIL" 1356 1357 self.assertEquals(_bytes('<root><a></a></root>'), 1358 self._writeElement(root)) 1359 root[0].addnext(pi) 1360 self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'), 1361 self._writeElement(root))
1362
1363 - def test_addnext_root_pi(self):
1364 Element = self.etree.Element 1365 PI = self.etree.PI 1366 root = Element('root') 1367 pi = PI('TARGET', 'TEXT') 1368 pi.tail = "TAIL" 1369 1370 self.assertEquals(_bytes('<root></root>'), 1371 self._writeElement(root)) 1372 root.addnext(pi) 1373 self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'), 1374 self._writeElement(root))
1375
1376 - def test_addnext_comment(self):
1377 Element = self.etree.Element 1378 SubElement = self.etree.SubElement 1379 Comment = self.etree.Comment 1380 root = Element('root') 1381 SubElement(root, 'a') 1382 comment = Comment('TEXT ') 1383 comment.tail = "TAIL" 1384 1385 self.assertEquals(_bytes('<root><a></a></root>'), 1386 self._writeElement(root)) 1387 root[0].addnext(comment) 1388 self.assertEquals(_bytes('<root><a></a><!--TEXT -->TAIL</root>'), 1389 self._writeElement(root))
1390
1391 - def test_addnext_root_comment(self):
1392 Element = self.etree.Element 1393 Comment = self.etree.Comment 1394 root = Element('root') 1395 comment = Comment('TEXT ') 1396 comment.tail = "TAIL" 1397 1398 self.assertEquals(_bytes('<root></root>'), 1399 self._writeElement(root)) 1400 root.addnext(comment) 1401 self.assertEquals(_bytes('<root></root>\n<!--TEXT -->'), 1402 self._writeElement(root))
1403
1404 - def test_addprevious_comment(self):
1405 Element = self.etree.Element 1406 SubElement = self.etree.SubElement 1407 Comment = self.etree.Comment 1408 root = Element('root') 1409 SubElement(root, 'a') 1410 comment = Comment('TEXT ') 1411 comment.tail = "TAIL" 1412 1413 self.assertEquals(_bytes('<root><a></a></root>'), 1414 self._writeElement(root)) 1415 root[0].addprevious(comment) 1416 self.assertEquals(_bytes('<root><!--TEXT -->TAIL<a></a></root>'), 1417 self._writeElement(root))
1418
1419 - def test_addprevious_root_comment(self):
1420 Element = self.etree.Element 1421 Comment = self.etree.Comment 1422 root = Element('root') 1423 comment = Comment('TEXT ') 1424 comment.tail = "TAIL" 1425 1426 self.assertEquals(_bytes('<root></root>'), 1427 self._writeElement(root)) 1428 root.addprevious(comment) 1429 self.assertEquals(_bytes('<!--TEXT -->\n<root></root>'), 1430 self._writeElement(root))
1431 1432 # ET's Elements have items() and key(), but not values()
1433 - def test_attribute_values(self):
1434 XML = self.etree.XML 1435 1436 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 1437 values = root.values() 1438 values.sort() 1439 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
1440 1441 # gives error in ElementTree
1442 - def test_comment_empty(self):
1443 Element = self.etree.Element 1444 Comment = self.etree.Comment 1445 1446 a = Element('a') 1447 a.append(Comment()) 1448 self.assertEquals( 1449 _bytes('<a><!----></a>'), 1450 self._writeElement(a))
1451 1452 # ElementTree ignores comments
1453 - def test_comment_parse_empty(self):
1454 ElementTree = self.etree.ElementTree 1455 tostring = self.etree.tostring 1456 1457 xml = _bytes('<a><b/><!----><c/></a>') 1458 f = BytesIO(xml) 1459 doc = ElementTree(file=f) 1460 a = doc.getroot() 1461 self.assertEquals( 1462 '', 1463 a[1].text) 1464 self.assertEquals( 1465 xml, 1466 tostring(a))
1467 1468 # ElementTree ignores comments
1469 - def test_comment_no_proxy_yet(self):
1470 ElementTree = self.etree.ElementTree 1471 1472 f = BytesIO('<a><b></b><!-- hoi --><c></c></a>') 1473 doc = ElementTree(file=f) 1474 a = doc.getroot() 1475 self.assertEquals( 1476 ' hoi ', 1477 a[1].text)
1478 1479 # does not raise an exception in ElementTree
1480 - def test_comment_immutable(self):
1481 Element = self.etree.Element 1482 Comment = self.etree.Comment 1483 1484 c = Comment() 1485 el = Element('myel') 1486 1487 self.assertRaises(TypeError, c.append, el) 1488 self.assertRaises(TypeError, c.insert, 0, el) 1489 self.assertRaises(TypeError, c.set, "myattr", "test")
1490 1491 # test passing 'None' to dump
1492 - def test_dump_none(self):
1493 self.assertRaises(TypeError, self.etree.dump, None)
1494
1495 - def test_prefix(self):
1496 ElementTree = self.etree.ElementTree 1497 1498 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') 1499 doc = ElementTree(file=f) 1500 a = doc.getroot() 1501 self.assertEquals( 1502 None, 1503 a.prefix) 1504 self.assertEquals( 1505 'foo', 1506 a[0].prefix)
1507
1508 - def test_prefix_default_ns(self):
1509 ElementTree = self.etree.ElementTree 1510 1511 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>') 1512 doc = ElementTree(file=f) 1513 a = doc.getroot() 1514 self.assertEquals( 1515 None, 1516 a.prefix) 1517 self.assertEquals( 1518 None, 1519 a[0].prefix)
1520
1521 - def test_getparent(self):
1522 Element = self.etree.Element 1523 SubElement = self.etree.SubElement 1524 1525 a = Element('a') 1526 b = SubElement(a, 'b') 1527 c = SubElement(a, 'c') 1528 d = SubElement(b, 'd') 1529 self.assertEquals( 1530 None, 1531 a.getparent()) 1532 self.assertEquals( 1533 a, 1534 b.getparent()) 1535 self.assertEquals( 1536 b.getparent(), 1537 c.getparent()) 1538 self.assertEquals( 1539 b, 1540 d.getparent())
1541
1542 - def test_iterchildren(self):
1543 XML = self.etree.XML 1544 1545 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 1546 result = [] 1547 for el in root.iterchildren(): 1548 result.append(el.tag) 1549 self.assertEquals(['one', 'two', 'three'], result)
1550
1551 - def test_iterchildren_reversed(self):
1552 XML = self.etree.XML 1553 1554 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 1555 result = [] 1556 for el in root.iterchildren(reversed=True): 1557 result.append(el.tag) 1558 self.assertEquals(['three', 'two', 'one'], result)
1559
1560 - def test_iterchildren_tag(self):
1561 XML = self.etree.XML 1562 1563 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 1564 result = [] 1565 for el in root.iterchildren(tag='two'): 1566 result.append(el.text) 1567 self.assertEquals(['Two', 'Bla'], result)
1568
1569 - def test_iterchildren_tag_reversed(self):
1570 XML = self.etree.XML 1571 1572 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 1573 result = [] 1574 for el in root.iterchildren(reversed=True, tag='two'): 1575 result.append(el.text) 1576 self.assertEquals(['Bla', 'Two'], result)
1577
1578 - def test_iterancestors(self):
1579 Element = self.etree.Element 1580 SubElement = self.etree.SubElement 1581 1582 a = Element('a') 1583 b = SubElement(a, 'b') 1584 c = SubElement(a, 'c') 1585 d = SubElement(b, 'd') 1586 self.assertEquals( 1587 [], 1588 list(a.iterancestors())) 1589 self.assertEquals( 1590 [a], 1591 list(b.iterancestors())) 1592 self.assertEquals( 1593 [a], 1594 list(c.iterancestors())) 1595 self.assertEquals( 1596 [b, a], 1597 list(d.iterancestors()))
1598
1599 - def test_iterancestors_tag(self):
1600 Element = self.etree.Element 1601 SubElement = self.etree.SubElement 1602 1603 a = Element('a') 1604 b = SubElement(a, 'b') 1605 c = SubElement(a, 'c') 1606 d = SubElement(b, 'd') 1607 self.assertEquals( 1608 [a], 1609 list(d.iterancestors(tag='a')))
1610
1611 - def test_iterdescendants(self):
1612 Element = self.etree.Element 1613 SubElement = self.etree.SubElement 1614 1615 a = Element('a') 1616 b = SubElement(a, 'b') 1617 c = SubElement(a, 'c') 1618 d = SubElement(b, 'd') 1619 e = SubElement(c, 'e') 1620 1621 self.assertEquals( 1622 [b, d, c, e], 1623 list(a.iterdescendants())) 1624 self.assertEquals( 1625 [], 1626 list(d.iterdescendants()))
1627
1628 - def test_iterdescendants_tag(self):
1629 Element = self.etree.Element 1630 SubElement = self.etree.SubElement 1631 1632 a = Element('a') 1633 b = SubElement(a, 'b') 1634 c = SubElement(a, 'c') 1635 d = SubElement(b, 'd') 1636 e = SubElement(c, 'e') 1637 1638 self.assertEquals( 1639 [], 1640 list(a.iterdescendants('a'))) 1641 a2 = SubElement(e, 'a') 1642 self.assertEquals( 1643 [a2], 1644 list(a.iterdescendants('a'))) 1645 self.assertEquals( 1646 [a2], 1647 list(c.iterdescendants('a')))
1648
1649 - def test_getroottree(self):
1650 Element = self.etree.Element 1651 SubElement = self.etree.SubElement 1652 1653 a = Element('a') 1654 b = SubElement(a, 'b') 1655 c = SubElement(a, 'c') 1656 d = SubElement(b, 'd') 1657 self.assertEquals( 1658 a, 1659 a.getroottree().getroot()) 1660 self.assertEquals( 1661 a, 1662 b.getroottree().getroot()) 1663 self.assertEquals( 1664 a, 1665 d.getroottree().getroot())
1666
1667 - def test_getnext(self):
1668 Element = self.etree.Element 1669 SubElement = self.etree.SubElement 1670 1671 a = Element('a') 1672 b = SubElement(a, 'b') 1673 c = SubElement(a, 'c') 1674 self.assertEquals( 1675 None, 1676 a.getnext()) 1677 self.assertEquals( 1678 c, 1679 b.getnext()) 1680 self.assertEquals( 1681 None, 1682 c.getnext())
1683
1684 - def test_getprevious(self):
1685 Element = self.etree.Element 1686 SubElement = self.etree.SubElement 1687 1688 a = Element('a') 1689 b = SubElement(a, 'b') 1690 c = SubElement(a, 'c') 1691 d = SubElement(b, 'd') 1692 self.assertEquals( 1693 None, 1694 a.getprevious()) 1695 self.assertEquals( 1696 b, 1697 c.getprevious()) 1698 self.assertEquals( 1699 None, 1700 b.getprevious())
1701
1702 - def test_itersiblings(self):
1703 Element = self.etree.Element 1704 SubElement = self.etree.SubElement 1705 1706 a = Element('a') 1707 b = SubElement(a, 'b') 1708 c = SubElement(a, 'c') 1709 d = SubElement(b, 'd') 1710 self.assertEquals( 1711 [], 1712 list(a.itersiblings())) 1713 self.assertEquals( 1714 [c], 1715 list(b.itersiblings())) 1716 self.assertEquals( 1717 [], 1718 list(c.itersiblings())) 1719 self.assertEquals( 1720 [b], 1721 list(c.itersiblings(preceding=True))) 1722 self.assertEquals( 1723 [], 1724 list(b.itersiblings(preceding=True)))
1725
1726 - def test_itersiblings_tag(self):
1727 Element = self.etree.Element 1728 SubElement = self.etree.SubElement 1729 1730 a = Element('a') 1731 b = SubElement(a, 'b') 1732 c = SubElement(a, 'c') 1733 d = SubElement(b, 'd') 1734 self.assertEquals( 1735 [], 1736 list(a.itersiblings(tag='XXX'))) 1737 self.assertEquals( 1738 [c], 1739 list(b.itersiblings(tag='c'))) 1740 self.assertEquals( 1741 [b], 1742 list(c.itersiblings(preceding=True, tag='b'))) 1743 self.assertEquals( 1744 [], 1745 list(c.itersiblings(preceding=True, tag='c')))
1746
1747 - def test_parseid(self):
1748 parseid = self.etree.parseid 1749 XML = self.etree.XML 1750 xml_text = _bytes(''' 1751 <!DOCTYPE document [ 1752 <!ELEMENT document (h1,p)*> 1753 <!ELEMENT h1 (#PCDATA)> 1754 <!ATTLIST h1 myid ID #REQUIRED> 1755 <!ELEMENT p (#PCDATA)> 1756 <!ATTLIST p someid ID #REQUIRED> 1757 ]> 1758 <document> 1759 <h1 myid="chapter1">...</h1> 1760 <p id="note1" class="note">...</p> 1761 <p>Regular paragraph.</p> 1762 <p xml:id="xmlid">XML:ID paragraph.</p> 1763 <p someid="warn1" class="warning">...</p> 1764 </document> 1765 ''') 1766 1767 tree, dic = parseid(BytesIO(xml_text)) 1768 root = tree.getroot() 1769 root2 = XML(xml_text) 1770 self.assertEquals(self._writeElement(root), 1771 self._writeElement(root2)) 1772 expected = { 1773 "chapter1" : root[0], 1774 "xmlid" : root[3], 1775 "warn1" : root[4] 1776 } 1777 self.assert_("chapter1" in dic) 1778 self.assert_("warn1" in dic) 1779 self.assert_("xmlid" in dic) 1780 self._checkIDDict(dic, expected)
1781
1782 - def test_XMLDTDID(self):
1783 XMLDTDID = self.etree.XMLDTDID 1784 XML = self.etree.XML 1785 xml_text = _bytes(''' 1786 <!DOCTYPE document [ 1787 <!ELEMENT document (h1,p)*> 1788 <!ELEMENT h1 (#PCDATA)> 1789 <!ATTLIST h1 myid ID #REQUIRED> 1790 <!ELEMENT p (#PCDATA)> 1791 <!ATTLIST p someid ID #REQUIRED> 1792 ]> 1793 <document> 1794 <h1 myid="chapter1">...</h1> 1795 <p id="note1" class="note">...</p> 1796 <p>Regular paragraph.</p> 1797 <p xml:id="xmlid">XML:ID paragraph.</p> 1798 <p someid="warn1" class="warning">...</p> 1799 </document> 1800 ''') 1801 1802 root, dic = XMLDTDID(xml_text) 1803 root2 = XML(xml_text) 1804 self.assertEquals(self._writeElement(root), 1805 self._writeElement(root2)) 1806 expected = { 1807 "chapter1" : root[0], 1808 "xmlid" : root[3], 1809 "warn1" : root[4] 1810 } 1811 self.assert_("chapter1" in dic) 1812 self.assert_("warn1" in dic) 1813 self.assert_("xmlid" in dic) 1814 self._checkIDDict(dic, expected)
1815
1816 - def test_XMLDTDID_empty(self):
1817 XMLDTDID = self.etree.XMLDTDID 1818 XML = self.etree.XML 1819 xml_text = _bytes(''' 1820 <document> 1821 <h1 myid="chapter1">...</h1> 1822 <p id="note1" class="note">...</p> 1823 <p>Regular paragraph.</p> 1824 <p someid="warn1" class="warning">...</p> 1825 </document> 1826 ''') 1827 1828 root, dic = XMLDTDID(xml_text) 1829 root2 = XML(xml_text) 1830 self.assertEquals(self._writeElement(root), 1831 self._writeElement(root2)) 1832 expected = {} 1833 self._checkIDDict(dic, expected)
1834
1835 - def _checkIDDict(self, dic, expected):
1836 self.assertEquals(len(dic), 1837 len(expected)) 1838 self.assertEquals(sorted(dic.items()), 1839 sorted(expected.items())) 1840 if sys.version_info < (3,): 1841 self.assertEquals(sorted(dic.iteritems()), 1842 sorted(expected.iteritems())) 1843 self.assertEquals(sorted(dic.keys()), 1844 sorted(expected.keys())) 1845 if sys.version_info < (3,): 1846 self.assertEquals(sorted(dic.iterkeys()), 1847 sorted(expected.iterkeys())) 1848 if sys.version_info < (3,): 1849 self.assertEquals(sorted(dic.values()), 1850 sorted(expected.values())) 1851 self.assertEquals(sorted(dic.itervalues()), 1852 sorted(expected.itervalues()))
1853
1854 - def test_namespaces(self):
1855 etree = self.etree 1856 1857 r = {'foo': 'http://ns.infrae.com/foo'} 1858 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1859 self.assertEquals( 1860 'foo', 1861 e.prefix) 1862 self.assertEquals( 1863 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'), 1864 self._writeElement(e))
1865
1866 - def test_namespaces_default(self):
1867 etree = self.etree 1868 1869 r = {None: 'http://ns.infrae.com/foo'} 1870 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1871 self.assertEquals( 1872 None, 1873 e.prefix) 1874 self.assertEquals( 1875 '{http://ns.infrae.com/foo}bar', 1876 e.tag) 1877 self.assertEquals( 1878 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'), 1879 self._writeElement(e))
1880
1881 - def test_namespaces_default_and_attr(self):
1882 etree = self.etree 1883 1884 r = {None: 'http://ns.infrae.com/foo', 1885 'hoi': 'http://ns.infrae.com/hoi'} 1886 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1887 e.set('{http://ns.infrae.com/hoi}test', 'value') 1888 self.assertEquals( 1889 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'), 1890 self._writeElement(e))
1891
1892 - def test_namespaces_elementtree(self):
1893 etree = self.etree 1894 r = {None: 'http://ns.infrae.com/foo', 1895 'hoi': 'http://ns.infrae.com/hoi'} 1896 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) 1897 tree = etree.ElementTree(element=e) 1898 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') 1899 self.assertEquals( 1900 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'), 1901 self._writeElement(e))
1902
1903 - def test_namespaces_default_copy_element(self):
1904 etree = self.etree 1905 1906 r = {None: 'http://ns.infrae.com/foo'} 1907 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1908 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1909 1910 e1.append(e2) 1911 1912 self.assertEquals( 1913 None, 1914 e1.prefix) 1915 self.assertEquals( 1916 None, 1917 e1[0].prefix) 1918 self.assertEquals( 1919 '{http://ns.infrae.com/foo}bar', 1920 e1.tag) 1921 self.assertEquals( 1922 '{http://ns.infrae.com/foo}bar', 1923 e1[0].tag)
1924
1925 - def test_namespaces_copy_element(self):
1926 etree = self.etree 1927 1928 r = {None: 'http://ns.infrae.com/BAR'} 1929 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) 1930 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1931 1932 e1.append(e2) 1933 1934 self.assertEquals( 1935 None, 1936 e1.prefix) 1937 self.assertNotEquals( 1938 None, 1939 e2.prefix) 1940 self.assertEquals( 1941 '{http://ns.infrae.com/BAR}bar', 1942 e1.tag) 1943 self.assertEquals( 1944 '{http://ns.infrae.com/foo}bar', 1945 e2.tag)
1946
1947 - def test_namespaces_reuse_after_move(self):
1948 ns_href = "http://a.b.c" 1949 one = self.etree.fromstring( 1950 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 1951 baz = one[0][0] 1952 1953 two = self.etree.fromstring( 1954 _bytes('<root xmlns:ns="%s"/>' % ns_href)) 1955 two.append(baz) 1956 del one # make sure the source document is deallocated 1957 1958 self.assertEquals('{%s}baz' % ns_href, baz.tag) 1959 self.assertEquals( 1960 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href), 1961 self.etree.tostring(two))
1962
1963 - def test_namespace_cleanup(self):
1964 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>') 1965 root = self.etree.fromstring(xml) 1966 self.assertEquals(xml, 1967 self.etree.tostring(root)) 1968 self.etree.cleanup_namespaces(root) 1969 self.assertEquals( 1970 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'), 1971 self.etree.tostring(root))
1972
1973 - def test_element_nsmap(self):
1974 etree = self.etree 1975 1976 r = {None: 'http://ns.infrae.com/foo', 1977 'hoi': 'http://ns.infrae.com/hoi'} 1978 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1979 self.assertEquals( 1980 r, 1981 e.nsmap)
1982
1983 - def test_subelement_nsmap(self):
1984 etree = self.etree 1985 1986 re = {None: 'http://ns.infrae.com/foo', 1987 'hoi': 'http://ns.infrae.com/hoi'} 1988 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) 1989 1990 rs = {None: 'http://ns.infrae.com/honk', 1991 'top': 'http://ns.infrae.com/top'} 1992 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) 1993 1994 r = re.copy() 1995 r.update(rs) 1996 self.assertEquals(re, e.nsmap) 1997 self.assertEquals(r, s.nsmap)
1998
1999 - def test_getiterator_filter_namespace(self):
2000 Element = self.etree.Element 2001 SubElement = self.etree.SubElement 2002 2003 a = Element('{a}a') 2004 b = SubElement(a, '{a}b') 2005 c = SubElement(a, '{a}c') 2006 d = SubElement(b, '{b}d') 2007 e = SubElement(c, '{a}e') 2008 f = SubElement(c, '{b}f') 2009 2010 self.assertEquals( 2011 [a], 2012 list(a.getiterator('{a}a'))) 2013 self.assertEquals( 2014 [], 2015 list(a.getiterator('{b}a'))) 2016 self.assertEquals( 2017 [], 2018 list(a.getiterator('a'))) 2019 self.assertEquals( 2020 [f], 2021 list(c.getiterator('{b}*'))) 2022 self.assertEquals( 2023 [d, f], 2024 list(a.getiterator('{b}*')))
2025
2026 - def test_getiterator_filter_entities(self):
2027 Element = self.etree.Element 2028 Entity = self.etree.Entity 2029 SubElement = self.etree.SubElement 2030 2031 a = Element('a') 2032 b = SubElement(a, 'b') 2033 entity_b = Entity("TEST-b") 2034 b.append(entity_b) 2035 2036 self.assertEquals( 2037 [entity_b], 2038 list(a.getiterator(Entity))) 2039 2040 entity_a = Entity("TEST-a") 2041 a.append(entity_a) 2042 2043 self.assertEquals( 2044 [entity_b, entity_a], 2045 list(a.getiterator(Entity))) 2046 2047 self.assertEquals( 2048 [entity_b], 2049 list(b.getiterator(Entity)))
2050
2051 - def test_getiterator_filter_element(self):
2052 Element = self.etree.Element 2053 Comment = self.etree.Comment 2054 PI = self.etree.PI 2055 SubElement = self.etree.SubElement 2056 2057 a = Element('a') 2058 b = SubElement(a, 'b') 2059 a.append(Comment("test")) 2060 a.append(PI("pi", "content")) 2061 c = SubElement(a, 'c') 2062 2063 self.assertEquals( 2064 [a, b, c], 2065 list(a.getiterator(Element)))
2066
2067 - def test_getiterator_filter_all_comment_pi(self):
2068 # ElementTree iterates over everything here 2069 Element = self.etree.Element 2070 Comment = self.etree.Comment 2071 PI = self.etree.PI 2072 SubElement = self.etree.SubElement 2073 2074 a = Element('a') 2075 b = SubElement(a, 'b') 2076 a.append(Comment("test")) 2077 a.append(PI("pi", "content")) 2078 c = SubElement(a, 'c') 2079 2080 self.assertEquals( 2081 [a, b, c], 2082 list(a.getiterator('*')))
2083
2084 - def test_elementtree_find_qname(self):
2085 XML = self.etree.XML 2086 ElementTree = self.etree.ElementTree 2087 QName = self.etree.QName 2088 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))) 2089 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])
2090
2091 - def test_elementtree_findall_qname(self):
2092 XML = self.etree.XML 2093 ElementTree = self.etree.ElementTree 2094 QName = self.etree.QName 2095 tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))) 2096 self.assertEquals(len(list(tree.findall(QName("c")))), 1)
2097
2098 - def test_elementtree_findall_ns_qname(self):
2099 XML = self.etree.XML 2100 ElementTree = self.etree.ElementTree 2101 QName = self.etree.QName 2102 tree = ElementTree(XML( 2103 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))) 2104 self.assertEquals(len(list(tree.findall(QName("b")))), 2) 2105 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)
2106
2107 - def test_findall_ns(self):
2108 XML = self.etree.XML 2109 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')) 2110 self.assertEquals(len(root.findall(".//{X}b")), 2) 2111 self.assertEquals(len(root.findall(".//{X}*")), 2) 2112 self.assertEquals(len(root.findall(".//b")), 3)
2113
2114 - def test_index(self):
2115 etree = self.etree 2116 e = etree.Element('foo') 2117 for i in range(10): 2118 etree.SubElement(e, 'a%s' % i) 2119 for i in range(10): 2120 self.assertEquals( 2121 i, 2122 e.index(e[i])) 2123 self.assertEquals( 2124 3, e.index(e[3], 3)) 2125 self.assertRaises( 2126 ValueError, e.index, e[3], 4) 2127 self.assertRaises( 2128 ValueError, e.index, e[3], 0, 2) 2129 self.assertRaises( 2130 ValueError, e.index, e[8], 0, -3) 2131 self.assertRaises( 2132 ValueError, e.index, e[8], -5, -3) 2133 self.assertEquals( 2134 8, e.index(e[8], 0, -1)) 2135 self.assertEquals( 2136 8, e.index(e[8], -12, -1)) 2137 self.assertEquals( 2138 0, e.index(e[0], -12, -1))
2139
2140 - def test_replace(self):
2141 etree = self.etree 2142 e = etree.Element('foo') 2143 for i in range(10): 2144 el = etree.SubElement(e, 'a%s' % i) 2145 el.text = "text%d" % i 2146 el.tail = "tail%d" % i 2147 2148 child0 = e[0] 2149 child1 = e[1] 2150 child2 = e[2] 2151 2152 e.replace(e[0], e[1]) 2153 self.assertEquals( 2154 9, len(e)) 2155 self.assertEquals( 2156 child1, e[0]) 2157 self.assertEquals( 2158 child1.text, "text1") 2159 self.assertEquals( 2160 child1.tail, "tail1") 2161 self.assertEquals( 2162 child0.tail, "tail0") 2163 self.assertEquals( 2164 child2, e[1]) 2165 2166 e.replace(e[-1], e[0]) 2167 self.assertEquals( 2168 child1, e[-1]) 2169 self.assertEquals( 2170 child1.text, "text1") 2171 self.assertEquals( 2172 child1.tail, "tail1") 2173 self.assertEquals( 2174 child2, e[0])
2175
2176 - def test_replace_new(self):
2177 etree = self.etree 2178 e = etree.Element('foo') 2179 for i in range(10): 2180 etree.SubElement(e, 'a%s' % i) 2181 2182 new_element = etree.Element("test") 2183 new_element.text = "TESTTEXT" 2184 new_element.tail = "TESTTAIL" 2185 child1 = e[1] 2186 e.replace(e[0], new_element) 2187 self.assertEquals( 2188 new_element, e[0]) 2189 self.assertEquals( 2190 "TESTTEXT", 2191 e[0].text) 2192 self.assertEquals( 2193 "TESTTAIL", 2194 e[0].tail) 2195 self.assertEquals( 2196 child1, e[1])
2197
2198 - def test_setslice_all_empty_reversed(self):
2199 Element = self.etree.Element 2200 SubElement = self.etree.SubElement 2201 2202 a = Element('a') 2203 2204 e = Element('e') 2205 f = Element('f') 2206 g = Element('g') 2207 2208 s = [e, f, g] 2209 a[::-1] = s 2210 self.assertEquals( 2211 [g, f, e], 2212 list(a))
2213
2214 - def test_setslice_step(self):
2215 Element = self.etree.Element 2216 SubElement = self.etree.SubElement 2217 2218 a = Element('a') 2219 b = SubElement(a, 'b') 2220 c = SubElement(a, 'c') 2221 d = SubElement(a, 'd') 2222 e = SubElement(a, 'e') 2223 2224 x = Element('x') 2225 y = Element('y') 2226 2227 a[1::2] = [x, y] 2228 self.assertEquals( 2229 [b, x, d, y], 2230 list(a))
2231
2232 - def test_setslice_step_negative(self):
2233 Element = self.etree.Element 2234 SubElement = self.etree.SubElement 2235 2236 a = Element('a') 2237 b = SubElement(a, 'b') 2238 c = SubElement(a, 'c') 2239 d = SubElement(a, 'd') 2240 e = SubElement(a, 'e') 2241 2242 x = Element('x') 2243 y = Element('y') 2244 2245 a[1::-1] = [x, y] 2246 self.assertEquals( 2247 [y, x, d, e], 2248 list(a))
2249
2250 - def test_setslice_step_negative2(self):
2251 Element = self.etree.Element 2252 SubElement = self.etree.SubElement 2253 2254 a = Element('a') 2255 b = SubElement(a, 'b') 2256 c = SubElement(a, 'c') 2257 d = SubElement(a, 'd') 2258 e = SubElement(a, 'e') 2259 2260 x = Element('x') 2261 y = Element('y') 2262 2263 a[::-2] = [x, y] 2264 self.assertEquals( 2265 [b, y, d, x], 2266 list(a))
2267
2268 - def test_setslice_step_overrun(self):
2269 Element = self.etree.Element 2270 SubElement = self.etree.SubElement 2271 try: 2272 slice 2273 except NameError: 2274 print("slice() not found") 2275 return 2276 2277 a = Element('a') 2278 b = SubElement(a, 'b') 2279 c = SubElement(a, 'c') 2280 d = SubElement(a, 'd') 2281 e = SubElement(a, 'e') 2282 2283 x = Element('x') 2284 y = Element('y') 2285 z = Element('z') 2286 2287 self.assertRaises( 2288 ValueError, 2289 operator.setitem, a, slice(1,None,2), [x, y, z]) 2290 2291 self.assertEquals( 2292 [b, c, d, e], 2293 list(a))
2294
2295 - def test_sourceline_XML(self):
2296 XML = self.etree.XML 2297 root = XML(_bytes('''<?xml version="1.0"?> 2298 <root><test> 2299 2300 <bla/></test> 2301 </root> 2302 ''')) 2303 2304 self.assertEquals( 2305 [2, 2, 4], 2306 [ el.sourceline for el in root.getiterator() ])
2307
2308 - def test_sourceline_parse(self):
2309 parse = self.etree.parse 2310 tree = parse(fileInTestDir('include/test_xinclude.xml')) 2311 2312 self.assertEquals( 2313 [1, 2, 3], 2314 [ el.sourceline for el in tree.getiterator() ])
2315
2316 - def test_sourceline_iterparse_end(self):
2317 iterparse = self.etree.iterparse 2318 lines = [ el.sourceline for (event, el) in 2319 iterparse(fileInTestDir('include/test_xinclude.xml')) ] 2320 2321 self.assertEquals( 2322 [2, 3, 1], 2323 lines)
2324
2325 - def test_sourceline_iterparse_start(self):
2326 iterparse = self.etree.iterparse 2327 lines = [ el.sourceline for (event, el) in 2328 iterparse(fileInTestDir('include/test_xinclude.xml'), 2329 events=("start",)) ] 2330 2331 self.assertEquals( 2332 [1, 2, 3], 2333 lines)
2334
2335 - def test_sourceline_element(self):
2336 Element = self.etree.Element 2337 SubElement = self.etree.SubElement 2338 el = Element("test") 2339 self.assertEquals(None, el.sourceline) 2340 2341 child = SubElement(el, "test") 2342 self.assertEquals(None, el.sourceline) 2343 self.assertEquals(None, child.sourceline)
2344
2345 - def test_XML_base_url_docinfo(self):
2346 etree = self.etree 2347 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2348 docinfo = root.getroottree().docinfo 2349 self.assertEquals(docinfo.URL, "http://no/such/url")
2350
2351 - def test_XML_set_base_url_docinfo(self):
2352 etree = self.etree 2353 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2354 docinfo = root.getroottree().docinfo 2355 self.assertEquals(docinfo.URL, "http://no/such/url") 2356 docinfo.URL = "https://secret/url" 2357 self.assertEquals(docinfo.URL, "https://secret/url")
2358
2359 - def test_parse_stringio_base_url(self):
2360 etree = self.etree 2361 tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url") 2362 docinfo = tree.docinfo 2363 self.assertEquals(docinfo.URL, "http://no/such/url")
2364
2365 - def test_parse_base_url_docinfo(self):
2366 etree = self.etree 2367 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 2368 base_url="http://no/such/url") 2369 docinfo = tree.docinfo 2370 self.assertEquals(docinfo.URL, "http://no/such/url")
2371
2372 - def test_HTML_base_url_docinfo(self):
2373 etree = self.etree 2374 root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url") 2375 docinfo = root.getroottree().docinfo 2376 self.assertEquals(docinfo.URL, "http://no/such/url")
2377
2378 - def test_docinfo_public(self):
2379 etree = self.etree 2380 xml_header = '<?xml version="1.0" encoding="ascii"?>' 2381 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 2382 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 2383 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) 2384 2385 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 2386 2387 tree = etree.parse(BytesIO(xml)) 2388 docinfo = tree.docinfo 2389 self.assertEquals(docinfo.encoding, "ascii") 2390 self.assertEquals(docinfo.xml_version, "1.0") 2391 self.assertEquals(docinfo.public_id, pub_id) 2392 self.assertEquals(docinfo.system_url, sys_id) 2393 self.assertEquals(docinfo.root_name, 'html') 2394 self.assertEquals(docinfo.doctype, doctype_string)
2395
2396 - def test_docinfo_system(self):
2397 etree = self.etree 2398 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' 2399 sys_id = "some.dtd" 2400 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id 2401 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 2402 2403 tree = etree.parse(BytesIO(xml)) 2404 docinfo = tree.docinfo 2405 self.assertEquals(docinfo.encoding, "UTF-8") 2406 self.assertEquals(docinfo.xml_version, "1.0") 2407 self.assertEquals(docinfo.public_id, None) 2408 self.assertEquals(docinfo.system_url, sys_id) 2409 self.assertEquals(docinfo.root_name, 'html') 2410 self.assertEquals(docinfo.doctype, doctype_string)
2411
2412 - def test_docinfo_empty(self):
2413 etree = self.etree 2414 xml = _bytes('<html><body></body></html>') 2415 tree = etree.parse(BytesIO(xml)) 2416 docinfo = tree.docinfo 2417 self.assertEquals(docinfo.encoding, "UTF-8") 2418 self.assertEquals(docinfo.xml_version, "1.0") 2419 self.assertEquals(docinfo.public_id, None) 2420 self.assertEquals(docinfo.system_url, None) 2421 self.assertEquals(docinfo.root_name, 'html') 2422 self.assertEquals(docinfo.doctype, '')
2423
2424 - def test_docinfo_name_only(self):
2425 etree = self.etree 2426 xml = _bytes('<!DOCTYPE root><root></root>') 2427 tree = etree.parse(BytesIO(xml)) 2428 docinfo = tree.docinfo 2429 self.assertEquals(docinfo.encoding, "UTF-8") 2430 self.assertEquals(docinfo.xml_version, "1.0") 2431 self.assertEquals(docinfo.public_id, None) 2432 self.assertEquals(docinfo.system_url, None) 2433 self.assertEquals(docinfo.root_name, 'root') 2434 self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')
2435
2436 - def test_doctype_name_only_roundtrip(self):
2437 etree = self.etree 2438 xml = _bytes('<!DOCTYPE root>\n<root/>') 2439 tree = etree.parse(BytesIO(xml)) 2440 self.assertEquals(xml, etree.tostring(tree))
2441
2442 - def test_doctype_output_override(self):
2443 etree = self.etree 2444 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 2445 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 2446 doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)) 2447 2448 xml = _bytes('<!DOCTYPE root>\n<root/>') 2449 tree = etree.parse(BytesIO(xml)) 2450 self.assertEquals(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string), 2451 etree.tostring(tree, doctype=doctype_string))
2452
2453 - def test_xml_base(self):
2454 etree = self.etree 2455 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2456 self.assertEquals(root.base, "http://no/such/url") 2457 self.assertEquals( 2458 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2459 root.base = "https://secret/url" 2460 self.assertEquals(root.base, "https://secret/url") 2461 self.assertEquals( 2462 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2463 "https://secret/url")
2464
2465 - def test_xml_base_attribute(self):
2466 etree = self.etree 2467 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2468 self.assertEquals(root.base, "http://no/such/url") 2469 self.assertEquals( 2470 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2471 root.set('{http://www.w3.org/XML/1998/namespace}base', 2472 "https://secret/url") 2473 self.assertEquals(root.base, "https://secret/url") 2474 self.assertEquals( 2475 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2476 "https://secret/url")
2477
2478 - def test_html_base(self):
2479 etree = self.etree 2480 root = etree.HTML(_bytes("<html><body></body></html>"), 2481 base_url="http://no/such/url") 2482 self.assertEquals(root.base, "http://no/such/url")
2483
2484 - def test_html_base_tag(self):
2485 etree = self.etree 2486 root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>')) 2487 self.assertEquals(root.base, "http://no/such/url")
2488
2489 - def test_parse_fileobject_unicode(self):
2490 # parse from a file object that returns unicode strings 2491 f = LargeFileLikeUnicode() 2492 tree = self.etree.parse(f) 2493 root = tree.getroot() 2494 self.assert_(root.tag.endswith('root'))
2495
2496 - def test_dtd_io(self):
2497 # check that DTDs that go in also go back out 2498 xml = _bytes('''\ 2499 <!DOCTYPE test SYSTEM "test.dtd" [ 2500 <!ENTITY entity "tasty"> 2501 <!ELEMENT test (a)> 2502 <!ELEMENT a (#PCDATA)> 2503 ]> 2504 <test><a>test-test</a></test>\ 2505 ''') 2506 tree = self.etree.parse(BytesIO(xml)) 2507 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")), 2508 xml.replace(_bytes(" "), _bytes("")))
2509
2510 - def test_byte_zero(self):
2511 Element = self.etree.Element 2512 2513 a = Element('a') 2514 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho') 2515 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho') 2516 2517 self.assertRaises(ValueError, Element, 'ha\0ho')
2518
2519 - def test_unicode_byte_zero(self):
2520 Element = self.etree.Element 2521 2522 a = Element('a') 2523 self.assertRaises(ValueError, setattr, a, "text", 2524 _str('ha\0ho')) 2525 self.assertRaises(ValueError, setattr, a, "tail", 2526 _str('ha\0ho')) 2527 2528 self.assertRaises(ValueError, Element, 2529 _str('ha\0ho'))
2530
2531 - def test_byte_invalid(self):
2532 Element = self.etree.Element 2533 2534 a = Element('a') 2535 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho') 2536 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho') 2537 2538 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho') 2539 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho') 2540 2541 self.assertRaises(ValueError, Element, 'ha\x07ho') 2542 self.assertRaises(ValueError, Element, 'ha\x02ho')
2543
2544 - def test_unicode_byte_invalid(self):
2545 Element = self.etree.Element 2546 2547 a = Element('a') 2548 self.assertRaises(ValueError, setattr, a, "text", 2549 _str('ha\x07ho')) 2550 self.assertRaises(ValueError, setattr, a, "text", 2551 _str('ha\x02ho')) 2552 2553 self.assertRaises(ValueError, setattr, a, "tail", 2554 _str('ha\x07ho')) 2555 self.assertRaises(ValueError, setattr, a, "tail", 2556 _str('ha\x02ho')) 2557 2558 self.assertRaises(ValueError, Element, 2559 _str('ha\x07ho')) 2560 self.assertRaises(ValueError, Element, 2561 _str('ha\x02ho'))
2562
2563 - def test_unicode_byte_invalid_sequence(self):
2564 Element = self.etree.Element 2565 2566 a = Element('a') 2567 self.assertRaises(ValueError, setattr, a, "text", 2568 _str('ha\u1234\x07ho')) 2569 self.assertRaises(ValueError, setattr, a, "text", 2570 _str('ha\u1234\x02ho')) 2571 2572 self.assertRaises(ValueError, setattr, a, "tail", 2573 _str('ha\u1234\x07ho')) 2574 self.assertRaises(ValueError, setattr, a, "tail", 2575 _str('ha\u1234\x02ho')) 2576 2577 self.assertRaises(ValueError, Element, 2578 _str('ha\u1234\x07ho')) 2579 self.assertRaises(ValueError, Element, 2580 _str('ha\u1234\x02ho'))
2581
2582 - def test_encoding_tostring_utf16(self):
2583 # ElementTree fails to serialize this 2584 tostring = self.etree.tostring 2585 Element = self.etree.Element 2586 SubElement = self.etree.SubElement 2587 2588 a = Element('a') 2589 b = SubElement(a, 'b') 2590 c = SubElement(a, 'c') 2591 2592 result = tostring(a, encoding='UTF-16') 2593 self.assertEquals(_bytes('<a><b></b><c></c></a>'), 2594 canonicalize(result))
2595
2596 - def test_tostring_none(self):
2597 # ElementTree raises an AssertionError here 2598 tostring = self.etree.tostring 2599 self.assertRaises(TypeError, self.etree.tostring, None)
2600
2601 - def test_tostring_pretty(self):
2602 tostring = self.etree.tostring 2603 Element = self.etree.Element 2604 SubElement = self.etree.SubElement 2605 2606 a = Element('a') 2607 b = SubElement(a, 'b') 2608 c = SubElement(a, 'c') 2609 2610 result = tostring(a) 2611 self.assertEquals(result, _bytes("<a><b/><c/></a>")) 2612 2613 result = tostring(a, pretty_print=False) 2614 self.assertEquals(result, _bytes("<a><b/><c/></a>")) 2615 2616 result = tostring(a, pretty_print=True) 2617 self.assertEquals(result, _bytes("<a>\n <b/>\n <c/>\n</a>\n"))
2618
2619 - def test_tostring_with_tail(self):
2620 tostring = self.etree.tostring 2621 Element = self.etree.Element 2622 SubElement = self.etree.SubElement 2623 2624 a = Element('a') 2625 a.tail = "aTAIL" 2626 b = SubElement(a, 'b') 2627 b.tail = "bTAIL" 2628 c = SubElement(a, 'c') 2629 2630 result = tostring(a) 2631 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL")) 2632 2633 result = tostring(a, with_tail=False) 2634 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>")) 2635 2636 result = tostring(a, with_tail=True) 2637 self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2638
2639 - def test_standalone(self):
2640 tostring = self.etree.tostring 2641 XML = self.etree.XML 2642 ElementTree = self.etree.ElementTree 2643 Element = self.etree.Element 2644 2645 tree = Element("root").getroottree() 2646 self.assertEquals(None, tree.docinfo.standalone) 2647 2648 tree = XML(_bytes("<root/>")).getroottree() 2649 self.assertEquals(None, tree.docinfo.standalone) 2650 2651 tree = XML(_bytes( 2652 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>" 2653 )).getroottree() 2654 self.assertEquals(True, tree.docinfo.standalone) 2655 2656 tree = XML(_bytes( 2657 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>" 2658 )).getroottree() 2659 self.assertEquals(False, tree.docinfo.standalone)
2660
2661 - def test_tostring_standalone(self):
2662 tostring = self.etree.tostring 2663 XML = self.etree.XML 2664 ElementTree = self.etree.ElementTree 2665 2666 root = XML(_bytes("<root/>")) 2667 2668 tree = ElementTree(root) 2669 self.assertEquals(None, tree.docinfo.standalone) 2670 2671 result = tostring(root, xml_declaration=True, encoding="ASCII") 2672 self.assertEquals(result, _bytes( 2673 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 2674 2675 result = tostring(root, xml_declaration=True, encoding="ASCII", 2676 standalone=True) 2677 self.assertEquals(result, _bytes( 2678 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) 2679 2680 tree = ElementTree(XML(result)) 2681 self.assertEquals(True, tree.docinfo.standalone) 2682 2683 result = tostring(root, xml_declaration=True, encoding="ASCII", 2684 standalone=False) 2685 self.assertEquals(result, _bytes( 2686 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>")) 2687 2688 tree = ElementTree(XML(result)) 2689 self.assertEquals(False, tree.docinfo.standalone)
2690
2691 - def test_tostring_standalone_in_out(self):
2692 tostring = self.etree.tostring 2693 XML = self.etree.XML 2694 ElementTree = self.etree.ElementTree 2695 2696 root = XML(_bytes( 2697 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>")) 2698 2699 tree = ElementTree(root) 2700 self.assertEquals(True, tree.docinfo.standalone) 2701 2702 result = tostring(root, xml_declaration=True, encoding="ASCII") 2703 self.assertEquals(result, _bytes( 2704 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 2705 2706 result = tostring(root, xml_declaration=True, encoding="ASCII", 2707 standalone=True) 2708 self.assertEquals(result, _bytes( 2709 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2710
2711 - def test_tostring_method_text_encoding(self):
2712 tostring = self.etree.tostring 2713 Element = self.etree.Element 2714 SubElement = self.etree.SubElement 2715 2716 a = Element('a') 2717 a.text = "A" 2718 a.tail = "tail" 2719 b = SubElement(a, 'b') 2720 b.text = "B" 2721 b.tail = _str("Søk på nettet") 2722 c = SubElement(a, 'c') 2723 c.text = "C" 2724 2725 result = tostring(a, method="text", encoding="UTF-16") 2726 2727 self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"), 2728 result)
2729
2730 - def test_tostring_method_text_unicode(self):
2731 tostring = self.etree.tostring 2732 Element = self.etree.Element 2733 SubElement = self.etree.SubElement 2734 2735 a = Element('a') 2736 a.text = _str('Søk på nettetA') 2737 a.tail = "tail" 2738 b = SubElement(a, 'b') 2739 b.text = "B" 2740 b.tail = _str('Søk på nettetB') 2741 c = SubElement(a, 'c') 2742 c.text = "C" 2743 2744 self.assertRaises(UnicodeEncodeError, 2745 tostring, a, method="text") 2746 2747 self.assertEquals( 2748 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'), 2749 tostring(a, encoding="UTF-8", method="text"))
2750
2751 - def test_tounicode(self):
2752 tounicode = self.etree.tounicode 2753 Element = self.etree.Element 2754 SubElement = self.etree.SubElement 2755 2756 a = Element('a') 2757 b = SubElement(a, 'b') 2758 c = SubElement(a, 'c') 2759 2760 self.assert_(isinstance(tounicode(a), _unicode)) 2761 self.assertEquals(_bytes('<a><b></b><c></c></a>'), 2762 canonicalize(tounicode(a)))
2763
2764 - def test_tounicode_element(self):
2765 tounicode = self.etree.tounicode 2766 Element = self.etree.Element 2767 SubElement = self.etree.SubElement 2768 2769 a = Element('a') 2770 b = SubElement(a, 'b') 2771 c = SubElement(a, 'c') 2772 d = SubElement(c, 'd') 2773 self.assert_(isinstance(tounicode(b), _unicode)) 2774 self.assert_(isinstance(tounicode(c), _unicode)) 2775 self.assertEquals(_bytes('<b></b>'), 2776 canonicalize(tounicode(b))) 2777 self.assertEquals(_bytes('<c><d></d></c>'), 2778 canonicalize(tounicode(c)))
2779
2780 - def test_tounicode_none(self):
2781 tounicode = self.etree.tounicode 2782 self.assertRaises(TypeError, self.etree.tounicode, None)
2783
2784 - def test_tounicode_element_tail(self):
2785 tounicode = self.etree.tounicode 2786 Element = self.etree.Element 2787 SubElement = self.etree.SubElement 2788 2789 a = Element('a') 2790 b = SubElement(a, 'b') 2791 c = SubElement(a, 'c') 2792 d = SubElement(c, 'd') 2793 b.tail = 'Foo' 2794 2795 self.assert_(isinstance(tounicode(b), _unicode)) 2796 self.assert_(tounicode(b) == '<b/>Foo' or 2797 tounicode(b) == '<b />Foo')
2798
2799 - def test_tounicode_pretty(self):
2800 tounicode = self.etree.tounicode 2801 Element = self.etree.Element 2802 SubElement = self.etree.SubElement 2803 2804 a = Element('a') 2805 b = SubElement(a, 'b') 2806 c = SubElement(a, 'c') 2807 2808 result = tounicode(a) 2809 self.assertEquals(result, "<a><b/><c/></a>") 2810 2811 result = tounicode(a, pretty_print=False) 2812 self.assertEquals(result, "<a><b/><c/></a>") 2813 2814 result = tounicode(a, pretty_print=True) 2815 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2816
2817 - def test_tostring_unicode(self):
2818 tostring = self.etree.tostring 2819 Element = self.etree.Element 2820 SubElement = self.etree.SubElement 2821 2822 a = Element('a') 2823 b = SubElement(a, 'b') 2824 c = SubElement(a, 'c') 2825 2826 self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode)) 2827 self.assertEquals(_bytes('<a><b></b><c></c></a>'), 2828 canonicalize(tostring(a, encoding=_unicode)))
2829
2830 - def test_tostring_unicode_element(self):
2831 tostring = self.etree.tostring 2832 Element = self.etree.Element 2833 SubElement = self.etree.SubElement 2834 2835 a = Element('a') 2836 b = SubElement(a, 'b') 2837 c = SubElement(a, 'c') 2838 d = SubElement(c, 'd') 2839 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode)) 2840 self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode)) 2841 self.assertEquals(_bytes('<b></b>'), 2842 canonicalize(tostring(b, encoding=_unicode))) 2843 self.assertEquals(_bytes('<c><d></d></c>'), 2844 canonicalize(tostring(c, encoding=_unicode)))
2845
2846 - def test_tostring_unicode_none(self):
2847 tostring = self.etree.tostring 2848 self.assertRaises(TypeError, self.etree.tostring, 2849 None, encoding=_unicode)
2850
2851 - def test_tostring_unicode_element_tail(self):
2852 tostring = self.etree.tostring 2853 Element = self.etree.Element 2854 SubElement = self.etree.SubElement 2855 2856 a = Element('a') 2857 b = SubElement(a, 'b') 2858 c = SubElement(a, 'c') 2859 d = SubElement(c, 'd') 2860 b.tail = 'Foo' 2861 2862 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode)) 2863 self.assert_(tostring(b, encoding=_unicode) == '<b/>Foo' or 2864 tostring(b, encoding=_unicode) == '<b />Foo')
2865
2866 - def test_tostring_unicode_pretty(self):
2867 tostring = self.etree.tostring 2868 Element = self.etree.Element 2869 SubElement = self.etree.SubElement 2870 2871 a = Element('a') 2872 b = SubElement(a, 'b') 2873 c = SubElement(a, 'c') 2874 2875 result = tostring(a, encoding=_unicode) 2876 self.assertEquals(result, "<a><b/><c/></a>") 2877 2878 result = tostring(a, encoding=_unicode, pretty_print=False) 2879 self.assertEquals(result, "<a><b/><c/></a>") 2880 2881 result = tostring(a, encoding=_unicode, pretty_print=True) 2882 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2883 2884 # helper methods 2885
2886 - def _writeElement(self, element, encoding='us-ascii', compression=0):
2887 """Write out element for comparison. 2888 """ 2889 ElementTree = self.etree.ElementTree 2890 f = BytesIO() 2891 tree = ElementTree(element=element) 2892 tree.write(f, encoding=encoding, compression=compression) 2893 data = f.getvalue() 2894 if compression: 2895 data = zlib.decompress(data) 2896 return canonicalize(data)
2897 2898
2899 -class XIncludeTestCase(HelperTestCase):
2900 - def test_xinclude_text(self):
2901 filename = fileInTestDir('test_broken.xml') 2902 root = etree.XML(_bytes('''\ 2903 <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 2904 <xi:include href="%s" parse="text"/> 2905 </doc> 2906 ''' % filename)) 2907 old_text = root.text 2908 content = open(filename).read() 2909 old_tail = root[0].tail 2910 2911 self.include( etree.ElementTree(root) ) 2912 self.assertEquals(old_text + content + old_tail, 2913 root.text)
2914
2915 - def test_xinclude(self):
2916 tree = etree.parse(fileInTestDir('include/test_xinclude.xml')) 2917 self.assertNotEquals( 2918 'a', 2919 tree.getroot()[1].tag) 2920 # process xincludes 2921 self.include( tree ) 2922 # check whether we find it replaced with included data 2923 self.assertEquals( 2924 'a', 2925 tree.getroot()[1].tag)
2926
2927 - def test_xinclude_resolver(self):
2928 class res(etree.Resolver): 2929 include_text = open(fileInTestDir('test.xml')).read() 2930 called = {} 2931 def resolve(self, url, id, context): 2932 if url.endswith(".dtd"): 2933 self.called["dtd"] = True 2934 return self.resolve_filename( 2935 fileInTestDir('test.dtd'), context) 2936 elif url.endswith("test_xinclude.xml"): 2937 self.called["input"] = True 2938 return None # delegate to default resolver 2939 else: 2940 self.called["include"] = True 2941 return self.resolve_string(self.include_text, context)
2942 2943 res_instance = res() 2944 parser = etree.XMLParser(load_dtd = True) 2945 parser.resolvers.add(res_instance) 2946 2947 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 2948 parser = parser) 2949 2950 self.include(tree) 2951 2952 called = list(res_instance.called.items()) 2953 called.sort() 2954 self.assertEquals( 2955 [("dtd", True), ("include", True), ("input", True)], 2956 called) 2957
2958 -class ETreeXIncludeTestCase(XIncludeTestCase):
2959 - def include(self, tree):
2960 tree.xinclude()
2961 2962
2963 -class ElementIncludeTestCase(XIncludeTestCase):
2964 from lxml import ElementInclude
2965 - def include(self, tree):
2966 self.ElementInclude.include(tree.getroot())
2967 2968
2969 -class ETreeC14NTestCase(HelperTestCase):
2970 - def test_c14n(self):
2971 tree = self.parse(_bytes('<a><b/></a>')) 2972 f = BytesIO() 2973 tree.write_c14n(f) 2974 s = f.getvalue() 2975 self.assertEquals(_bytes('<a><b></b></a>'), 2976 s)
2977
2978 - def test_c14n_gzip(self):
2979 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 2980 f = BytesIO() 2981 tree.write_c14n(f, compression=9) 2982 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read() 2983 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'), 2984 s)
2985
2986 - def test_c14n_file(self):
2987 tree = self.parse(_bytes('<a><b/></a>')) 2988 handle, filename = tempfile.mkstemp() 2989 try: 2990 tree.write_c14n(filename) 2991 f = open(filename, 'rb') 2992 data = f.read() 2993 f.close() 2994 finally: 2995 os.close(handle) 2996 os.remove(filename) 2997 self.assertEquals(_bytes('<a><b></b></a>'), 2998 data)
2999
3000 - def test_c14n_file_gzip(self):
3001 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3002 handle, filename = tempfile.mkstemp() 3003 try: 3004 tree.write_c14n(filename, compression=9) 3005 f = gzip.open(filename, 'rb') 3006 data = f.read() 3007 f.close() 3008 finally: 3009 os.close(handle) 3010 os.remove(filename) 3011 self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'), 3012 data)
3013
3014 - def test_c14n_with_comments(self):
3015 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 3016 f = BytesIO() 3017 tree.write_c14n(f) 3018 s = f.getvalue() 3019 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 3020 s) 3021 f = BytesIO() 3022 tree.write_c14n(f, with_comments=True) 3023 s = f.getvalue() 3024 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 3025 s) 3026 f = BytesIO() 3027 tree.write_c14n(f, with_comments=False) 3028 s = f.getvalue() 3029 self.assertEquals(_bytes('<a><b></b></a>'), 3030 s)
3031
3033 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 3034 s = etree.tostring(tree, method='c14n') 3035 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 3036 s) 3037 s = etree.tostring(tree, method='c14n', with_comments=True) 3038 self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 3039 s) 3040 s = etree.tostring(tree, method='c14n', with_comments=False) 3041 self.assertEquals(_bytes('<a><b></b></a>'), 3042 s)
3043
3045 tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 3046 s = etree.tostring(tree.getroot(), method='c14n') 3047 self.assertEquals(_bytes('<a><!--ho--><b></b></a>'), 3048 s) 3049 s = etree.tostring(tree.getroot(), method='c14n', with_comments=True) 3050 self.assertEquals(_bytes('<a><!--ho--><b></b></a>'), 3051 s) 3052 s = etree.tostring(tree.getroot(), method='c14n', with_comments=False) 3053 self.assertEquals(_bytes('<a><b></b></a>'), 3054 s)
3055
3056 - def test_c14n_exclusive(self):
3057 tree = self.parse(_bytes( 3058 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3059 f = BytesIO() 3060 tree.write_c14n(f) 3061 s = f.getvalue() 3062 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3063 s) 3064 f = BytesIO() 3065 tree.write_c14n(f, exclusive=False) 3066 s = f.getvalue() 3067 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3068 s) 3069 f = BytesIO() 3070 tree.write_c14n(f, exclusive=True) 3071 s = f.getvalue() 3072 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3073 s)
3074
3076 tree = self.parse(_bytes( 3077 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3078 s = etree.tostring(tree, method='c14n') 3079 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3080 s) 3081 s = etree.tostring(tree, method='c14n', exclusive=False) 3082 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3083 s) 3084 s = etree.tostring(tree, method='c14n', exclusive=True) 3085 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3086 s)
3087
3089 tree = self.parse(_bytes( 3090 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3091 s = etree.tostring(tree.getroot(), method='c14n') 3092 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3093 s) 3094 s = etree.tostring(tree.getroot(), method='c14n', exclusive=False) 3095 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3096 s) 3097 s = etree.tostring(tree.getroot(), method='c14n', exclusive=True) 3098 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3099 s) 3100 3101 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=False) 3102 self.assertEquals(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'), 3103 s) 3104 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True) 3105 self.assertEquals(_bytes('<z:b xmlns:z="http://cde"></z:b>'), 3106 s)
3107 3108
3109 -class ETreeWriteTestCase(HelperTestCase):
3110 - def test_write(self):
3111 tree = self.parse(_bytes('<a><b/></a>')) 3112 f = BytesIO() 3113 tree.write(f) 3114 s = f.getvalue() 3115 self.assertEquals(_bytes('<a><b/></a>'), 3116 s)
3117
3118 - def test_write_gzip(self):
3119 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3120 f = BytesIO() 3121 tree.write(f, compression=9) 3122 s = gzip.GzipFile(fileobj=BytesIO(f.getvalue())).read() 3123 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3124 s)
3125
3126 - def test_write_gzip_level(self):
3127 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3128 f = BytesIO() 3129 tree.write(f, compression=0) 3130 s0 = f.getvalue() 3131 3132 f = BytesIO() 3133 tree.write(f) 3134 self.assertEquals(f.getvalue(), s0) 3135 3136 f = BytesIO() 3137 tree.write(f, compression=1) 3138 s = f.getvalue() 3139 self.assert_(len(s) <= len(s0)) 3140 s1 = gzip.GzipFile(fileobj=BytesIO(s)).read() 3141 3142 f = BytesIO() 3143 tree.write(f, compression=9) 3144 s = f.getvalue() 3145 self.assert_(len(s) <= len(s0)) 3146 s9 = gzip.GzipFile(fileobj=BytesIO(s)).read() 3147 3148 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3149 s0) 3150 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3151 s1) 3152 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3153 s9)
3154
3155 - def test_write_file(self):
3156 tree = self.parse(_bytes('<a><b/></a>')) 3157 handle, filename = tempfile.mkstemp() 3158 try: 3159 tree.write(filename) 3160 f = open(filename, 'rb') 3161 data = f.read() 3162 f.close() 3163 finally: 3164 os.close(handle) 3165 os.remove(filename) 3166 self.assertEquals(_bytes('<a><b/></a>'), 3167 data)
3168
3169 - def test_write_file_gzip(self):
3170 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3171 handle, filename = tempfile.mkstemp() 3172 try: 3173 tree.write(filename, compression=9) 3174 f = gzip.open(filename, 'rb') 3175 data = f.read() 3176 f.close() 3177 finally: 3178 os.close(handle) 3179 os.remove(filename) 3180 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3181 data)
3182
3183 - def test_write_file_gzip_parse(self):
3184 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3185 handle, filename = tempfile.mkstemp() 3186 try: 3187 tree.write(filename, compression=9) 3188 data = etree.tostring(etree.parse(filename)) 3189 finally: 3190 os.close(handle) 3191 os.remove(filename) 3192 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3193 data)
3194
3196 tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 3197 handle, filename = tempfile.mkstemp() 3198 try: 3199 tree.write(filename, compression=9) 3200 data = etree.tostring(etree.parse( 3201 gzip.GzipFile(filename))) 3202 finally: 3203 os.close(handle) 3204 os.remove(filename) 3205 self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'), 3206 data)
3207
3208 -class ETreeErrorLogTest(HelperTestCase):
3209 etree = etree 3210
3211 - def test_parse_error_logging(self):
3212 parse = self.etree.parse 3213 f = BytesIO('<a><b></c></b></a>') 3214 self.etree.clear_error_log() 3215 try: 3216 parse(f) 3217 logs = None 3218 except SyntaxError: 3219 e = sys.exc_info()[1] 3220 logs = e.error_log 3221 f.close() 3222 self.assert_([ log for log in logs 3223 if 'mismatch' in log.message ]) 3224 self.assert_([ log for log in logs 3225 if 'PARSER' in log.domain_name]) 3226 self.assert_([ log for log in logs 3227 if 'ERR_TAG_NAME_MISMATCH' in log.type_name ]) 3228 self.assert_([ log for log in logs 3229 if 1 == log.line ]) 3230 self.assert_([ log for log in logs 3231 if 15 == log.column ])
3232
3233 - def _test_python_error_logging(self):
3234 """This can't really be tested as long as there isn't a way to 3235 reset the logging setup ... 3236 """ 3237 parse = self.etree.parse 3238 3239 messages = [] 3240 class Logger(self.etree.PyErrorLog): 3241 def log(self, entry, message, *args): 3242 messages.append(message)
3243 3244 self.etree.use_global_python_log(Logger()) 3245 f = BytesIO('<a><b></c></b></a>') 3246 try: 3247 parse(f) 3248 except SyntaxError: 3249 pass 3250 f.close() 3251 3252 self.assert_([ message for message in messages 3253 if 'mismatch' in message ]) 3254 self.assert_([ message for message in messages 3255 if ':PARSER:' in message]) 3256 self.assert_([ message for message in messages 3257 if ':ERR_TAG_NAME_MISMATCH:' in message ]) 3258 self.assert_([ message for message in messages 3259 if ':1:15:' in message ]) 3260
3261 -def test_suite():
3262 suite = unittest.TestSuite() 3263 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)]) 3264 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)]) 3265 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)]) 3266 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)]) 3267 suite.addTests([unittest.makeSuite(ETreeWriteTestCase)]) 3268 suite.addTests([unittest.makeSuite(ETreeErrorLogTest)]) 3269 suite.addTests( 3270 [make_doctest('../../../doc/tutorial.txt')]) 3271 suite.addTests( 3272 [make_doctest('../../../doc/api.txt')]) 3273 suite.addTests( 3274 [make_doctest('../../../doc/FAQ.txt')]) 3275 suite.addTests( 3276 [make_doctest('../../../doc/parsing.txt')]) 3277 suite.addTests( 3278 [make_doctest('../../../doc/resolvers.txt')]) 3279 return suite
3280 3281 if __name__ == '__main__': 3282 print('to test use test.py %s' % __file__) 3283