lxml.tests.test

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, read_file 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

148 - def test_subelement_attribute_invalid(self):

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

173 - def test_qname_namespace_localname(self):

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_has_key(self):

211 # ET in Py 3.x has no "attrib.has_key()" method 212 XML = self.etree.XML 213 214 root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 215 self.assertEquals( 216 True, root.attrib.has_key('bar')) 217 self.assertEquals( 218 False, root.attrib.has_key('baz')) 219 self.assertEquals( 220 False, root.attrib.has_key('hah')) 221 self.assertEquals( 222 True, 223 root.attrib.has_key('{http://ns.codespeak.net/test}baz'))

224

225 - def test_attribute_set(self):

226 Element = self.etree.Element 227 root = Element("root") 228 root.set("attr", "TEST") 229 self.assertEquals("TEST", root.get("attr"))

230

231 - def test_attribute_set_invalid(self):

232 # ElementTree accepts arbitrary attribute values 233 # lxml.etree allows only strings 234 Element = self.etree.Element 235 root = Element("root") 236 self.assertRaises(TypeError, root.set, "newattr", 5) 237 self.assertRaises(TypeError, root.set, "newattr", None)

238

239 - def test_strip_attributes(self):

240 XML = self.etree.XML 241 xml = _bytes('<test a="5" b="10" c="20"><x a="4" b="2"/></test>') 242 243 root = XML(xml) 244 self.etree.strip_attributes(root, 'a') 245 self.assertEquals(_bytes('<test b="10" c="20"><x b="2"></x></test>'), 246 self._writeElement(root)) 247 248 root = XML(xml) 249 self.etree.strip_attributes(root, 'b', 'c') 250 self.assertEquals(_bytes('<test a="5"><x a="4"></x></test>'), 251 self._writeElement(root))

252

253 - def test_strip_attributes_ns(self):

254 XML = self.etree.XML 255 xml = _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20" n:a="5"><x a="4" n:b="2"/></test>') 256 257 root = XML(xml) 258 self.etree.strip_attributes(root, 'a') 259 self.assertEquals( 260 _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'), 261 self._writeElement(root)) 262 263 root = XML(xml) 264 self.etree.strip_attributes(root, '{http://test/ns}a', 'c') 265 self.assertEquals( 266 _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'), 267 self._writeElement(root)) 268 269 root = XML(xml) 270 self.etree.strip_attributes(root, '{http://test/ns}*') 271 self.assertEquals( 272 _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'), 273 self._writeElement(root))

274

275 - def test_strip_elements(self):

276 XML = self.etree.XML 277 xml = _bytes('<test><a><c/></a><x><a><c/></a></x></test>') 278 279 root = XML(xml) 280 self.etree.strip_elements(root, 'a') 281 self.assertEquals(_bytes('<test><x></x></test>'), 282 self._writeElement(root)) 283 284 root = XML(xml) 285 self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z') 286 self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'), 287 self._writeElement(root)) 288 289 root = XML(xml) 290 self.etree.strip_elements(root, 'c') 291 self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'), 292 self._writeElement(root))

293

294 - def test_strip_elements_ns(self):

295 XML = self.etree.XML 296 xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"/>CBT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 297 298 root = XML(xml) 299 self.etree.strip_elements(root, 'a') 300 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"></c>CBT</n:a>AT<x>X</x>XT</test>'), 301 self._writeElement(root)) 302 303 root = XML(xml) 304 self.etree.strip_elements(root, '{urn:a}b', 'c') 305 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"></c>CBT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 306 self._writeElement(root)) 307 308 root = XML(xml) 309 self.etree.strip_elements(root, '{urn:a}*', 'c') 310 self.assertEquals(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 311 self._writeElement(root)) 312 313 root = XML(xml) 314 self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False) 315 self.assertEquals(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 316 self._writeElement(root))

317

318 - def test_strip_tags(self):

319 XML = self.etree.XML 320 xml = _bytes('<test>TEST<a>AB<c/>CTBT</a>AT<x>X<a>ABT<c/>CT</a>AT</x>XT</test>') 321 322 root = XML(xml) 323 self.etree.strip_tags(root, 'a') 324 self.assertEquals(_bytes('<test>TESTAB<c></c>CTBTAT<x>XABT<c></c>CTAT</x>XT</test>'), 325 self._writeElement(root)) 326 327 root = XML(xml) 328 self.etree.strip_tags(root, 'b', 'c', 'X', 'Y', 'Z') 329 self.assertEquals(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'), 330 self._writeElement(root)) 331 332 root = XML(xml) 333 self.etree.strip_tags(root, 'c') 334 self.assertEquals(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'), 335 self._writeElement(root))

336

337 - def test_strip_tags_pi_comment(self):

338 XML = self.etree.XML 339 PI = self.etree.ProcessingInstruction 340 Comment = self.etree.Comment 341 xml = _bytes('\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n\n<?PI1?>') 342 343 root = XML(xml) 344 self.etree.strip_tags(root, PI) 345 self.assertEquals(_bytes('\n<?PI1?>\n<test>TESTXT</test>\n\n<?PI1?>'), 346 self._writeElement(root)) 347 348 root = XML(xml) 349 self.etree.strip_tags(root, Comment) 350 self.assertEquals(_bytes('\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n\n<?PI1?>'), 351 self._writeElement(root)) 352 353 root = XML(xml) 354 self.etree.strip_tags(root, PI, Comment) 355 self.assertEquals(_bytes('\n<?PI1?>\n<test>TESTXT</test>\n\n<?PI1?>'), 356 self._writeElement(root)) 357 358 root = XML(xml) 359 self.etree.strip_tags(root, Comment, PI) 360 self.assertEquals(_bytes('\n<?PI1?>\n<test>TESTXT</test>\n\n<?PI1?>'), 361 self._writeElement(root))

362

363 - def test_strip_tags_pi_comment_all(self):

364 XML = self.etree.XML 365 ElementTree = self.etree.ElementTree 366 PI = self.etree.ProcessingInstruction 367 Comment = self.etree.Comment 368 xml = _bytes('\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n\n<?PI1?>') 369 370 root = XML(xml) 371 self.etree.strip_tags(ElementTree(root), PI) 372 self.assertEquals(_bytes('\n<test>TESTXT</test>\n'), 373 self._writeElement(root)) 374 375 root = XML(xml) 376 self.etree.strip_tags(ElementTree(root), Comment) 377 self.assertEquals(_bytes('<?PI1?>\n<test>TESTXT<?PI2?></test>\n<?PI1?>'), 378 self._writeElement(root)) 379 380 root = XML(xml) 381 self.etree.strip_tags(ElementTree(root), PI, Comment) 382 self.assertEquals(_bytes('<test>TESTXT</test>'), 383 self._writeElement(root)) 384 385 root = XML(xml) 386 self.etree.strip_tags(ElementTree(root), Comment, PI) 387 self.assertEquals(_bytes('<test>TESTXT</test>'), 388 self._writeElement(root))

389

390 - def test_strip_tags_doc_style(self):

391 XML = self.etree.XML 392 xml = _bytes(''' 393 <div> 394 <div> 395 I like sheep. 396   397 I like lots of sheep. 398   399 Click <a href="http://www.sheep.com">here</a> for <a href="http://www.sheep.com">those</a> sheep. 400   401 </div> 402 </div> 403 '''.strip()) 404 405 root = XML(xml) 406 self.etree.strip_tags(root, 'a') 407 self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''), xml).replace(_bytes(' '), _bytes(' ')), 408 self._writeElement(root)) 409 410 root = XML(xml) 411 self.etree.strip_tags(root, 'a', 'br') 412 self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''), 413 re.sub(_bytes('<br[^>]*>'), _bytes(''), xml)), 414 self._writeElement(root))

415

416 - def test_strip_tags_ns(self):

417 XML = self.etree.XML 418 xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"/>CTBT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 419 420 root = XML(xml) 421 self.etree.strip_tags(root, 'a') 422 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"></c>CTBT</n:a>AT<x>XABT<c xmlns="urn:x"></c>CTAT</x>XT</test>'), 423 self._writeElement(root)) 424 425 root = XML(xml) 426 self.etree.strip_tags(root, '{urn:a}b', 'c') 427 self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">AB<c xmlns="urn:c"></c>CTBT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 428 self._writeElement(root)) 429 430 root = XML(xml) 431 self.etree.strip_tags(root, '{urn:a}*', 'c') 432 self.assertEquals(_bytes('<test>TESTAB<c xmlns="urn:c"></c>CTBTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 433 self._writeElement(root))

434

435 - def test_strip_tags_and_remove(self):

436 # previously crashed 437 HTML = self.etree.HTML 438 root = HTML(_bytes('<div><h1>title</h1> foo boo</div>'))[0][0] 439 self.assertEquals(_bytes('<div><h1>title</h1> foo boo</div>'), 440 self.etree.tostring(root)) 441 self.etree.strip_tags(root, 'b') 442 self.assertEquals(_bytes('<div><h1>title</h1> foo boo</div>'), 443 self.etree.tostring(root)) 444 root.remove(root[0]) 445 self.assertEquals(_bytes('<div>boo</div>'), 446 self.etree.tostring(root))

447

448 - def test_pi(self):

449 # lxml.etree separates target and text 450 Element = self.etree.Element 451 SubElement = self.etree.SubElement 452 ProcessingInstruction = self.etree.ProcessingInstruction 453 454 a = Element('a') 455 a.append(ProcessingInstruction('foo', 'some more text')) 456 self.assertEquals(a[0].target, 'foo') 457 self.assertEquals(a[0].text, 'some more text')

458

459 - def test_pi_parse(self):

460 XML = self.etree.XML 461 root = XML(_bytes("<test><?mypi my test ?></test>")) 462 self.assertEquals(root[0].target, "mypi") 463 self.assertEquals(root[0].text, "my test ")

464

465 - def test_pi_pseudo_attributes_get(self):

466 XML = self.etree.XML 467 root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>")) 468 self.assertEquals(root[0].target, "mypi") 469 self.assertEquals(root[0].get('my'), "1") 470 self.assertEquals(root[0].get('test'), " abc ") 471 self.assertEquals(root[0].get('quotes'), "' '") 472 self.assertEquals(root[0].get('only'), None) 473 self.assertEquals(root[0].get('names'), None) 474 self.assertEquals(root[0].get('nope'), None)

475

476 - def test_pi_pseudo_attributes_attrib(self):

477 XML = self.etree.XML 478 root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>")) 479 self.assertEquals(root[0].target, "mypi") 480 self.assertEquals(root[0].attrib['my'], "1") 481 self.assertEquals(root[0].attrib['test'], " abc ") 482 self.assertEquals(root[0].attrib['quotes'], "' '") 483 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'only') 484 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'names') 485 self.assertRaises(KeyError, root[0].attrib.__getitem__, 'nope')

486

487 - def test_deepcopy_pi(self):

488 # previously caused a crash 489 ProcessingInstruction = self.etree.ProcessingInstruction 490 491 a = ProcessingInstruction("PI", "ONE") 492 b = copy.deepcopy(a) 493 b.text = "ANOTHER" 494 495 self.assertEquals('ONE', a.text) 496 self.assertEquals('ANOTHER', b.text)

497

498 - def test_deepcopy_elementtree_pi(self):

499 XML = self.etree.XML 500 tostring = self.etree.tostring 501 root = XML(_bytes("<?mypi my test ?><test/>")) 502 tree1 = self.etree.ElementTree(root) 503 self.assertEquals(_bytes("<?mypi my test ?><test/>"), 504 tostring(tree1)) 505 506 tree2 = copy.deepcopy(tree1) 507 self.assertEquals(_bytes("<?mypi my test ?><test/>"), 508 tostring(tree2)) 509 510 root2 = copy.deepcopy(tree1.getroot()) 511 self.assertEquals(_bytes("<test/>"), 512 tostring(root2))

513

514 - def test_deepcopy_elementtree_dtd(self):

515 XML = self.etree.XML 516 tostring = self.etree.tostring 517 xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>') 518 root = XML(xml) 519 tree1 = self.etree.ElementTree(root) 520 self.assertEquals(xml, tostring(tree1)) 521 522 tree2 = copy.deepcopy(tree1) 523 self.assertEquals(xml, tostring(tree2)) 524 525 root2 = copy.deepcopy(tree1.getroot()) 526 self.assertEquals(_bytes("<test/>"), 527 tostring(root2))

528

529 - def test_attribute_set(self):

530 # ElementTree accepts arbitrary attribute values 531 # lxml.etree allows only strings 532 Element = self.etree.Element 533 534 root = Element("root") 535 root.set("attr", "TEST") 536 self.assertEquals("TEST", root.get("attr")) 537 self.assertRaises(TypeError, root.set, "newattr", 5)

538

539 - def test_parse_remove_comments(self):

540 fromstring = self.etree.fromstring 541 tostring = self.etree.tostring 542 XMLParser = self.etree.XMLParser 543 544 xml = _bytes('<a><c/></a>') 545 parser = XMLParser(remove_comments=True) 546 root = fromstring(xml, parser) 547 self.assertEquals( 548 _bytes('<a><c/></a>'), 549 tostring(root))

550

551 - def test_parse_remove_pis(self):

552 parse = self.etree.parse 553 tostring = self.etree.tostring 554 XMLParser = self.etree.XMLParser 555 556 xml = _bytes('<?test?><a><?A?><?B?><c/><?C?></a><?tail?>') 557 558 f = BytesIO(xml) 559 tree = parse(f) 560 self.assertEquals( 561 xml, 562 tostring(tree)) 563 564 parser = XMLParser(remove_pis=True) 565 tree = parse(f, parser) 566 self.assertEquals( 567 _bytes('<a><c/></a>'), 568 tostring(tree))

569

570 - def test_parse_parser_type_error(self):

571 # ET raises IOError only 572 parse = self.etree.parse 573 self.assertRaises(TypeError, parse, 'notthere.xml', object())

574

575 - def test_iterparse_tree_comments(self):

576 # ET removes comments 577 iterparse = self.etree.iterparse 578 tostring = self.etree.tostring 579 580 f = BytesIO('<a><c/></a>') 581 events = list(iterparse(f)) 582 root = events[-1][1] 583 self.assertEquals(3, len(events)) 584 self.assertEquals( 585 _bytes('<a><c/></a>'), 586 tostring(root))

587

588 - def test_iterparse_comments(self):

589 # ET removes comments 590 iterparse = self.etree.iterparse 591 tostring = self.etree.tostring 592 593 def name(event, el): 594 if event == 'comment': 595 return el.text 596 else: 597 return el.tag

598 599 f = BytesIO('<a><c/></a>') 600 events = list(iterparse(f, events=('end', 'comment'))) 601 root = events[-1][1] 602 self.assertEquals(6, len(events)) 603 self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'], 604 [ name(*item) for item in events ]) 605 self.assertEquals( 606 _bytes('<a><c/></a>'), 607 tostring(root))

608

609 - def test_iterparse_pis(self):

610 # ET removes pis 611 iterparse = self.etree.iterparse 612 tostring = self.etree.tostring 613 ElementTree = self.etree.ElementTree 614 615 def name(event, el): 616 if event == 'pi': 617 return (el.target, el.text) 618 else: 619 return el.tag

620 621 f = BytesIO('<?pia a?><a><?pib b?><?pic c?><c/><?pid d?></a><?pie e?>') 622 events = list(iterparse(f, events=('end', 'pi'))) 623 root = events[-2][1] 624 self.assertEquals(8, len(events)) 625 self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b', 626 ('pid','d'), 'a', ('pie','e')], 627 [ name(*item) for item in events ]) 628 self.assertEquals( 629 _bytes('<?pia a?><a><?pib b?><?pic c?><c/><?pid d?></a><?pie e?>'), 630 tostring(ElementTree(root))) 631

632 - def test_iterparse_remove_comments(self):

633 iterparse = self.etree.iterparse 634 tostring = self.etree.tostring 635 636 f = BytesIO('<a><c/></a>') 637 events = list(iterparse(f, remove_comments=True, 638 events=('end', 'comment'))) 639 root = events[-1][1] 640 self.assertEquals(3, len(events)) 641 self.assertEquals(['c', 'b', 'a'], 642 [ el.tag for (event, el) in events ]) 643 self.assertEquals( 644 _bytes('<a><c/></a>'), 645 tostring(root))

646

647 - def test_iterparse_broken(self):

648 iterparse = self.etree.iterparse 649 f = BytesIO('<a><c/></a>') 650 # ET raises ExpatError, lxml raises XMLSyntaxError 651 self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f))

652

653 - def test_iterparse_strip(self):

654 iterparse = self.etree.iterparse 655 f = BytesIO(""" 656 <a> \n \n b test \n 657 658 \n\t <c> \n </c> </a> \n """) 659 iterator = iterparse(f, remove_blank_text=True) 660 text = [ (element.text, element.tail) 661 for event, element in iterator ] 662 self.assertEquals( 663 [(" b test ", None), (" \n ", None), (None, None)], 664 text)

665

666 - def test_iterparse_tag(self):

667 iterparse = self.etree.iterparse 668 f = BytesIO('<a><d/><c/></a>') 669 670 iterator = iterparse(f, tag="b", events=('start', 'end')) 671 events = list(iterator) 672 root = iterator.root 673 self.assertEquals( 674 [('start', root[0]), ('end', root[0])], 675 events)

676

677 - def test_iterparse_tag_all(self):

678 iterparse = self.etree.iterparse 679 f = BytesIO('<a><d/><c/></a>') 680 681 iterator = iterparse(f, tag="*", events=('start', 'end')) 682 events = list(iterator) 683 self.assertEquals( 684 8, 685 len(events))

686

687 - def test_iterparse_tag_ns(self):

688 iterparse = self.etree.iterparse 689 f = BytesIO('<a xmlns="urn:test:1"><d/><c/></a>') 690 691 iterator = iterparse(f, tag="{urn:test:1}b", events=('start', 'end')) 692 events = list(iterator) 693 root = iterator.root 694 self.assertEquals( 695 [('start', root[0]), ('end', root[0])], 696 events)

697

698 - def test_iterparse_tag_ns_all(self):

699 iterparse = self.etree.iterparse 700 f = BytesIO('<a xmlns="urn:test:1"><d/><c/></a>') 701 702 iterator = iterparse(f, tag="{urn:test:1}*", events=('start', 'end')) 703 events = list(iterator) 704 self.assertEquals( 705 8, 706 len(events))

707

708 - def test_iterparse_encoding_error(self):

709 text = _str('Søk på nettet') 710 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 711 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 712 ).encode('iso-8859-1') 713 714 self.assertRaises(self.etree.ParseError, 715 list, self.etree.iterparse(BytesIO(xml_latin1)))

716

717 - def test_iterparse_encoding_8bit_override(self):

718 text = _str('Søk på nettet', encoding="UTF-8") 719 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 720 xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 721 ).encode('iso-8859-1') 722 723 iterator = self.etree.iterparse(BytesIO(xml_latin1), 724 encoding="iso-8859-1") 725 self.assertEquals(1, len(list(iterator))) 726 727 a = iterator.root 728 self.assertEquals(a.text, text)

729

730 - def test_iterparse_keep_cdata(self):

731 tostring = self.etree.tostring 732 f = BytesIO('<root><![CDATA[test]]></root>') 733 context = self.etree.iterparse(f, strip_cdata=False) 734 content = [ el.text for event,el in context ] 735 736 self.assertEquals(['test'], content) 737 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 738 tostring(context.root))

739

740 - def test_parser_encoding_unknown(self):

741 self.assertRaises( 742 LookupError, self.etree.XMLParser, encoding="hopefully unknown")

743

744 - def test_parser_encoding(self):

745 self.etree.XMLParser(encoding="ascii") 746 self.etree.XMLParser(encoding="utf-8") 747 self.etree.XMLParser(encoding="iso-8859-1")

748

749 - def test_feed_parser_recover(self):

750 parser = self.etree.XMLParser(recover=True) 751 752 parser.feed('<?xml version=') 753 parser.feed('"1.0"?><ro') 754 parser.feed('ot><') 755 parser.feed('a test="works"') 756 parser.feed('><othertag/></root') # <a> not closed! 757 parser.feed('>') 758 759 root = parser.close() 760 761 self.assertEquals(root.tag, "root") 762 self.assertEquals(len(root), 1) 763 self.assertEquals(root[0].tag, "a") 764 self.assertEquals(root[0].get("test"), "works") 765 self.assertEquals(len(root[0]), 1) 766 self.assertEquals(root[0][0].tag, "othertag")

767 # FIXME: would be nice to get some errors logged ... 768 #self.assert_(len(parser.error_log) > 0, "error log is empty") 769

770 - def test_elementtree_parser_target_type_error(self):

771 assertEquals = self.assertEquals 772 assertFalse = self.assertFalse 773 774 events = [] 775 class Target(object): 776 def start(self, tag, attrib): 777 events.append("start") 778 assertFalse(attrib) 779 assertEquals("TAG", tag)

780 def end(self, tag): 781 events.append("end") 782 assertEquals("TAG", tag) 783 def close(self): 784 return "DONE" # no Element! 785 786 parser = self.etree.XMLParser(target=Target()) 787 tree = self.etree.ElementTree() 788 789 self.assertRaises(TypeError, 790 tree.parse, BytesIO("<TAG/>"), parser=parser) 791 self.assertEquals(["start", "end"], events) 792

793 - def test_parser_target_feed_exception(self):

794 # ET doesn't call .close() on errors 795 events = [] 796 class Target(object): 797 def start(self, tag, attrib): 798 events.append("start-" + tag)

799 def end(self, tag): 800 events.append("end-" + tag) 801 if tag == 'a': 802 raise ValueError("dead and gone") 803 def data(self, data): 804 events.append("data-" + data) 805 def close(self): 806 events.append("close") 807 return "DONE" 808 809 parser = self.etree.XMLParser(target=Target()) 810 811 try: 812 parser.feed(_bytes('<root>A<a>ca</a>B</root>')) 813 done = parser.close() 814 self.fail("error expected, but parsing succeeded") 815 except ValueError: 816 done = 'value error received as expected' 817 818 self.assertEquals(["start-root", "data-A", "start-a", 819 "data-ca", "end-a", "close"], 820 events) 821

822 - def test_parser_target_fromstring_exception(self):

823 # ET doesn't call .close() on errors 824 events = [] 825 class Target(object): 826 def start(self, tag, attrib): 827 events.append("start-" + tag)

828 def end(self, tag): 829 events.append("end-" + tag) 830 if tag == 'a': 831 raise ValueError("dead and gone") 832 def data(self, data): 833 events.append("data-" + data) 834 def close(self): 835 events.append("close") 836 return "DONE" 837 838 parser = self.etree.XMLParser(target=Target()) 839 840 try: 841 done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'), 842 parser=parser) 843 self.fail("error expected, but parsing succeeded") 844 except ValueError: 845 done = 'value error received as expected' 846 847 self.assertEquals(["start-root", "data-A", "start-a", 848 "data-ca", "end-a", "close"], 849 events) 850

851 - def test_parser_target_comment(self):

852 events = [] 853 class Target(object): 854 def start(self, tag, attrib): 855 events.append("start-" + tag)

856 def end(self, tag): 857 events.append("end-" + tag) 858 def data(self, data): 859 events.append("data-" + data) 860 def comment(self, text): 861 events.append("comment-" + text) 862 def close(self): 863 return "DONE" 864 865 parser = self.etree.XMLParser(target=Target()) 866 867 parser.feed(_bytes('<root>AB</root>')) 868 done = parser.close() 869 870 self.assertEquals("DONE", done) 871 self.assertEquals(["comment-a", "start-root", "data-A", "comment-b", 872 "start-sub", "end-sub", "comment-c", "data-B", 873 "end-root", "comment-d"], 874 events) 875

876 - def test_parser_target_pi(self):

877 events = [] 878 class Target(object): 879 def start(self, tag, attrib): 880 events.append("start-" + tag)

881 def end(self, tag): 882 events.append("end-" + tag) 883 def data(self, data): 884 events.append("data-" + data) 885 def pi(self, target, data): 886 events.append("pi-" + target + "-" + data) 887 def close(self): 888 return "DONE" 889 890 parser = self.etree.XMLParser(target=Target()) 891 892 parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>')) 893 done = parser.close() 894 895 self.assertEquals("DONE", done) 896 self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b", 897 "data-B", "end-root", "pi-test-c"], 898 events) 899

900 - def test_parser_target_cdata(self):

901 events = [] 902 class Target(object): 903 def start(self, tag, attrib): 904 events.append("start-" + tag)

905 def end(self, tag): 906 events.append("end-" + tag) 907 def data(self, data): 908 events.append("data-" + data) 909 def close(self): 910 return "DONE" 911 912 parser = self.etree.XMLParser(target=Target(), 913 strip_cdata=False) 914 915 parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>')) 916 done = parser.close() 917 918 self.assertEquals("DONE", done) 919 self.assertEquals(["start-root", "data-A", "start-a", 920 "data-ca", "end-a", "data-B", "end-root"], 921 events) 922

923 - def test_parser_target_recover(self):

924 events = [] 925 class Target(object): 926 def start(self, tag, attrib): 927 events.append("start-" + tag)

928 def end(self, tag): 929 events.append("end-" + tag) 930 def data(self, data): 931 events.append("data-" + data) 932 def close(self): 933 events.append("close") 934 return "DONE" 935 936 parser = self.etree.XMLParser(target=Target(), 937 recover=True) 938 939 parser.feed(_bytes('<root>A<a>ca</a>B</not-root>')) 940 done = parser.close() 941 942 self.assertEquals("DONE", done) 943 self.assertEquals(["start-root", "data-A", "start-a", 944 "data-ca", "end-a", "data-B", 945 "end-root", "close"], 946 events) 947

948 - def test_iterwalk_tag(self):

949 iterwalk = self.etree.iterwalk 950 root = self.etree.XML(_bytes('<a><d/><c/></a>')) 951 952 iterator = iterwalk(root, tag="b", events=('start', 'end')) 953 events = list(iterator) 954 self.assertEquals( 955 [('start', root[0]), ('end', root[0])], 956 events)

957

958 - def test_iterwalk_tag_all(self):

959 iterwalk = self.etree.iterwalk 960 root = self.etree.XML(_bytes('<a><d/><c/></a>')) 961 962 iterator = iterwalk(root, tag="*", events=('start', 'end')) 963 events = list(iterator) 964 self.assertEquals( 965 8, 966 len(events))

967

968 - def test_iterwalk(self):

969 iterwalk = self.etree.iterwalk 970 root = self.etree.XML(_bytes('<a><c/></a>')) 971 972 events = list(iterwalk(root)) 973 self.assertEquals( 974 [('end', root[0]), ('end', root[1]), ('end', root)], 975 events)

976

977 - def test_iterwalk_start(self):

978 iterwalk = self.etree.iterwalk 979 root = self.etree.XML(_bytes('<a><c/></a>')) 980 981 iterator = iterwalk(root, events=('start',)) 982 events = list(iterator) 983 self.assertEquals( 984 [('start', root), ('start', root[0]), ('start', root[1])], 985 events)

986

987 - def test_iterwalk_start_end(self):

988 iterwalk = self.etree.iterwalk 989 root = self.etree.XML(_bytes('<a><c/></a>')) 990 991 iterator = iterwalk(root, events=('start','end')) 992 events = list(iterator) 993 self.assertEquals( 994 [('start', root), ('start', root[0]), ('end', root[0]), 995 ('start', root[1]), ('end', root[1]), ('end', root)], 996 events)

997

998 - def test_iterwalk_clear(self):

999 iterwalk = self.etree.iterwalk 1000 root = self.etree.XML(_bytes('<a><c/></a>')) 1001 1002 iterator = iterwalk(root) 1003 for event, elem in iterator: 1004 elem.clear() 1005 1006 self.assertEquals(0, 1007 len(root))

1008

1009 - def test_iterwalk_attrib_ns(self):

1010 iterwalk = self.etree.iterwalk 1011 root = self.etree.XML(_bytes('<a xmlns="ns1"><c xmlns="ns2"/></a>')) 1012 1013 attr_name = '{testns}bla' 1014 events = [] 1015 iterator = iterwalk(root, events=('start','end','start-ns','end-ns')) 1016 for event, elem in iterator: 1017 events.append(event) 1018 if event == 'start': 1019 if elem.tag != '{ns1}a': 1020 elem.set(attr_name, 'value') 1021 1022 self.assertEquals( 1023 ['start-ns', 'start', 'start', 'start-ns', 'start', 1024 'end', 'end-ns', 'end', 'end', 'end-ns'], 1025 events) 1026 1027 self.assertEquals( 1028 None, 1029 root.get(attr_name)) 1030 self.assertEquals( 1031 'value', 1032 root[0].get(attr_name))

1033

1034 - def test_iterwalk_getiterator(self):

1035 iterwalk = self.etree.iterwalk 1036 root = self.etree.XML(_bytes('<a><d/><c/></a>')) 1037 1038 counts = [] 1039 for event, elem in iterwalk(root): 1040 counts.append(len(list(elem.getiterator()))) 1041 self.assertEquals( 1042 [1,2,1,4], 1043 counts)

1044

1045 - def test_resolve_string_dtd(self):

1046 parse = self.etree.parse 1047 parser = self.etree.XMLParser(dtd_validation=True) 1048 assertEqual = self.assertEqual 1049 test_url = _str("__nosuch.dtd") 1050 1051 class MyResolver(self.etree.Resolver): 1052 def resolve(self, url, id, context): 1053 assertEqual(url, test_url) 1054 return self.resolve_string( 1055 _str('''<!ENTITY myentity "%s"> 1056 <!ELEMENT doc ANY>''') % url, context)

1057 1058 parser.resolvers.add(MyResolver()) 1059 1060 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1061 tree = parse(StringIO(xml), parser) 1062 root = tree.getroot() 1063 self.assertEquals(root.text, test_url) 1064

1065 - def test_resolve_bytes_dtd(self):

1066 parse = self.etree.parse 1067 parser = self.etree.XMLParser(dtd_validation=True) 1068 assertEqual = self.assertEqual 1069 test_url = _str("__nosuch.dtd") 1070 1071 class MyResolver(self.etree.Resolver): 1072 def resolve(self, url, id, context): 1073 assertEqual(url, test_url) 1074 return self.resolve_string( 1075 (_str('''<!ENTITY myentity "%s"> 1076 <!ELEMENT doc ANY>''') % url).encode('utf-8'), 1077 context)

1078 1079 parser.resolvers.add(MyResolver()) 1080 1081 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1082 tree = parse(StringIO(xml), parser) 1083 root = tree.getroot() 1084 self.assertEquals(root.text, test_url) 1085

1086 - def test_resolve_filelike_dtd(self):

1087 parse = self.etree.parse 1088 parser = self.etree.XMLParser(dtd_validation=True) 1089 assertEqual = self.assertEqual 1090 test_url = _str("__nosuch.dtd") 1091 1092 class MyResolver(self.etree.Resolver): 1093 def resolve(self, url, id, context): 1094 assertEqual(url, test_url) 1095 return self.resolve_file( 1096 SillyFileLike( 1097 _str('''<!ENTITY myentity "%s"> 1098 <!ELEMENT doc ANY>''') % url), context)

1099 1100 parser.resolvers.add(MyResolver()) 1101 1102 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1103 tree = parse(StringIO(xml), parser) 1104 root = tree.getroot() 1105 self.assertEquals(root.text, test_url) 1106

1107 - def test_resolve_filename_dtd(self):

1108 parse = self.etree.parse 1109 parser = self.etree.XMLParser(attribute_defaults=True) 1110 assertEqual = self.assertEqual 1111 test_url = _str("__nosuch.dtd") 1112 1113 class MyResolver(self.etree.Resolver): 1114 def resolve(self, url, id, context): 1115 assertEqual(url, test_url) 1116 return self.resolve_filename( 1117 fileInTestDir('test.dtd'), context)

1118 1119 parser.resolvers.add(MyResolver()) 1120 1121 xml = _str('<!DOCTYPE a SYSTEM "%s"><a></a>') % test_url 1122 tree = parse(StringIO(xml), parser) 1123 root = tree.getroot() 1124 self.assertEquals( 1125 root.attrib, {'default': 'valueA'}) 1126 self.assertEquals( 1127 root[0].attrib, {'default': 'valueB'}) 1128

1129 - def test_resolve_filename_dtd_relative(self):

1130 parse = self.etree.parse 1131 parser = self.etree.XMLParser(attribute_defaults=True) 1132 assertEqual = self.assertEqual 1133 test_url = _str("__nosuch.dtd") 1134 1135 class MyResolver(self.etree.Resolver): 1136 def resolve(self, url, id, context): 1137 assertEqual(url, fileInTestDir(test_url)) 1138 return self.resolve_filename( 1139 fileInTestDir('test.dtd'), context)

1140 1141 parser.resolvers.add(MyResolver()) 1142 1143 xml = _str('<!DOCTYPE a SYSTEM "%s"><a></a>') % test_url 1144 tree = parse(StringIO(xml), parser, 1145 base_url=fileInTestDir('__test.xml')) 1146 root = tree.getroot() 1147 self.assertEquals( 1148 root.attrib, {'default': 'valueA'}) 1149 self.assertEquals( 1150 root[0].attrib, {'default': 'valueB'}) 1151

1152 - def test_resolve_file_dtd(self):

1153 parse = self.etree.parse 1154 parser = self.etree.XMLParser(attribute_defaults=True) 1155 assertEqual = self.assertEqual 1156 test_url = _str("__nosuch.dtd") 1157 1158 class MyResolver(self.etree.Resolver): 1159 def resolve(self, url, id, context): 1160 assertEqual(url, test_url) 1161 return self.resolve_file( 1162 open(fileInTestDir('test.dtd'), 'rb'), context)

1163 1164 parser.resolvers.add(MyResolver()) 1165 1166 xml = _str('<!DOCTYPE a SYSTEM "%s"><a></a>') % test_url 1167 tree = parse(StringIO(xml), parser) 1168 root = tree.getroot() 1169 self.assertEquals( 1170 root.attrib, {'default': 'valueA'}) 1171 self.assertEquals( 1172 root[0].attrib, {'default': 'valueB'}) 1173

1174 - def test_resolve_empty(self):

1175 parse = self.etree.parse 1176 parser = self.etree.XMLParser(load_dtd=True) 1177 assertEqual = self.assertEqual 1178 test_url = _str("__nosuch.dtd") 1179 1180 class check(object): 1181 resolved = False

1182 1183 class MyResolver(self.etree.Resolver): 1184 def resolve(self, url, id, context): 1185 assertEqual(url, test_url) 1186 check.resolved = True 1187 return self.resolve_empty(context) 1188 1189 parser.resolvers.add(MyResolver()) 1190 1191 xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 1192 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser) 1193 self.assert_(check.resolved) 1194

1195 - def test_resolve_error(self):

1196 parse = self.etree.parse 1197 parser = self.etree.XMLParser(dtd_validation=True) 1198 1199 class _LocalException(Exception): 1200 pass

1201 1202 class MyResolver(self.etree.Resolver): 1203 def resolve(self, url, id, context): 1204 raise _LocalException 1205 1206 parser.resolvers.add(MyResolver()) 1207 1208 xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 1209 self.assertRaises(_LocalException, parse, BytesIO(xml), parser) 1210 1211 if etree.LIBXML_VERSION > (2,6,20):

1212 - def test_entity_parse(self):

1213 parse = self.etree.parse 1214 tostring = self.etree.tostring 1215 parser = self.etree.XMLParser(resolve_entities=False) 1216 Entity = self.etree.Entity 1217 1218 xml = _bytes('<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>') 1219 tree = parse(BytesIO(xml), parser) 1220 root = tree.getroot() 1221 self.assertEquals(root[0].tag, Entity) 1222 self.assertEquals(root[0].text, "&myentity;") 1223 self.assertEquals(root[0].tail, None) 1224 self.assertEquals(root[0].name, "myentity") 1225 1226 self.assertEquals(_bytes('<doc>&myentity;</doc>'), 1227 tostring(root))

1228

1229 - def test_entity_restructure(self):

1230 xml = _bytes('''<!DOCTYPE root [ <!ENTITY nbsp " "> ]> 1231 <root> 1232 <child1/> 1233 <child2/> 1234 <child3> </child3> 1235 </root>''') 1236 1237 parser = self.etree.XMLParser(resolve_entities=False) 1238 root = etree.fromstring(xml, parser) 1239 self.assertEquals([ el.tag for el in root ], 1240 ['child1', 'child2', 'child3']) 1241 1242 root[0] = root[-1] 1243 self.assertEquals([ el.tag for el in root ], 1244 ['child3', 'child2']) 1245 self.assertEquals(root[0][0].text, ' ') 1246 self.assertEquals(root[0][0].name, 'nbsp')

1247

1248 - def test_entity_append(self):

1249 Entity = self.etree.Entity 1250 Element = self.etree.Element 1251 tostring = self.etree.tostring 1252 1253 root = Element("root") 1254 root.append( Entity("test") ) 1255 1256 self.assertEquals(root[0].tag, Entity) 1257 self.assertEquals(root[0].text, "&test;") 1258 self.assertEquals(root[0].tail, None) 1259 self.assertEquals(root[0].name, "test") 1260 1261 self.assertEquals(_bytes('<root>&test;</root>'), 1262 tostring(root))

1263

1264 - def test_entity_values(self):

1265 Entity = self.etree.Entity 1266 self.assertEquals(Entity("test").text, '&test;') 1267 self.assertEquals(Entity("#17683").text, '䔓') 1268 self.assertEquals(Entity("#x1768").text, 'ᝨ') 1269 self.assertEquals(Entity("#x98AF").text, '颯')

1270

1271 - def test_entity_error(self):

1272 Entity = self.etree.Entity 1273 self.assertRaises(ValueError, Entity, 'a b c') 1274 self.assertRaises(ValueError, Entity, 'a,b') 1275 self.assertRaises(ValueError, Entity, 'a\0b') 1276 self.assertRaises(ValueError, Entity, '#abc') 1277 self.assertRaises(ValueError, Entity, '#xxyz')

1278

1279 - def test_cdata(self):

1280 CDATA = self.etree.CDATA 1281 Element = self.etree.Element 1282 tostring = self.etree.tostring 1283 1284 root = Element("root") 1285 root.text = CDATA('test') 1286 1287 self.assertEquals('test', 1288 root.text) 1289 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1290 tostring(root))

1291

1292 - def test_cdata_type(self):

1293 CDATA = self.etree.CDATA 1294 Element = self.etree.Element 1295 root = Element("root") 1296 1297 root.text = CDATA("test") 1298 self.assertEquals('test', root.text) 1299 1300 root.text = CDATA(_str("test")) 1301 self.assertEquals('test', root.text) 1302 1303 self.assertRaises(TypeError, CDATA, 1)

1304

1305 - def test_cdata_errors(self):

1306 CDATA = self.etree.CDATA 1307 Element = self.etree.Element 1308 1309 root = Element("root") 1310 cdata = CDATA('test') 1311 1312 self.assertRaises(TypeError, 1313 setattr, root, 'tail', cdata) 1314 self.assertRaises(TypeError, 1315 root.set, 'attr', cdata) 1316 self.assertRaises(TypeError, 1317 operator.setitem, root.attrib, 'attr', cdata)

1318

1319 - def test_cdata_parser(self):

1320 tostring = self.etree.tostring 1321 parser = self.etree.XMLParser(strip_cdata=False) 1322 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 1323 1324 self.assertEquals('test', root.text) 1325 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1326 tostring(root))

1327

1328 - def test_cdata_xpath(self):

1329 tostring = self.etree.tostring 1330 parser = self.etree.XMLParser(strip_cdata=False) 1331 root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 1332 self.assertEquals(_bytes('<root><![CDATA[test]]></root>'), 1333 tostring(root)) 1334 1335 self.assertEquals(['test'], root.xpath('//text()'))

1336 1337 # TypeError in etree, AssertionError in ElementTree;

1338 - def test_setitem_assert(self):

1339 Element = self.etree.Element 1340 SubElement = self.etree.SubElement 1341 1342 a = Element('a') 1343 b = SubElement(a, 'b') 1344 1345 self.assertRaises(TypeError, 1346 a.__setitem__, 0, 'foo')

1347

1348 - def test_append_error(self):

1349 Element = self.etree.Element 1350 root = Element('root') 1351 # raises AssertionError in ElementTree 1352 self.assertRaises(TypeError, root.append, None) 1353 self.assertRaises(TypeError, root.extend, [None]) 1354 self.assertRaises(TypeError, root.extend, [Element('one'), None]) 1355 self.assertEquals('one', root[0].tag)

1356

1357 - def test_addnext(self):

1358 Element = self.etree.Element 1359 SubElement = self.etree.SubElement 1360 root = Element('root') 1361 SubElement(root, 'a') 1362 SubElement(root, 'b') 1363 1364 self.assertEquals(['a', 'b'], 1365 [c.tag for c in root]) 1366 root[1].addnext(root[0]) 1367 self.assertEquals(['b', 'a'], 1368 [c.tag for c in root])

1369

1370 - def test_addprevious(self):

1371 Element = self.etree.Element 1372 SubElement = self.etree.SubElement 1373 root = Element('root') 1374 SubElement(root, 'a') 1375 SubElement(root, 'b') 1376 1377 self.assertEquals(['a', 'b'], 1378 [c.tag for c in root]) 1379 root[0].addprevious(root[1]) 1380 self.assertEquals(['b', 'a'], 1381 [c.tag for c in root])

1382

1383 - def test_addnext_root(self):

1384 Element = self.etree.Element 1385 a = Element('a') 1386 b = Element('b') 1387 self.assertRaises(TypeError, a.addnext, b)

1388

1389 - def test_addnext_root(self):

1390 Element = self.etree.Element 1391 a = Element('a') 1392 b = Element('b') 1393 self.assertRaises(TypeError, a.addnext, b)

1394

1395 - def test_addprevious_pi(self):

1396 Element = self.etree.Element 1397 SubElement = self.etree.SubElement 1398 PI = self.etree.PI 1399 root = Element('root') 1400 SubElement(root, 'a') 1401 pi = PI('TARGET', 'TEXT') 1402 pi.tail = "TAIL" 1403 1404 self.assertEquals(_bytes('<root><a></a></root>'), 1405 self._writeElement(root)) 1406 root[0].addprevious(pi) 1407 self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'), 1408 self._writeElement(root))

1409

1410 - def test_addprevious_root_pi(self):

1411 Element = self.etree.Element 1412 PI = self.etree.PI 1413 root = Element('root') 1414 pi = PI('TARGET', 'TEXT') 1415 pi.tail = "TAIL" 1416 1417 self.assertEquals(_bytes('<root></root>'), 1418 self._writeElement(root)) 1419 root.addprevious(pi) 1420 self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'), 1421 self._writeElement(root))

1422

1423 - def test_addnext_pi(self):

1424 Element = self.etree.Element 1425 SubElement = self.etree.SubElement 1426 PI = self.etree.PI 1427 root = Element('root') 1428 SubElement(root, 'a') 1429 pi = PI('TARGET', 'TEXT') 1430 pi.tail = "TAIL" 1431 1432 self.assertEquals(_bytes('<root><a></a></root>'), 1433 self._writeElement(root)) 1434 root[0].addnext(pi) 1435 self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'), 1436 self._writeElement(root))

1437

1438 - def test_addnext_root_pi(self):

1439 Element = self.etree.Element 1440 PI = self.etree.PI 1441 root = Element('root') 1442 pi = PI('TARGET', 'TEXT') 1443 pi.tail = "TAIL" 1444 1445 self.assertEquals(_bytes('<root></root>'), 1446 self._writeElement(root)) 1447 root.addnext(pi) 1448 self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'), 1449 self._writeElement(root))

1450

1451 - def test_addnext_comment(self):

1452 Element = self.etree.Element 1453 SubElement = self.etree.SubElement 1454 Comment = self.etree.Comment 1455 root = Element('root') 1456 SubElement(root, 'a') 1457 comment = Comment('TEXT ') 1458 comment.tail = "TAIL" 1459 1460 self.assertEquals(_bytes('<root><a></a></root>'), 1461 self._writeElement(root)) 1462 root[0].addnext(comment) 1463 self.assertEquals(_bytes('<root><a></a>TAIL</root>'), 1464 self._writeElement(root))

1465

1466 - def test_addnext_root_comment(self):

1467 Element = self.etree.Element 1468 Comment = self.etree.Comment 1469 root = Element('root') 1470 comment = Comment('TEXT ') 1471 comment.tail = "TAIL" 1472 1473 self.assertEquals(_bytes('<root></root>'), 1474 self._writeElement(root)) 1475 root.addnext(comment) 1476 self.assertEquals(_bytes('<root></root>\n'), 1477 self._writeElement(root))

1478

1479 - def test_addprevious_comment(self):

1480 Element = self.etree.Element 1481 SubElement = self.etree.SubElement 1482 Comment = self.etree.Comment 1483 root = Element('root') 1484 SubElement(root, 'a') 1485 comment = Comment('TEXT ') 1486 comment.tail = "TAIL" 1487 1488 self.assertEquals(_bytes('<root><a></a></root>'), 1489 self._writeElement(root)) 1490 root[0].addprevious(comment) 1491 self.assertEquals(_bytes('<root>TAIL<a></a></root>'), 1492 self._writeElement(root))

1493

1494 - def test_addprevious_root_comment(self):

1495 Element = self.etree.Element 1496 Comment = self.etree.Comment 1497 root = Element('root') 1498 comment = Comment('TEXT ') 1499 comment.tail = "TAIL" 1500 1501 self.assertEquals(_bytes('<root></root>'), 1502 self._writeElement(root)) 1503 root.addprevious(comment) 1504 self.assertEquals(_bytes('\n<root></root>'), 1505 self._writeElement(root))

1506 1507 # ET's Elements have items() and key(), but not values()

1508 - def test_attribute_values(self):

1509 XML = self.etree.XML 1510 1511 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 1512 values = root.values() 1513 values.sort() 1514 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)

1515 1516 # gives error in ElementTree

1517 - def test_comment_empty(self):

1518 Element = self.etree.Element 1519 Comment = self.etree.Comment 1520 1521 a = Element('a') 1522 a.append(Comment()) 1523 self.assertEquals( 1524 _bytes('<a></a>'), 1525 self._writeElement(a))

1526 1527 # ElementTree ignores comments

1528 - def test_comment_parse_empty(self):

1529 ElementTree = self.etree.ElementTree 1530 tostring = self.etree.tostring 1531 1532 xml = _bytes('<a><c/></a>') 1533 f = BytesIO(xml) 1534 doc = ElementTree(file=f) 1535 a = doc.getroot() 1536 self.assertEquals( 1537 '', 1538 a[1].text) 1539 self.assertEquals( 1540 xml, 1541 tostring(a))

1542 1543 # ElementTree ignores comments

1544 - def test_comment_no_proxy_yet(self):

1545 ElementTree = self.etree.ElementTree 1546 1547 f = BytesIO('<a><c></c></a>') 1548 doc = ElementTree(file=f) 1549 a = doc.getroot() 1550 self.assertEquals( 1551 ' hoi ', 1552 a[1].text)

1553 1554 # does not raise an exception in ElementTree

1555 - def test_comment_immutable(self):

1556 Element = self.etree.Element 1557 Comment = self.etree.Comment 1558 1559 c = Comment() 1560 el = Element('myel') 1561 1562 self.assertRaises(TypeError, c.append, el) 1563 self.assertRaises(TypeError, c.insert, 0, el) 1564 self.assertRaises(TypeError, c.set, "myattr", "test")

1565 1566 # test passing 'None' to dump

1567 - def test_dump_none(self):

1568 self.assertRaises(TypeError, self.etree.dump, None)

1569

1570 - def test_prefix(self):

1571 ElementTree = self.etree.ElementTree 1572 1573 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') 1574 doc = ElementTree(file=f) 1575 a = doc.getroot() 1576 self.assertEquals( 1577 None, 1578 a.prefix) 1579 self.assertEquals( 1580 'foo', 1581 a[0].prefix)

1582

1583 - def test_prefix_default_ns(self):

1584 ElementTree = self.etree.ElementTree 1585 1586 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"></a>') 1587 doc = ElementTree(file=f) 1588 a = doc.getroot() 1589 self.assertEquals( 1590 None, 1591 a.prefix) 1592 self.assertEquals( 1593 None, 1594 a[0].prefix)

1595

1596 - def test_getparent(self):

1597 Element = self.etree.Element 1598 SubElement = self.etree.SubElement 1599 1600 a = Element('a') 1601 b = SubElement(a, 'b') 1602 c = SubElement(a, 'c') 1603 d = SubElement(b, 'd') 1604 self.assertEquals( 1605 None, 1606 a.getparent()) 1607 self.assertEquals( 1608 a, 1609 b.getparent()) 1610 self.assertEquals( 1611 b.getparent(), 1612 c.getparent()) 1613 self.assertEquals( 1614 b, 1615 d.getparent())

1616

1617 - def test_iterchildren(self):

1618 XML = self.etree.XML 1619 1620 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 1621 result = [] 1622 for el in root.iterchildren(): 1623 result.append(el.tag) 1624 self.assertEquals(['one', 'two', 'three'], result)

1625

1626 - def test_iterchildren_reversed(self):

1627 XML = self.etree.XML 1628 1629 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 1630 result = [] 1631 for el in root.iterchildren(reversed=True): 1632 result.append(el.tag) 1633 self.assertEquals(['three', 'two', 'one'], result)

1634

1635 - def test_iterchildren_tag(self):

1636 XML = self.etree.XML 1637 1638 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 1639 result = [] 1640 for el in root.iterchildren(tag='two'): 1641 result.append(el.text) 1642 self.assertEquals(['Two', 'Bla'], result)

1643

1644 - def test_iterchildren_tag_reversed(self):

1645 XML = self.etree.XML 1646 1647 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 1648 result = [] 1649 for el in root.iterchildren(reversed=True, tag='two'): 1650 result.append(el.text) 1651 self.assertEquals(['Bla', 'Two'], result)

1652

1653 - def test_iterancestors(self):

1654 Element = self.etree.Element 1655 SubElement = self.etree.SubElement 1656 1657 a = Element('a') 1658 b = SubElement(a, 'b') 1659 c = SubElement(a, 'c') 1660 d = SubElement(b, 'd') 1661 self.assertEquals( 1662 [], 1663 list(a.iterancestors())) 1664 self.assertEquals( 1665 [a], 1666 list(b.iterancestors())) 1667 self.assertEquals( 1668 [a], 1669 list(c.iterancestors())) 1670 self.assertEquals( 1671 [b, a], 1672 list(d.iterancestors()))

1673

1674 - def test_iterancestors_tag(self):

1675 Element = self.etree.Element 1676 SubElement = self.etree.SubElement 1677 1678 a = Element('a') 1679 b = SubElement(a, 'b') 1680 c = SubElement(a, 'c') 1681 d = SubElement(b, 'd') 1682 self.assertEquals( 1683 [a], 1684 list(d.iterancestors(tag='a')))

1685

1686 - def test_iterdescendants(self):

1687 Element = self.etree.Element 1688 SubElement = self.etree.SubElement 1689 1690 a = Element('a') 1691 b = SubElement(a, 'b') 1692 c = SubElement(a, 'c') 1693 d = SubElement(b, 'd') 1694 e = SubElement(c, 'e') 1695 1696 self.assertEquals( 1697 [b, d, c, e], 1698 list(a.iterdescendants())) 1699 self.assertEquals( 1700 [], 1701 list(d.iterdescendants()))

1702

1703 - def test_iterdescendants_tag(self):

1704 Element = self.etree.Element 1705 SubElement = self.etree.SubElement 1706 1707 a = Element('a') 1708 b = SubElement(a, 'b') 1709 c = SubElement(a, 'c') 1710 d = SubElement(b, 'd') 1711 e = SubElement(c, 'e') 1712 1713 self.assertEquals( 1714 [], 1715 list(a.iterdescendants('a'))) 1716 a2 = SubElement(e, 'a') 1717 self.assertEquals( 1718 [a2], 1719 list(a.iterdescendants('a'))) 1720 self.assertEquals( 1721 [a2], 1722 list(c.iterdescendants('a')))

1723

1724 - def test_getroottree(self):

1725 Element = self.etree.Element 1726 SubElement = self.etree.SubElement 1727 1728 a = Element('a') 1729 b = SubElement(a, 'b') 1730 c = SubElement(a, 'c') 1731 d = SubElement(b, 'd') 1732 self.assertEquals( 1733 a, 1734 a.getroottree().getroot()) 1735 self.assertEquals( 1736 a, 1737 b.getroottree().getroot()) 1738 self.assertEquals( 1739 a, 1740 d.getroottree().getroot())

1741

1742 - def test_getnext(self):

1743 Element = self.etree.Element 1744 SubElement = self.etree.SubElement 1745 1746 a = Element('a') 1747 b = SubElement(a, 'b') 1748 c = SubElement(a, 'c') 1749 self.assertEquals( 1750 None, 1751 a.getnext()) 1752 self.assertEquals( 1753 c, 1754 b.getnext()) 1755 self.assertEquals( 1756 None, 1757 c.getnext())

1758

1759 - def test_getprevious(self):

1760 Element = self.etree.Element 1761 SubElement = self.etree.SubElement 1762 1763 a = Element('a') 1764 b = SubElement(a, 'b') 1765 c = SubElement(a, 'c') 1766 d = SubElement(b, 'd') 1767 self.assertEquals( 1768 None, 1769 a.getprevious()) 1770 self.assertEquals( 1771 b, 1772 c.getprevious()) 1773 self.assertEquals( 1774 None, 1775 b.getprevious())

1776

1777 - def test_itersiblings(self):

1778 Element = self.etree.Element 1779 SubElement = self.etree.SubElement 1780 1781 a = Element('a') 1782 b = SubElement(a, 'b') 1783 c = SubElement(a, 'c') 1784 d = SubElement(b, 'd') 1785 self.assertEquals( 1786 [], 1787 list(a.itersiblings())) 1788 self.assertEquals( 1789 [c], 1790 list(b.itersiblings())) 1791 self.assertEquals( 1792 [], 1793 list(c.itersiblings())) 1794 self.assertEquals( 1795 [b], 1796 list(c.itersiblings(preceding=True))) 1797 self.assertEquals( 1798 [], 1799 list(b.itersiblings(preceding=True)))

1800

1801 - def test_itersiblings_tag(self):

1802 Element = self.etree.Element 1803 SubElement = self.etree.SubElement 1804 1805 a = Element('a') 1806 b = SubElement(a, 'b') 1807 c = SubElement(a, 'c') 1808 d = SubElement(b, 'd') 1809 self.assertEquals( 1810 [], 1811 list(a.itersiblings(tag='XXX'))) 1812 self.assertEquals( 1813 [c], 1814 list(b.itersiblings(tag='c'))) 1815 self.assertEquals( 1816 [b], 1817 list(c.itersiblings(preceding=True, tag='b'))) 1818 self.assertEquals( 1819 [], 1820 list(c.itersiblings(preceding=True, tag='c')))

1821

1822 - def test_parseid(self):

1823 parseid = self.etree.parseid 1824 XML = self.etree.XML 1825 xml_text = _bytes(''' 1826 <!DOCTYPE document [ 1827 <!ELEMENT document (h1,p)*> 1828 <!ELEMENT h1 (#PCDATA)> 1829 <!ATTLIST h1 myid ID #REQUIRED> 1830 <!ELEMENT p (#PCDATA)> 1831 <!ATTLIST p someid ID #REQUIRED> 1832 ]> 1833 <document> 1834 <h1 myid="chapter1">...</h1> 1835 ... 1836 Regular paragraph. 1837 XML:ID paragraph. 1838 ... 1839 </document> 1840 ''') 1841 1842 tree, dic = parseid(BytesIO(xml_text)) 1843 root = tree.getroot() 1844 root2 = XML(xml_text) 1845 self.assertEquals(self._writeElement(root), 1846 self._writeElement(root2)) 1847 expected = { 1848 "chapter1" : root[0], 1849 "xmlid" : root[3], 1850 "warn1" : root[4] 1851 } 1852 self.assert_("chapter1" in dic) 1853 self.assert_("warn1" in dic) 1854 self.assert_("xmlid" in dic) 1855 self._checkIDDict(dic, expected)

1856

1857 - def test_XMLDTDID(self):

1858 XMLDTDID = self.etree.XMLDTDID 1859 XML = self.etree.XML 1860 xml_text = _bytes(''' 1861 <!DOCTYPE document [ 1862 <!ELEMENT document (h1,p)*> 1863 <!ELEMENT h1 (#PCDATA)> 1864 <!ATTLIST h1 myid ID #REQUIRED> 1865 <!ELEMENT p (#PCDATA)> 1866 <!ATTLIST p someid ID #REQUIRED> 1867 ]> 1868 <document> 1869 <h1 myid="chapter1">...</h1> 1870 ... 1871 Regular paragraph. 1872 XML:ID paragraph. 1873 ... 1874 </document> 1875 ''') 1876 1877 root, dic = XMLDTDID(xml_text) 1878 root2 = XML(xml_text) 1879 self.assertEquals(self._writeElement(root), 1880 self._writeElement(root2)) 1881 expected = { 1882 "chapter1" : root[0], 1883 "xmlid" : root[3], 1884 "warn1" : root[4] 1885 } 1886 self.assert_("chapter1" in dic) 1887 self.assert_("warn1" in dic) 1888 self.assert_("xmlid" in dic) 1889 self._checkIDDict(dic, expected)

1890

1891 - def test_XMLDTDID_empty(self):

1892 XMLDTDID = self.etree.XMLDTDID 1893 XML = self.etree.XML 1894 xml_text = _bytes(''' 1895 <document> 1896 <h1 myid="chapter1">...</h1> 1897 ... 1898 Regular paragraph. 1899 ... 1900 </document> 1901 ''') 1902 1903 root, dic = XMLDTDID(xml_text) 1904 root2 = XML(xml_text) 1905 self.assertEquals(self._writeElement(root), 1906 self._writeElement(root2)) 1907 expected = {} 1908 self._checkIDDict(dic, expected)

1909

1910 - def _checkIDDict(self, dic, expected):

1911 self.assertEquals(len(dic), 1912 len(expected)) 1913 self.assertEquals(sorted(dic.items()), 1914 sorted(expected.items())) 1915 if sys.version_info < (3,): 1916 self.assertEquals(sorted(dic.iteritems()), 1917 sorted(expected.iteritems())) 1918 self.assertEquals(sorted(dic.keys()), 1919 sorted(expected.keys())) 1920 if sys.version_info < (3,): 1921 self.assertEquals(sorted(dic.iterkeys()), 1922 sorted(expected.iterkeys())) 1923 if sys.version_info < (3,): 1924 self.assertEquals(sorted(dic.values()), 1925 sorted(expected.values())) 1926 self.assertEquals(sorted(dic.itervalues()), 1927 sorted(expected.itervalues()))

1928

1929 - def test_namespaces(self):

1930 etree = self.etree 1931 1932 r = {'foo': 'http://ns.infrae.com/foo'} 1933 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1934 self.assertEquals( 1935 'foo', 1936 e.prefix) 1937 self.assertEquals( 1938 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'), 1939 self._writeElement(e))

1940

1941 - def test_namespaces_default(self):

1942 etree = self.etree 1943 1944 r = {None: 'http://ns.infrae.com/foo'} 1945 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1946 self.assertEquals( 1947 None, 1948 e.prefix) 1949 self.assertEquals( 1950 '{http://ns.infrae.com/foo}bar', 1951 e.tag) 1952 self.assertEquals( 1953 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'), 1954 self._writeElement(e))

1955

1956 - def test_namespaces_default_and_attr(self):

1957 etree = self.etree 1958 1959 r = {None: 'http://ns.infrae.com/foo', 1960 'hoi': 'http://ns.infrae.com/hoi'} 1961 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1962 e.set('{http://ns.infrae.com/hoi}test', 'value') 1963 self.assertEquals( 1964 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'), 1965 self._writeElement(e))

1966

1967 - def test_namespaces_elementtree(self):

1968 etree = self.etree 1969 r = {None: 'http://ns.infrae.com/foo', 1970 'hoi': 'http://ns.infrae.com/hoi'} 1971 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) 1972 tree = etree.ElementTree(element=e) 1973 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') 1974 self.assertEquals( 1975 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'), 1976 self._writeElement(e))

1977

1978 - def test_namespaces_default_copy_element(self):

1979 etree = self.etree 1980 1981 r = {None: 'http://ns.infrae.com/foo'} 1982 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1983 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 1984 1985 e1.append(e2) 1986 1987 self.assertEquals( 1988 None, 1989 e1.prefix) 1990 self.assertEquals( 1991 None, 1992 e1[0].prefix) 1993 self.assertEquals( 1994 '{http://ns.infrae.com/foo}bar', 1995 e1.tag) 1996 self.assertEquals( 1997 '{http://ns.infrae.com/foo}bar', 1998 e1[0].tag)

1999

2000 - def test_namespaces_copy_element(self):

2001 etree = self.etree 2002 2003 r = {None: 'http://ns.infrae.com/BAR'} 2004 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) 2005 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 2006 2007 e1.append(e2) 2008 2009 self.assertEquals( 2010 None, 2011 e1.prefix) 2012 self.assertNotEquals( 2013 None, 2014 e2.prefix) 2015 self.assertEquals( 2016 '{http://ns.infrae.com/BAR}bar', 2017 e1.tag) 2018 self.assertEquals( 2019 '{http://ns.infrae.com/foo}bar', 2020 e2.tag)

2021

2022 - def test_namespaces_reuse_after_move(self):

2023 ns_href = "http://a.b.c" 2024 one = self.etree.fromstring( 2025 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 2026 baz = one[0][0] 2027 2028 two = self.etree.fromstring( 2029 _bytes('<root xmlns:ns="%s"/>' % ns_href)) 2030 two.append(baz) 2031 del one # make sure the source document is deallocated 2032 2033 self.assertEquals('{%s}baz' % ns_href, baz.tag) 2034 self.assertEquals( 2035 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href), 2036 self.etree.tostring(two))

2037

2038 - def test_namespace_cleanup(self):

2039 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>') 2040 root = self.etree.fromstring(xml) 2041 self.assertEquals(xml, 2042 self.etree.tostring(root)) 2043 self.etree.cleanup_namespaces(root) 2044 self.assertEquals( 2045 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'), 2046 self.etree.tostring(root))

2047

2048 - def test_element_nsmap(self):

2049 etree = self.etree 2050 2051 r = {None: 'http://ns.infrae.com/foo', 2052 'hoi': 'http://ns.infrae.com/hoi'} 2053 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 2054 self.assertEquals( 2055 r, 2056 e.nsmap)

2057

2058 - def test_subelement_nsmap(self):

2059 etree = self.etree 2060 2061 re = {None: 'http://ns.infrae.com/foo', 2062 'hoi': 'http://ns.infrae.com/hoi'} 2063 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) 2064 2065 rs = {None: 'http://ns.infrae.com/honk', 2066 'top': 'http://ns.infrae.com/top'} 2067 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) 2068 2069 r = re.copy() 2070 r.update(rs) 2071 self.assertEquals(re, e.nsmap) 2072 self.assertEquals(r, s.nsmap)

2073

2074 - def test_html_prefix_nsmap(self):

2075 etree = self.etree 2076 el = etree.HTML('<hha:page-description>aa</hha:page-description>').find('.//page-description') 2077 self.assertEquals({'hha': None}, el.nsmap)

2078

2079 - def test_getiterator_filter_namespace(self):

2080 Element = self.etree.Element 2081 SubElement = self.etree.SubElement 2082 2083 a = Element('{a}a') 2084 b = SubElement(a, '{a}b') 2085 c = SubElement(a, '{a}c') 2086 d = SubElement(b, '{b}d') 2087 e = SubElement(c, '{a}e') 2088 f = SubElement(c, '{b}f') 2089 2090 self.assertEquals( 2091 [a], 2092 list(a.getiterator('{a}a'))) 2093 self.assertEquals( 2094 [], 2095 list(a.getiterator('{b}a'))) 2096 self.assertEquals( 2097 [], 2098 list(a.getiterator('a'))) 2099 self.assertEquals( 2100 [f], 2101 list(c.getiterator('{b}*'))) 2102 self.assertEquals( 2103 [d, f], 2104 list(a.getiterator('{b}*')))

2105

2106 - def test_getiterator_filter_entities(self):

2107 Element = self.etree.Element 2108 Entity = self.etree.Entity 2109 SubElement = self.etree.SubElement 2110 2111 a = Element('a') 2112 b = SubElement(a, 'b') 2113 entity_b = Entity("TEST-b") 2114 b.append(entity_b) 2115 2116 self.assertEquals( 2117 [entity_b], 2118 list(a.getiterator(Entity))) 2119 2120 entity_a = Entity("TEST-a") 2121 a.append(entity_a) 2122 2123 self.assertEquals( 2124 [entity_b, entity_a], 2125 list(a.getiterator(Entity))) 2126 2127 self.assertEquals( 2128 [entity_b], 2129 list(b.getiterator(Entity)))

2130

2131 - def test_getiterator_filter_element(self):

2132 Element = self.etree.Element 2133 Comment = self.etree.Comment 2134 PI = self.etree.PI 2135 SubElement = self.etree.SubElement 2136 2137 a = Element('a') 2138 b = SubElement(a, 'b') 2139 a.append(Comment("test")) 2140 a.append(PI("pi", "content")) 2141 c = SubElement(a, 'c') 2142 2143 self.assertEquals( 2144 [a, b, c], 2145 list(a.getiterator(Element)))

2146

2147 - def test_getiterator_filter_all_comment_pi(self):

2148 # ElementTree iterates over everything here 2149 Element = self.etree.Element 2150 Comment = self.etree.Comment 2151 PI = self.etree.PI 2152 SubElement = self.etree.SubElement 2153 2154 a = Element('a') 2155 b = SubElement(a, 'b') 2156 a.append(Comment("test")) 2157 a.append(PI("pi", "content")) 2158 c = SubElement(a, 'c') 2159 2160 self.assertEquals( 2161 [a, b, c], 2162 list(a.getiterator('*')))

2163

2164 - def test_elementtree_find_qname(self):

2165 XML = self.etree.XML 2166 ElementTree = self.etree.ElementTree 2167 QName = self.etree.QName 2168 tree = ElementTree(XML(_bytes('<a><c/><c></c></a>'))) 2169 self.assertEquals(tree.find(QName("c")), tree.getroot()[2])

2170

2171 - def test_elementtree_findall_qname(self):

2172 XML = self.etree.XML 2173 ElementTree = self.etree.ElementTree 2174 QName = self.etree.QName 2175 tree = ElementTree(XML(_bytes('<a><c/><c></c></a>'))) 2176 self.assertEquals(len(list(tree.findall(QName("c")))), 1)

2177

2178 - def test_elementtree_findall_ns_qname(self):

2179 XML = self.etree.XML 2180 ElementTree = self.etree.ElementTree 2181 QName = self.etree.QName 2182 tree = ElementTree(XML( 2183 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>'))) 2184 self.assertEquals(len(list(tree.findall(QName("b")))), 2) 2185 self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)

2186

2187 - def test_findall_ns(self):

2188 XML = self.etree.XML 2189 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) 2190 self.assertEquals(len(root.findall(".//{X}b")), 2) 2191 self.assertEquals(len(root.findall(".//{X}*")), 2) 2192 self.assertEquals(len(root.findall(".//b")), 3)

2193

2194 - def test_index(self):

2195 etree = self.etree 2196 e = etree.Element('foo') 2197 for i in range(10): 2198 etree.SubElement(e, 'a%s' % i) 2199 for i in range(10): 2200 self.assertEquals( 2201 i, 2202 e.index(e[i])) 2203 self.assertEquals( 2204 3, e.index(e[3], 3)) 2205 self.assertRaises( 2206 ValueError, e.index, e[3], 4) 2207 self.assertRaises( 2208 ValueError, e.index, e[3], 0, 2) 2209 self.assertRaises( 2210 ValueError, e.index, e[8], 0, -3) 2211 self.assertRaises( 2212 ValueError, e.index, e[8], -5, -3) 2213 self.assertEquals( 2214 8, e.index(e[8], 0, -1)) 2215 self.assertEquals( 2216 8, e.index(e[8], -12, -1)) 2217 self.assertEquals( 2218 0, e.index(e[0], -12, -1))

2219

2220 - def test_replace(self):

2221 etree = self.etree 2222 e = etree.Element('foo') 2223 for i in range(10): 2224 el = etree.SubElement(e, 'a%s' % i) 2225 el.text = "text%d" % i 2226 el.tail = "tail%d" % i 2227 2228 child0 = e[0] 2229 child1 = e[1] 2230 child2 = e[2] 2231 2232 e.replace(e[0], e[1]) 2233 self.assertEquals( 2234 9, len(e)) 2235 self.assertEquals( 2236 child1, e[0]) 2237 self.assertEquals( 2238 child1.text, "text1") 2239 self.assertEquals( 2240 child1.tail, "tail1") 2241 self.assertEquals( 2242 child0.tail, "tail0") 2243 self.assertEquals( 2244 child2, e[1]) 2245 2246 e.replace(e[-1], e[0]) 2247 self.assertEquals( 2248 child1, e[-1]) 2249 self.assertEquals( 2250 child1.text, "text1") 2251 self.assertEquals( 2252 child1.tail, "tail1") 2253 self.assertEquals( 2254 child2, e[0])

2255

2256 - def test_replace_new(self):

2257 etree = self.etree 2258 e = etree.Element('foo') 2259 for i in range(10): 2260 etree.SubElement(e, 'a%s' % i) 2261 2262 new_element = etree.Element("test") 2263 new_element.text = "TESTTEXT" 2264 new_element.tail = "TESTTAIL" 2265 child1 = e[1] 2266 e.replace(e[0], new_element) 2267 self.assertEquals( 2268 new_element, e[0]) 2269 self.assertEquals( 2270 "TESTTEXT", 2271 e[0].text) 2272 self.assertEquals( 2273 "TESTTAIL", 2274 e[0].tail) 2275 self.assertEquals( 2276 child1, e[1])

2277

2278 - def test_setslice_all_empty_reversed(self):

2279 Element = self.etree.Element 2280 SubElement = self.etree.SubElement 2281 2282 a = Element('a') 2283 2284 e = Element('e') 2285 f = Element('f') 2286 g = Element('g') 2287 2288 s = [e, f, g] 2289 a[::-1] = s 2290 self.assertEquals( 2291 [g, f, e], 2292 list(a))

2293

2294 - def test_setslice_step(self):

2295 Element = self.etree.Element 2296 SubElement = self.etree.SubElement 2297 2298 a = Element('a') 2299 b = SubElement(a, 'b') 2300 c = SubElement(a, 'c') 2301 d = SubElement(a, 'd') 2302 e = SubElement(a, 'e') 2303 2304 x = Element('x') 2305 y = Element('y') 2306 2307 a[1::2] = [x, y] 2308 self.assertEquals( 2309 [b, x, d, y], 2310 list(a))

2311

2312 - def test_setslice_step_negative(self):

2313 Element = self.etree.Element 2314 SubElement = self.etree.SubElement 2315 2316 a = Element('a') 2317 b = SubElement(a, 'b') 2318 c = SubElement(a, 'c') 2319 d = SubElement(a, 'd') 2320 e = SubElement(a, 'e') 2321 2322 x = Element('x') 2323 y = Element('y') 2324 2325 a[1::-1] = [x, y] 2326 self.assertEquals( 2327 [y, x, d, e], 2328 list(a))

2329

2330 - def test_setslice_step_negative2(self):

2331 Element = self.etree.Element 2332 SubElement = self.etree.SubElement 2333 2334 a = Element('a') 2335 b = SubElement(a, 'b') 2336 c = SubElement(a, 'c') 2337 d = SubElement(a, 'd') 2338 e = SubElement(a, 'e') 2339 2340 x = Element('x') 2341 y = Element('y') 2342 2343 a[::-2] = [x, y] 2344 self.assertEquals( 2345 [b, y, d, x], 2346 list(a))

2347

2348 - def test_setslice_step_overrun(self):

2349 Element = self.etree.Element 2350 SubElement = self.etree.SubElement 2351 try: 2352 slice 2353 except NameError: 2354 print("slice() not found") 2355 return 2356 2357 a = Element('a') 2358 b = SubElement(a, 'b') 2359 c = SubElement(a, 'c') 2360 d = SubElement(a, 'd') 2361 e = SubElement(a, 'e') 2362 2363 x = Element('x') 2364 y = Element('y') 2365 z = Element('z') 2366 2367 self.assertRaises( 2368 ValueError, 2369 operator.setitem, a, slice(1,None,2), [x, y, z]) 2370 2371 self.assertEquals( 2372 [b, c, d, e], 2373 list(a))

2374

2375 - def test_sourceline_XML(self):

2376 XML = self.etree.XML 2377 root = XML(_bytes('''<?xml version="1.0"?> 2378 <root><test> 2379 2380 <bla/></test> 2381 </root> 2382 ''')) 2383 2384 self.assertEquals( 2385 [2, 2, 4], 2386 [ el.sourceline for el in root.getiterator() ])

2387

2388 - def test_sourceline_parse(self):

2389 parse = self.etree.parse 2390 tree = parse(fileInTestDir('include/test_xinclude.xml')) 2391 2392 self.assertEquals( 2393 [1, 2, 3], 2394 [ el.sourceline for el in tree.getiterator() ])

2395

2396 - def test_sourceline_iterparse_end(self):

2397 iterparse = self.etree.iterparse 2398 lines = [ el.sourceline for (event, el) in 2399 iterparse(fileInTestDir('include/test_xinclude.xml')) ] 2400 2401 self.assertEquals( 2402 [2, 3, 1], 2403 lines)

2404

2405 - def test_sourceline_iterparse_start(self):

2406 iterparse = self.etree.iterparse 2407 lines = [ el.sourceline for (event, el) in 2408 iterparse(fileInTestDir('include/test_xinclude.xml'), 2409 events=("start",)) ] 2410 2411 self.assertEquals( 2412 [1, 2, 3], 2413 lines)

2414

2415 - def test_sourceline_element(self):

2416 Element = self.etree.Element 2417 SubElement = self.etree.SubElement 2418 el = Element("test") 2419 self.assertEquals(None, el.sourceline) 2420 2421 child = SubElement(el, "test") 2422 self.assertEquals(None, el.sourceline) 2423 self.assertEquals(None, child.sourceline)

2424

2425 - def test_XML_base_url_docinfo(self):

2426 etree = self.etree 2427 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2428 docinfo = root.getroottree().docinfo 2429 self.assertEquals(docinfo.URL, "http://no/such/url")

2430

2431 - def test_XML_set_base_url_docinfo(self):

2432 etree = self.etree 2433 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2434 docinfo = root.getroottree().docinfo 2435 self.assertEquals(docinfo.URL, "http://no/such/url") 2436 docinfo.URL = "https://secret/url" 2437 self.assertEquals(docinfo.URL, "https://secret/url")

2438

2439 - def test_parse_stringio_base_url(self):

2440 etree = self.etree 2441 tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url") 2442 docinfo = tree.docinfo 2443 self.assertEquals(docinfo.URL, "http://no/such/url")

2444

2445 - def test_parse_base_url_docinfo(self):

2446 etree = self.etree 2447 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 2448 base_url="http://no/such/url") 2449 docinfo = tree.docinfo 2450 self.assertEquals(docinfo.URL, "http://no/such/url")

2451

2452 - def test_HTML_base_url_docinfo(self):

2453 etree = self.etree 2454 root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url") 2455 docinfo = root.getroottree().docinfo 2456 self.assertEquals(docinfo.URL, "http://no/such/url")

2457

2458 - def test_docinfo_public(self):

2459 etree = self.etree 2460 xml_header = '<?xml version="1.0" encoding="ascii"?>' 2461 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 2462 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 2463 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) 2464 2465 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 2466 2467 tree = etree.parse(BytesIO(xml)) 2468 docinfo = tree.docinfo 2469 self.assertEquals(docinfo.encoding, "ascii") 2470 self.assertEquals(docinfo.xml_version, "1.0") 2471 self.assertEquals(docinfo.public_id, pub_id) 2472 self.assertEquals(docinfo.system_url, sys_id) 2473 self.assertEquals(docinfo.root_name, 'html') 2474 self.assertEquals(docinfo.doctype, doctype_string)

2475

2476 - def test_docinfo_system(self):

2477 etree = self.etree 2478 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' 2479 sys_id = "some.dtd" 2480 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id 2481 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 2482 2483 tree = etree.parse(BytesIO(xml)) 2484 docinfo = tree.docinfo 2485 self.assertEquals(docinfo.encoding, "UTF-8") 2486 self.assertEquals(docinfo.xml_version, "1.0") 2487 self.assertEquals(docinfo.public_id, None) 2488 self.assertEquals(docinfo.system_url, sys_id) 2489 self.assertEquals(docinfo.root_name, 'html') 2490 self.assertEquals(docinfo.doctype, doctype_string)

2491

2492 - def test_docinfo_empty(self):

2493 etree = self.etree 2494 xml = _bytes('<html><body></body></html>') 2495 tree = etree.parse(BytesIO(xml)) 2496 docinfo = tree.docinfo 2497 self.assertEquals(docinfo.encoding, "UTF-8") 2498 self.assertEquals(docinfo.xml_version, "1.0") 2499 self.assertEquals(docinfo.public_id, None) 2500 self.assertEquals(docinfo.system_url, None) 2501 self.assertEquals(docinfo.root_name, 'html') 2502 self.assertEquals(docinfo.doctype, '')

2503

2504 - def test_docinfo_name_only(self):

2505 etree = self.etree 2506 xml = _bytes('<!DOCTYPE root><root></root>') 2507 tree = etree.parse(BytesIO(xml)) 2508 docinfo = tree.docinfo 2509 self.assertEquals(docinfo.encoding, "UTF-8") 2510 self.assertEquals(docinfo.xml_version, "1.0") 2511 self.assertEquals(docinfo.public_id, None) 2512 self.assertEquals(docinfo.system_url, None) 2513 self.assertEquals(docinfo.root_name, 'root') 2514 self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')

2515

2516 - def test_doctype_name_only_roundtrip(self):

2517 etree = self.etree 2518 xml = _bytes('<!DOCTYPE root>\n<root/>') 2519 tree = etree.parse(BytesIO(xml)) 2520 self.assertEquals(xml, etree.tostring(tree))

2521

2522 - def test_doctype_output_override(self):

2523 etree = self.etree 2524 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 2525 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 2526 doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)) 2527 2528 xml = _bytes('<!DOCTYPE root>\n<root/>') 2529 tree = etree.parse(BytesIO(xml)) 2530 self.assertEquals(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string), 2531 etree.tostring(tree, doctype=doctype_string))

2532

2533 - def test_xml_base(self):

2534 etree = self.etree 2535 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2536 self.assertEquals(root.base, "http://no/such/url") 2537 self.assertEquals( 2538 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2539 root.base = "https://secret/url" 2540 self.assertEquals(root.base, "https://secret/url") 2541 self.assertEquals( 2542 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2543 "https://secret/url")

2544

2545 - def test_xml_base_attribute(self):

2546 etree = self.etree 2547 root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 2548 self.assertEquals(root.base, "http://no/such/url") 2549 self.assertEquals( 2550 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2551 root.set('{http://www.w3.org/XML/1998/namespace}base', 2552 "https://secret/url") 2553 self.assertEquals(root.base, "https://secret/url") 2554 self.assertEquals( 2555 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2556 "https://secret/url")

2557

2558 - def test_html_base(self):

2559 etree = self.etree 2560 root = etree.HTML(_bytes("<html><body></body></html>"), 2561 base_url="http://no/such/url") 2562 self.assertEquals(root.base, "http://no/such/url")

2563

2564 - def test_html_base_tag(self):

2565 etree = self.etree 2566 root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>')) 2567 self.assertEquals(root.base, "http://no/such/url")

2568

2569 - def test_parse_fileobject_unicode(self):

2570 # parse from a file object that returns unicode strings 2571 f = LargeFileLikeUnicode() 2572 tree = self.etree.parse(f) 2573 root = tree.getroot() 2574 self.assert_(root.tag.endswith('root'))

2575

2576 - def test_dtd_io(self):

2577 # check that DTDs that go in also go back out 2578 xml = _bytes('''\ 2579 <!DOCTYPE test SYSTEM "test.dtd" [ 2580 <!ENTITY entity "tasty"> 2581 <!ELEMENT test (a)> 2582 <!ELEMENT a (#PCDATA)> 2583 ]> 2584 <test><a>test-test</a></test>\ 2585 ''') 2586 tree = self.etree.parse(BytesIO(xml)) 2587 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")), 2588 xml.replace(_bytes(" "), _bytes("")))

2589

2590 - def test_byte_zero(self):

2591 Element = self.etree.Element 2592 2593 a = Element('a') 2594 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho') 2595 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho') 2596 2597 self.assertRaises(ValueError, Element, 'ha\0ho')

2598

2599 - def test_unicode_byte_zero(self):

2600 Element = self.etree.Element 2601 2602 a = Element('a') 2603 self.assertRaises(ValueError, setattr, a, "text", 2604 _str('ha\0ho')) 2605 self.assertRaises(ValueError, setattr, a, "tail", 2606 _str('ha\0ho')) 2607 2608 self.assertRaises(ValueError, Element, 2609 _str('ha\0ho'))

2610

2611 - def test_byte_invalid(self):

2612 Element = self.etree.Element 2613 2614 a = Element('a') 2615 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho') 2616 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho') 2617 2618 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho') 2619 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho') 2620 2621 self.assertRaises(ValueError, Element, 'ha\x07ho') 2622 self.assertRaises(ValueError, Element, 'ha\x02ho')

2623

2624 - def test_unicode_byte_invalid(self):

2625 Element = self.etree.Element 2626 2627 a = Element('a') 2628 self.assertRaises(ValueError, setattr, a, "text", 2629 _str('ha\x07ho')) 2630 self.assertRaises(ValueError, setattr, a, "text", 2631 _str('ha\x02ho')) 2632 2633 self.assertRaises(ValueError, setattr, a, "tail", 2634 _str('ha\x07ho')) 2635 self.assertRaises(ValueError, setattr, a, "tail", 2636 _str('ha\x02ho')) 2637 2638 self.assertRaises(ValueError, Element, 2639 _str('ha\x07ho')) 2640 self.assertRaises(ValueError, Element, 2641 _str('ha\x02ho'))

2642

2643 - def test_unicode_byte_invalid_sequence(self):

2644 Element = self.etree.Element 2645 2646 a = Element('a') 2647 self.assertRaises(ValueError, setattr, a, "text", 2648 _str('ha\u1234\x07ho')) 2649 self.assertRaises(ValueError, setattr, a, "text", 2650 _str('ha\u1234\x02ho')) 2651 2652 self.assertRaises(ValueError, setattr, a, "tail", 2653 _str('ha\u1234\x07ho')) 2654 self.assertRaises(ValueError, setattr, a, "tail", 2655 _str('ha\u1234\x02ho')) 2656 2657 self.assertRaises(ValueError, Element, 2658 _str('ha\u1234\x07ho')) 2659 self.assertRaises(ValueError, Element, 2660 _str('ha\u1234\x02ho'))

2661

2662 - def test_encoding_tostring_utf16(self):

2663 # ElementTree fails to serialize this 2664 tostring = self.etree.tostring 2665 Element = self.etree.Element 2666 SubElement = self.etree.SubElement 2667 2668 a = Element('a') 2669 b = SubElement(a, 'b') 2670 c = SubElement(a, 'c') 2671 2672 result = tostring(a, encoding='UTF-16') 2673 self.assertEquals(_bytes('<a><c></c></a>'), 2674 canonicalize(result))

2675

2676 - def test_tostring_none(self):

2677 # ElementTree raises an AssertionError here 2678 tostring = self.etree.tostring 2679 self.assertRaises(TypeError, self.etree.tostring, None)

2680

2681 - def test_tostring_pretty(self):

2682 tostring = self.etree.tostring 2683 Element = self.etree.Element 2684 SubElement = self.etree.SubElement 2685 2686 a = Element('a') 2687 b = SubElement(a, 'b') 2688 c = SubElement(a, 'c') 2689 2690 result = tostring(a) 2691 self.assertEquals(result, _bytes("<a><c/></a>")) 2692 2693 result = tostring(a, pretty_print=False) 2694 self.assertEquals(result, _bytes("<a><c/></a>")) 2695 2696 result = tostring(a, pretty_print=True) 2697 self.assertEquals(result, _bytes("<a>\n \n <c/>\n</a>\n"))

2698

2699 - def test_tostring_with_tail(self):

2700 tostring = self.etree.tostring 2701 Element = self.etree.Element 2702 SubElement = self.etree.SubElement 2703 2704 a = Element('a') 2705 a.tail = "aTAIL" 2706 b = SubElement(a, 'b') 2707 b.tail = "bTAIL" 2708 c = SubElement(a, 'c') 2709 2710 result = tostring(a) 2711 self.assertEquals(result, _bytes("<a>bTAIL<c/></a>aTAIL")) 2712 2713 result = tostring(a, with_tail=False) 2714 self.assertEquals(result, _bytes("<a>bTAIL<c/></a>")) 2715 2716 result = tostring(a, with_tail=True) 2717 self.assertEquals(result, _bytes("<a>bTAIL<c/></a>aTAIL"))

2718

2719 - def test_standalone(self):

2720 tostring = self.etree.tostring 2721 XML = self.etree.XML 2722 ElementTree = self.etree.ElementTree 2723 Element = self.etree.Element 2724 2725 tree = Element("root").getroottree() 2726 self.assertEquals(None, tree.docinfo.standalone) 2727 2728 tree = XML(_bytes("<root/>")).getroottree() 2729 self.assertEquals(None, tree.docinfo.standalone) 2730 2731 tree = XML(_bytes( 2732 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>" 2733 )).getroottree() 2734 self.assertEquals(True, tree.docinfo.standalone) 2735 2736 tree = XML(_bytes( 2737 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>" 2738 )).getroottree() 2739 self.assertEquals(False, tree.docinfo.standalone)

2740

2741 - def test_tostring_standalone(self):

2742 tostring = self.etree.tostring 2743 XML = self.etree.XML 2744 ElementTree = self.etree.ElementTree 2745 2746 root = XML(_bytes("<root/>")) 2747 2748 tree = ElementTree(root) 2749 self.assertEquals(None, tree.docinfo.standalone) 2750 2751 result = tostring(root, xml_declaration=True, encoding="ASCII") 2752 self.assertEquals(result, _bytes( 2753 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 2754 2755 result = tostring(root, xml_declaration=True, encoding="ASCII", 2756 standalone=True) 2757 self.assertEquals(result, _bytes( 2758 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) 2759 2760 tree = ElementTree(XML(result)) 2761 self.assertEquals(True, tree.docinfo.standalone) 2762 2763 result = tostring(root, xml_declaration=True, encoding="ASCII", 2764 standalone=False) 2765 self.assertEquals(result, _bytes( 2766 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>")) 2767 2768 tree = ElementTree(XML(result)) 2769 self.assertEquals(False, tree.docinfo.standalone)

2770

2771 - def test_tostring_standalone_in_out(self):

2772 tostring = self.etree.tostring 2773 XML = self.etree.XML 2774 ElementTree = self.etree.ElementTree 2775 2776 root = XML(_bytes( 2777 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>")) 2778 2779 tree = ElementTree(root) 2780 self.assertEquals(True, tree.docinfo.standalone) 2781 2782 result = tostring(root, xml_declaration=True, encoding="ASCII") 2783 self.assertEquals(result, _bytes( 2784 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 2785 2786 result = tostring(root, xml_declaration=True, encoding="ASCII", 2787 standalone=True) 2788 self.assertEquals(result, _bytes( 2789 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))

2790

2791 - def test_tostring_method_text_encoding(self):

2792 tostring = self.etree.tostring 2793 Element = self.etree.Element 2794 SubElement = self.etree.SubElement 2795 2796 a = Element('a') 2797 a.text = "A" 2798 a.tail = "tail" 2799 b = SubElement(a, 'b') 2800 b.text = "B" 2801 b.tail = _str("Søk på nettet") 2802 c = SubElement(a, 'c') 2803 c.text = "C" 2804 2805 result = tostring(a, method="text", encoding="UTF-16") 2806 2807 self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"), 2808 result)

2809

2810 - def test_tostring_method_text_unicode(self):

2811 tostring = self.etree.tostring 2812 Element = self.etree.Element 2813 SubElement = self.etree.SubElement 2814 2815 a = Element('a') 2816 a.text = _str('Søk på nettetA') 2817 a.tail = "tail" 2818 b = SubElement(a, 'b') 2819 b.text = "B" 2820 b.tail = _str('Søk på nettetB') 2821 c = SubElement(a, 'c') 2822 c.text = "C" 2823 2824 self.assertRaises(UnicodeEncodeError, 2825 tostring, a, method="text") 2826 2827 self.assertEquals( 2828 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'), 2829 tostring(a, encoding="UTF-8", method="text"))

2830

2831 - def test_tounicode(self):

2832 tounicode = self.etree.tounicode 2833 Element = self.etree.Element 2834 SubElement = self.etree.SubElement 2835 2836 a = Element('a') 2837 b = SubElement(a, 'b') 2838 c = SubElement(a, 'c') 2839 2840 self.assert_(isinstance(tounicode(a), _unicode)) 2841 self.assertEquals(_bytes('<a><c></c></a>'), 2842 canonicalize(tounicode(a)))

2843

2844 - def test_tounicode_element(self):

2845 tounicode = self.etree.tounicode 2846 Element = self.etree.Element 2847 SubElement = self.etree.SubElement 2848 2849 a = Element('a') 2850 b = SubElement(a, 'b') 2851 c = SubElement(a, 'c') 2852 d = SubElement(c, 'd') 2853 self.assert_(isinstance(tounicode(b), _unicode)) 2854 self.assert_(isinstance(tounicode(c), _unicode)) 2855 self.assertEquals(_bytes(''), 2856 canonicalize(tounicode(b))) 2857 self.assertEquals(_bytes('<c><d></d></c>'), 2858 canonicalize(tounicode(c)))

2859

2860 - def test_tounicode_none(self):

2861 tounicode = self.etree.tounicode 2862 self.assertRaises(TypeError, self.etree.tounicode, None)

2863

2864 - def test_tounicode_element_tail(self):

2865 tounicode = self.etree.tounicode 2866 Element = self.etree.Element 2867 SubElement = self.etree.SubElement 2868 2869 a = Element('a') 2870 b = SubElement(a, 'b') 2871 c = SubElement(a, 'c') 2872 d = SubElement(c, 'd') 2873 b.tail = 'Foo' 2874 2875 self.assert_(isinstance(tounicode(b), _unicode)) 2876 self.assert_(tounicode(b) == 'Foo' or 2877 tounicode(b) == 'Foo')

2878

2879 - def test_tounicode_pretty(self):

2880 tounicode = self.etree.tounicode 2881 Element = self.etree.Element 2882 SubElement = self.etree.SubElement 2883 2884 a = Element('a') 2885 b = SubElement(a, 'b') 2886 c = SubElement(a, 'c') 2887 2888 result = tounicode(a) 2889 self.assertEquals(result, "<a><c/></a>") 2890 2891 result = tounicode(a, pretty_print=False) 2892 self.assertEquals(result, "<a><c/></a>") 2893 2894 result = tounicode(a, pretty_print=True) 2895 self.assertEquals(result, "<a>\n \n <c/>\n</a>\n")

2896

2897 - def test_tostring_unicode(self):

2898 tostring = self.etree.tostring 2899 Element = self.etree.Element 2900 SubElement = self.etree.SubElement 2901 2902 a = Element('a') 2903 b = SubElement(a, 'b') 2904 c = SubElement(a, 'c') 2905 2906 self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode)) 2907 self.assertEquals(_bytes('<a><c></c></a>'), 2908 canonicalize(tostring(a, encoding=_unicode)))

2909

2910 - def test_tostring_unicode_element(self):

2911 tostring = self.etree.tostring 2912 Element = self.etree.Element 2913 SubElement = self.etree.SubElement 2914 2915 a = Element('a') 2916 b = SubElement(a, 'b') 2917 c = SubElement(a, 'c') 2918 d = SubElement(c, 'd') 2919 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode)) 2920 self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode)) 2921 self.assertEquals(_bytes(''), 2922 canonicalize(tostring(b, encoding=_unicode))) 2923 self.assertEquals(_bytes('<c><d></d></c>'), 2924 canonicalize(tostring(c, encoding=_unicode)))

2925

2926 - def test_tostring_unicode_none(self):

2927 tostring = self.etree.tostring 2928 self.assertRaises(TypeError, self.etree.tostring, 2929 None, encoding=_unicode)

2930

2931 - def test_tostring_unicode_element_tail(self):

2932 tostring = self.etree.tostring 2933 Element = self.etree.Element 2934 SubElement = self.etree.SubElement 2935 2936 a = Element('a') 2937 b = SubElement(a, 'b') 2938 c = SubElement(a, 'c') 2939 d = SubElement(c, 'd') 2940 b.tail = 'Foo' 2941 2942 self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode)) 2943 self.assert_(tostring(b, encoding=_unicode) == 'Foo' or 2944 tostring(b, encoding=_unicode) == 'Foo')

2945

2946 - def test_tostring_unicode_pretty(self):

2947 tostring = self.etree.tostring 2948 Element = self.etree.Element 2949 SubElement = self.etree.SubElement 2950 2951 a = Element('a') 2952 b = SubElement(a, 'b') 2953 c = SubElement(a, 'c') 2954 2955 result = tostring(a, encoding=_unicode) 2956 self.assertEquals(result, "<a><c/></a>") 2957 2958 result = tostring(a, encoding=_unicode, pretty_print=False) 2959 self.assertEquals(result, "<a><c/></a>") 2960 2961 result = tostring(a, encoding=_unicode, pretty_print=True) 2962 self.assertEquals(result, "<a>\n \n <c/>\n</a>\n")

2963 2964 # helper methods 2965

2966 - def _writeElement(self, element, encoding='us-ascii', compression=0):

2967 """Write out element for comparison. 2968 """ 2969 ElementTree = self.etree.ElementTree 2970 f = BytesIO() 2971 tree = ElementTree(element=element) 2972 tree.write(f, encoding=encoding, compression=compression) 2973 data = f.getvalue() 2974 if compression: 2975 data = zlib.decompress(data) 2976 return canonicalize(data)

2977 2978

2979 -class XIncludeTestCase(HelperTestCase):

2980 - def test_xinclude_text(self):

2981 filename = fileInTestDir('test_broken.xml') 2982 root = etree.XML(_bytes('''\ 2983 <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 2984 <xi:include href="%s" parse="text"/> 2985 </doc> 2986 ''' % filename)) 2987 old_text = root.text 2988 content = read_file(filename) 2989 old_tail = root[0].tail 2990 2991 self.include( etree.ElementTree(root) ) 2992 self.assertEquals(old_text + content + old_tail, 2993 root.text)

2994

2995 - def test_xinclude(self):

2996 tree = etree.parse(fileInTestDir('include/test_xinclude.xml')) 2997 self.assertNotEquals( 2998 'a', 2999 tree.getroot()[1].tag) 3000 # process xincludes 3001 self.include( tree ) 3002 # check whether we find it replaced with included data 3003 self.assertEquals( 3004 'a', 3005 tree.getroot()[1].tag)

3006

3007 - def test_xinclude_resolver(self):

3008 class res(etree.Resolver): 3009 include_text = read_file(fileInTestDir('test.xml')) 3010 called = {} 3011 def resolve(self, url, id, context): 3012 if url.endswith(".dtd"): 3013 self.called["dtd"] = True 3014 return self.resolve_filename( 3015 fileInTestDir('test.dtd'), context) 3016 elif url.endswith("test_xinclude.xml"): 3017 self.called["input"] = True 3018 return None # delegate to default resolver 3019 else: 3020 self.called["include"] = True 3021 return self.resolve_string(self.include_text, context)

3022 3023 res_instance = res() 3024 parser = etree.XMLParser(load_dtd = True) 3025 parser.resolvers.add(res_instance) 3026 3027 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 3028 parser = parser) 3029 3030 self.include(tree) 3031 3032 called = list(res_instance.called.items()) 3033 called.sort() 3034 self.assertEquals( 3035 [("dtd", True), ("include", True), ("input", True)], 3036 called) 3037

3038 -class ETreeXIncludeTestCase(XIncludeTestCase):

3039 - def include(self, tree):

3040 tree.xinclude()

3041 3042

3043 -class ElementIncludeTestCase(XIncludeTestCase):

3044 from lxml import ElementInclude

3045 - def include(self, tree):

3046 self.ElementInclude.include(tree.getroot())

3047 3048

3049 -class ETreeC14NTestCase(HelperTestCase):

3050 - def test_c14n(self):

3051 tree = self.parse(_bytes('<a></a>')) 3052 f = BytesIO() 3053 tree.write_c14n(f) 3054 s = f.getvalue() 3055 self.assertEquals(_bytes('<a></a>'), 3056 s)

3057

3058 - def test_c14n_gzip(self):

3059 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3060 f = BytesIO() 3061 tree.write_c14n(f, compression=9) 3062 gzfile = gzip.GzipFile(fileobj=BytesIO(f.getvalue())) 3063 try: 3064 s = gzfile.read() 3065 finally: 3066 gzfile.close() 3067 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3068 s)

3069

3070 - def test_c14n_file(self):

3071 tree = self.parse(_bytes('<a></a>')) 3072 handle, filename = tempfile.mkstemp() 3073 try: 3074 tree.write_c14n(filename) 3075 data = read_file(filename, 'rb') 3076 finally: 3077 os.close(handle) 3078 os.remove(filename) 3079 self.assertEquals(_bytes('<a></a>'), 3080 data)

3081

3082 - def test_c14n_file_gzip(self):

3083 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3084 handle, filename = tempfile.mkstemp() 3085 try: 3086 tree.write_c14n(filename, compression=9) 3087 f = gzip.open(filename, 'rb') 3088 try: 3089 data = f.read() 3090 finally: 3091 f.close() 3092 finally: 3093 os.close(handle) 3094 os.remove(filename) 3095 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3096 data)

3097

3098 - def test_c14n_with_comments(self):

3099 tree = self.parse(_bytes('<a></a>')) 3100 f = BytesIO() 3101 tree.write_c14n(f) 3102 s = f.getvalue() 3103 self.assertEquals(_bytes('\n<a></a>\n'), 3104 s) 3105 f = BytesIO() 3106 tree.write_c14n(f, with_comments=True) 3107 s = f.getvalue() 3108 self.assertEquals(_bytes('\n<a></a>\n'), 3109 s) 3110 f = BytesIO() 3111 tree.write_c14n(f, with_comments=False) 3112 s = f.getvalue() 3113 self.assertEquals(_bytes('<a></a>'), 3114 s)

3115

3116 - def test_c14n_tostring_with_comments(self):

3117 tree = self.parse(_bytes('<a></a>')) 3118 s = etree.tostring(tree, method='c14n') 3119 self.assertEquals(_bytes('\n<a></a>\n'), 3120 s) 3121 s = etree.tostring(tree, method='c14n', with_comments=True) 3122 self.assertEquals(_bytes('\n<a></a>\n'), 3123 s) 3124 s = etree.tostring(tree, method='c14n', with_comments=False) 3125 self.assertEquals(_bytes('<a></a>'), 3126 s)

3127

3128 - def test_c14n_element_tostring_with_comments(self):

3129 tree = self.parse(_bytes('<a></a>')) 3130 s = etree.tostring(tree.getroot(), method='c14n') 3131 self.assertEquals(_bytes('<a></a>'), 3132 s) 3133 s = etree.tostring(tree.getroot(), method='c14n', with_comments=True) 3134 self.assertEquals(_bytes('<a></a>'), 3135 s) 3136 s = etree.tostring(tree.getroot(), method='c14n', with_comments=False) 3137 self.assertEquals(_bytes('<a></a>'), 3138 s)

3139

3140 - def test_c14n_exclusive(self):

3141 tree = self.parse(_bytes( 3142 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3143 f = BytesIO() 3144 tree.write_c14n(f) 3145 s = f.getvalue() 3146 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3147 s) 3148 f = BytesIO() 3149 tree.write_c14n(f, exclusive=False) 3150 s = f.getvalue() 3151 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3152 s) 3153 f = BytesIO() 3154 tree.write_c14n(f, exclusive=True) 3155 s = f.getvalue() 3156 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3157 s)

3158

3159 - def test_c14n_tostring_exclusive(self):

3160 tree = self.parse(_bytes( 3161 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3162 s = etree.tostring(tree, method='c14n') 3163 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3164 s) 3165 s = etree.tostring(tree, method='c14n', exclusive=False) 3166 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3167 s) 3168 s = etree.tostring(tree, method='c14n', exclusive=True) 3169 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3170 s)

3171

3172 - def test_c14n_element_tostring_exclusive(self):

3173 tree = self.parse(_bytes( 3174 '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 3175 s = etree.tostring(tree.getroot(), method='c14n') 3176 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3177 s) 3178 s = etree.tostring(tree.getroot(), method='c14n', exclusive=False) 3179 self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 3180 s) 3181 s = etree.tostring(tree.getroot(), method='c14n', exclusive=True) 3182 self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 3183 s) 3184 3185 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=False) 3186 self.assertEquals(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'), 3187 s) 3188 s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True) 3189 self.assertEquals(_bytes('<z:b xmlns:z="http://cde"></z:b>'), 3190 s)

3191 3192

3193 -class ETreeWriteTestCase(HelperTestCase):

3194 - def test_write(self):

3195 tree = self.parse(_bytes('<a></a>')) 3196 f = BytesIO() 3197 tree.write(f) 3198 s = f.getvalue() 3199 self.assertEquals(_bytes('<a></a>'), 3200 s)

3201

3202 - def test_write_gzip(self):

3203 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3204 f = BytesIO() 3205 tree.write(f, compression=9) 3206 gzfile = gzip.GzipFile(fileobj=BytesIO(f.getvalue())) 3207 try: 3208 s = gzfile.read() 3209 finally: 3210 gzfile.close() 3211 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3212 s)

3213

3214 - def test_write_gzip_level(self):

3215 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3216 f = BytesIO() 3217 tree.write(f, compression=0) 3218 s0 = f.getvalue() 3219 3220 f = BytesIO() 3221 tree.write(f) 3222 self.assertEquals(f.getvalue(), s0) 3223 3224 f = BytesIO() 3225 tree.write(f, compression=1) 3226 s = f.getvalue() 3227 self.assert_(len(s) <= len(s0)) 3228 gzfile = gzip.GzipFile(fileobj=BytesIO(s)) 3229 try: 3230 s1 = gzfile.read() 3231 finally: 3232 gzfile.close() 3233 3234 f = BytesIO() 3235 tree.write(f, compression=9) 3236 s = f.getvalue() 3237 self.assert_(len(s) <= len(s0)) 3238 gzfile = gzip.GzipFile(fileobj=BytesIO(s)) 3239 try: 3240 s9 = gzfile.read() 3241 finally: 3242 gzfile.close() 3243 3244 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3245 s0) 3246 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3247 s1) 3248 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3249 s9)

3250

3251 - def test_write_file(self):

3252 tree = self.parse(_bytes('<a></a>')) 3253 handle, filename = tempfile.mkstemp() 3254 try: 3255 tree.write(filename) 3256 data = read_file(filename, 'rb') 3257 finally: 3258 os.close(handle) 3259 os.remove(filename) 3260 self.assertEquals(_bytes('<a></a>'), 3261 data)

3262

3263 - def test_write_file_gzip(self):

3264 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3265 handle, filename = tempfile.mkstemp() 3266 try: 3267 tree.write(filename, compression=9) 3268 f = gzip.open(filename, 'rb') 3269 try: 3270 data = f.read() 3271 finally: 3272 f.close() 3273 finally: 3274 os.close(handle) 3275 os.remove(filename) 3276 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3277 data)

3278

3279 - def test_write_file_gzip_parse(self):

3280 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3281 handle, filename = tempfile.mkstemp() 3282 try: 3283 tree.write(filename, compression=9) 3284 data = etree.tostring(etree.parse(filename)) 3285 finally: 3286 os.close(handle) 3287 os.remove(filename) 3288 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3289 data)

3290

3291 - def test_write_file_gzipfile_parse(self):

3292 tree = self.parse(_bytes('<a>'+''*200+'</a>')) 3293 handle, filename = tempfile.mkstemp() 3294 try: 3295 tree.write(filename, compression=9) 3296 data = etree.tostring(etree.parse( 3297 gzip.GzipFile(filename))) 3298 finally: 3299 os.close(handle) 3300 os.remove(filename) 3301 self.assertEquals(_bytes('<a>'+''*200+'</a>'), 3302 data)

3303

3304 -class ETreeErrorLogTest(HelperTestCase):

3305 etree = etree 3306

3307 - def test_parse_error_logging(self):

3308 parse = self.etree.parse 3309 f = BytesIO('<a></c></a>') 3310 self.etree.clear_error_log() 3311 try: 3312 parse(f) 3313 logs = None 3314 except SyntaxError: 3315 e = sys.exc_info()[1] 3316 logs = e.error_log 3317 f.close() 3318 self.assert_([ log for log in logs 3319 if 'mismatch' in log.message ]) 3320 self.assert_([ log for log in logs 3321 if 'PARSER' in log.domain_name]) 3322 self.assert_([ log for log in logs 3323 if 'ERR_TAG_NAME_MISMATCH' in log.type_name ]) 3324 self.assert_([ log for log in logs 3325 if 1 == log.line ]) 3326 self.assert_([ log for log in logs 3327 if 15 == log.column ])

3328

3329 - def _test_python_error_logging(self):

3330 """This can't really be tested as long as there isn't a way to 3331 reset the logging setup ... 3332 """ 3333 parse = self.etree.parse 3334 3335 messages = [] 3336 class Logger(self.etree.PyErrorLog): 3337 def log(self, entry, message, *args): 3338 messages.append(message)

3339 3340 self.etree.use_global_python_log(Logger()) 3341 f = BytesIO('<a></c></a>') 3342 try: 3343 parse(f) 3344 except SyntaxError: 3345 pass 3346 f.close() 3347 3348 self.assert_([ message for message in messages 3349 if 'mismatch' in message ]) 3350 self.assert_([ message for message in messages 3351 if ':PARSER:' in message]) 3352 self.assert_([ message for message in messages 3353 if ':ERR_TAG_NAME_MISMATCH:' in message ]) 3354 self.assert_([ message for message in messages 3355 if ':1:15:' in message ]) 3356

3357 -def test_suite():

3358 suite = unittest.TestSuite() 3359 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)]) 3360 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)]) 3361 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)]) 3362 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)]) 3363 suite.addTests([unittest.makeSuite(ETreeWriteTestCase)]) 3364 suite.addTests([unittest.makeSuite(ETreeErrorLogTest)]) 3365 suite.addTests( 3366 [make_doctest('../../../doc/tutorial.txt')]) 3367 suite.addTests( 3368 [make_doctest('../../../doc/api.txt')]) 3369 suite.addTests( 3370 [make_doctest('../../../doc/FAQ.txt')]) 3371 suite.addTests( 3372 [make_doctest('../../../doc/parsing.txt')]) 3373 suite.addTests( 3374 [make_doctest('../../../doc/resolvers.txt')]) 3375 return suite

3376 3377 if __name__ == '__main__': 3378 print('to test use test.py %s' % __file__) 3379

Source Code for Module lxml.tests.test_etree