Package lxml :: Package tests :: Module selftest
Source Code for Module lxml.tests.selftest

   1  # $Id: selftest.py 3276 2007-09-12 06:52:30Z fredrik $ 
   2  # -*- coding: iso-8859-1 -*- 
   3  # elementtree selftest program 
   4   
   5  # this test script uses Python's "doctest" module to check that the 
   6  # *test script* works as expected. 
   7   
   8  # TODO: add more elementtree method tests 
   9  # TODO: add xml/html parsing tests 
  10  # TODO: etc 
  11   
  12  import re, sys 
  13   
  14 -def stdout(): 
  15      if sys.version_info[0] < 3: 
  16          return sys.stdout 
  17      class bytes_stdout(object): 
  18          def write(self, data): 
  19              if isinstance(data, bytes): 
  20                  data = data.decode('ISO8859-1') 
  21              sys.stdout.write(data) 
  22      return bytes_stdout() 
  23   
  24  try: 
  25      from StringIO import StringIO as BytesIO 
  26  except ImportError: 
  27      from io import BytesIO 
  28   
  29  from lxml import etree as ElementTree 
  30  from lxml import _elementpath as ElementPath 
  31  from lxml import ElementInclude 
  32  ET = ElementTree 
  33   
  34  #from elementtree import ElementTree 
  35  #from elementtree import ElementPath 
  36  #from elementtree import ElementInclude 
  37  #from elementtree import HTMLTreeBuilder 
  38  #from elementtree import SimpleXMLWriter 
  39   
  40 -def fix_compatibility(xml_data): 
  41      xml_data = re.sub(r'\s*xmlns:[a-z0-9]+="http://www.w3.org/2001/XInclude"', '', xml_data) 
  42      xml_data = xml_data.replace(' />', '/>') 
  43      if xml_data[-1:] == '\n': 
  44          xml_data = xml_data[:-1] 
  45      return xml_data 
  46   
  47 -def serialize(elem, **options): 
  48      file = BytesIO() 
  49      tree = ElementTree.ElementTree(elem) 
  50      tree.write(file, **options) 
  51      if sys.version_info[0] < 3: 
  52          try: 
  53              encoding = options["encoding"] 
  54          except KeyError: 
  55              encoding = "utf-8" 
  56      else: 
  57          encoding = 'ISO8859-1' 
  58      result = fix_compatibility(file.getvalue().decode(encoding)) 
  59      if sys.version_info[0] < 3: 
  60          result = result.encode(encoding) 
  61      return result 
  62   
  63 -def summarize(elem): 
  64      return elem.tag 
  65   
  66 -def summarize_list(seq): 
  67      return list(map(summarize, seq)) 
  68   
  69 -def normalize_crlf(tree): 
  70      for elem in tree.getiterator(): 
  71          if elem.text: elem.text = elem.text.replace("\r\n", "\n") 
  72          if elem.tail: elem.tail = elem.tail.replace("\r\n", "\n") 
  73   
  74  SAMPLE_XML = ElementTree.XML(""" 
  75  <body> 
  76    <tag class='a'>text</tag> 
  77    <tag class='b' /> 
  78     <section> 
  79      <tag class='b' id='inner'>subtext</tag> 
  80     </section> 
  81  </body> 
  82  """) 
  83   
  84  # 
  85  # interface tests 
  86   
  87 -def check_string(string): 
  88      len(string) 
  89      for char in string: 
  90          if len(char) != 1: 
  91              print("expected one-character string, got %r" % char) 
  92      new_string = string + "" 
  93      new_string = string + " " 
  94      string[:0] 
  95   
  96 -def check_string_or_none(value): 
  97      if value is None: 
  98          return 
  99      return check_string(value) 
 100   
 101 -def check_mapping(mapping): 
 102      len(mapping) 
 103      keys = mapping.keys() 
 104      items = mapping.items() 
 105      for key in keys: 
 106          item = mapping[key] 
 107      mapping["key"] = "value" 
 108      if mapping["key"] != "value": 
 109          print("expected value string, got %r" % mapping["key"]) 
 110   
 111 -def check_element(element): 
 112      if not hasattr(element, "tag"): 
 113          print("no tag member") 
 114      if not hasattr(element, "attrib"): 
 115          print("no attrib member") 
 116      if not hasattr(element, "text"): 
 117          print("no text member") 
 118      if not hasattr(element, "tail"): 
 119          print("no tail member") 
 120      check_string(element.tag) 
 121      check_mapping(element.attrib) 
 122      check_string_or_none(element.text) 
 123      check_string_or_none(element.tail) 
 124      for elem in element: 
 125          check_element(elem) 
 126   
 127 -def check_element_tree(tree): 
 128      check_element(tree.getroot()) 
 129   
 130  # -------------------------------------------------------------------- 
 131  # element tree tests 
 132   
 133 -def sanity(): 
 134      """ 
 135      >>> from elementtree.ElementTree import * 
 136      >>> from elementtree.ElementInclude import * 
 137      >>> from elementtree.ElementPath import * 
 138      >>> from elementtree.HTMLTreeBuilder import * 
 139      >>> from elementtree.SimpleXMLWriter import * 
 140      >>> from elementtree.TidyTools import * 
 141      """ 
 142   
 143  # doesn't work with lxml.etree 
 144  del sanity 
 145   
 146 -def version(): 
 147      """ 
 148      >>> ElementTree.VERSION 
 149      '1.3a2' 
 150      """ 
 151   
 152  # doesn't work with lxml.etree 
 153  del version 
 154   
 155 -def interface(): 
 156      """ 
 157      Test element tree interface. 
 158   
 159      >>> element = ElementTree.Element("tag") 
 160      >>> check_element(element) 
 161      >>> tree = ElementTree.ElementTree(element) 
 162      >>> check_element_tree(tree) 
 163      """ 
 164   
 165 -def simpleops(): 
 166      """ 
 167      >>> elem = ElementTree.XML("<body><tag/></body>") 
 168      >>> serialize(elem) 
 169      '<body><tag/></body>' 
 170      >>> e = ElementTree.Element("tag2") 
 171      >>> elem.append(e) 
 172      >>> serialize(elem) 
 173      '<body><tag/><tag2/></body>' 
 174      >>> elem.remove(e) 
 175      >>> serialize(elem) 
 176      '<body><tag/></body>' 
 177      >>> elem.insert(0, e) 
 178      >>> serialize(elem) 
 179      '<body><tag2/><tag/></body>' 
 180      >>> elem.remove(e) 
 181      >>> elem.extend([e]) 
 182      >>> serialize(elem) 
 183      '<body><tag/><tag2/></body>' 
 184      >>> elem.remove(e) 
 185      """ 
 186   
 187 -def simplefind(): 
 188      """ 
 189      Test find methods using the elementpath fallback. 
 190   
 191      >>> CurrentElementPath = ElementTree.ElementPath 
 192      >>> ElementTree.ElementPath = ElementTree._SimpleElementPath() 
 193      >>> elem = SAMPLE_XML 
 194      >>> elem.find("tag").tag 
 195      'tag' 
 196      >>> ElementTree.ElementTree(elem).find("tag").tag 
 197      'tag' 
 198      >>> elem.findtext("tag") 
 199      'text' 
 200      >>> elem.findtext("tog") 
 201      >>> elem.findtext("tog", "default") 
 202      'default' 
 203      >>> ElementTree.ElementTree(elem).findtext("tag") 
 204      'text' 
 205      >>> summarize_list(elem.findall("tag")) 
 206      ['tag', 'tag'] 
 207      >>> summarize_list(elem.findall(".//tag")) 
 208      ['tag', 'tag', 'tag'] 
 209   
 210      Path syntax doesn't work in this case. 
 211   
 212      >>> elem.find("section/tag") 
 213      >>> elem.findtext("section/tag") 
 214      >>> elem.findall("section/tag") 
 215      [] 
 216   
 217      >>> ElementTree.ElementPath = CurrentElementPath 
 218      """ 
 219   
 220  # doesn't work with lxml.etree 
 221  del simplefind 
 222   
 223 -def find(): 
 224      """ 
 225      Test find methods (including xpath syntax). 
 226   
 227      >>> elem = SAMPLE_XML 
 228      >>> elem.find("tag").tag 
 229      'tag' 
 230      >>> ElementTree.ElementTree(elem).find("tag").tag 
 231      'tag' 
 232      >>> elem.find("section/tag").tag 
 233      'tag' 
 234      >>> ElementTree.ElementTree(elem).find("section/tag").tag 
 235      'tag' 
 236      >>> elem.findtext("tag") 
 237      'text' 
 238      >>> elem.findtext("tog") 
 239      >>> elem.findtext("tog", "default") 
 240      'default' 
 241      >>> ElementTree.ElementTree(elem).findtext("tag") 
 242      'text' 
 243      >>> elem.findtext("section/tag") 
 244      'subtext' 
 245      >>> ElementTree.ElementTree(elem).findtext("section/tag") 
 246      'subtext' 
 247      >>> summarize_list(elem.findall("tag")) 
 248      ['tag', 'tag'] 
 249      >>> summarize_list(elem.findall("*")) 
 250      ['tag', 'tag', 'section'] 
 251      >>> summarize_list(elem.findall(".//tag")) 
 252      ['tag', 'tag', 'tag'] 
 253      >>> summarize_list(elem.findall("section/tag")) 
 254      ['tag'] 
 255      >>> summarize_list(elem.findall("section//tag")) 
 256      ['tag'] 
 257      >>> summarize_list(elem.findall("section/*")) 
 258      ['tag'] 
 259      >>> summarize_list(elem.findall("section//*")) 
 260      ['tag'] 
 261      >>> summarize_list(elem.findall("section/.//*")) 
 262      ['tag'] 
 263      >>> summarize_list(elem.findall("*/*")) 
 264      ['tag'] 
 265      >>> summarize_list(elem.findall("*//*")) 
 266      ['tag'] 
 267      >>> summarize_list(elem.findall("*/tag")) 
 268      ['tag'] 
 269      >>> summarize_list(elem.findall("*/./tag")) 
 270      ['tag'] 
 271      >>> summarize_list(elem.findall("./tag")) 
 272      ['tag', 'tag'] 
 273      >>> summarize_list(elem.findall(".//tag")) 
 274      ['tag', 'tag', 'tag'] 
 275      >>> summarize_list(elem.findall("././tag")) 
 276      ['tag', 'tag'] 
 277      >>> summarize_list(elem.findall(".//tag[@class]")) 
 278      ['tag', 'tag', 'tag'] 
 279      >>> summarize_list(elem.findall(".//tag[@class='a']")) 
 280      ['tag'] 
 281      >>> summarize_list(elem.findall(".//tag[@class='b']")) 
 282      ['tag', 'tag'] 
 283      >>> summarize_list(elem.findall(".//tag[@id]")) 
 284      ['tag'] 
 285      >>> summarize_list(elem.findall(".//section[tag]")) 
 286      ['section'] 
 287      >>> summarize_list(elem.findall(".//section[element]")) 
 288      [] 
 289      >>> summarize_list(elem.findall("../tag")) 
 290      [] 
 291      >>> summarize_list(elem.findall("section/../tag")) 
 292      ['tag', 'tag'] 
 293      >>> summarize_list(ElementTree.ElementTree(elem).findall("./tag")) 
 294      ['tag', 'tag'] 
 295   
 296      FIXME: ET's Path module handles this case incorrectly; this gives 
 297      a warning in 1.3, and the behaviour will be modified in 1.4. 
 298   
 299      >>> summarize_list(ElementTree.ElementTree(elem).findall("/tag")) 
 300      ['tag', 'tag'] 
 301      """ 
 302   
 303 -def bad_find(): 
 304      """ 
 305      Check bad or unsupported path expressions. 
 306   
 307      >>> elem = SAMPLE_XML 
 308      >>> elem.findall("/tag") 
 309      Traceback (most recent call last): 
 310      SyntaxError: cannot use absolute path on element 
 311   
 312      # this is supported in ET 1.3: 
 313      #>>> elem.findall("section//") 
 314      #Traceback (most recent call last): 
 315      #SyntaxError: invalid path 
 316      """ 
 317   
 318 -def parsefile(): 
 319      """ 
 320      Test parsing from file. 
 321   
 322      >>> tree = ElementTree.parse("samples/simple.xml") 
 323      >>> normalize_crlf(tree) 
 324      >>> tree.write(stdout()) 
 325      <root> 
 326         <element key="value">text</element> 
 327         <element>text</element>tail 
 328         <empty-element/> 
 329      </root> 
 330      >>> tree = ElementTree.parse("samples/simple-ns.xml") 
 331      >>> normalize_crlf(tree) 
 332      >>> tree.write(stdout()) 
 333      <root xmlns="http://namespace/"> 
 334         <element key="value">text</element> 
 335         <element>text</element>tail 
 336         <empty-element/> 
 337      </root> 
 338   
 339  ##     <ns0:root xmlns:ns0="http://namespace/"> 
 340  ##        <ns0:element key="value">text</ns0:element> 
 341  ##        <ns0:element>text</ns0:element>tail 
 342  ##        <ns0:empty-element/> 
 343  ##     </ns0:root> 
 344      """ 
 345   
 346 -def parsehtml(): 
 347      """ 
 348      Test HTML parsing. 
 349   
 350      >>> # p = HTMLTreeBuilder.TreeBuilder() 
 351      >>> p = ElementTree.HTMLParser() 
 352      >>> p.feed("<p><p>spam<b>egg</b></p>") 
 353      >>> serialize(p.close()) 
 354      '<p>spam<b>egg</b></p>' 
 355      """ 
 356   
 357  # doesn't work with lxml.etree 
 358  del parsehtml 
 359   
 360 -def parseliteral(): 
 361      r""" 
 362      >>> element = ElementTree.XML("<html><body>text</body></html>") 
 363      >>> ElementTree.ElementTree(element).write(stdout()) 
 364      <html><body>text</body></html> 
 365      >>> element = ElementTree.fromstring("<html><body>text</body></html>") 
 366      >>> ElementTree.ElementTree(element).write(stdout()) 
 367      <html><body>text</body></html> 
 368   
 369  ##     >>> sequence = ["<html><body>", "text</bo", "dy></html>"] 
 370  ##     >>> element = ElementTree.fromstringlist(sequence) 
 371  ##     >>> ElementTree.ElementTree(element).write(stdout()) 
 372  ##     <html><body>text</body></html> 
 373   
 374      >>> print(repr(ElementTree.tostring(element)).lstrip('b')) 
 375      '<html><body>text</body></html>' 
 376   
 377  # looks different in lxml 
 378  #    >>> print(ElementTree.tostring(element, "ascii")) 
 379  #    <?xml version='1.0' encoding='ascii'?> 
 380  #    <html><body>text</body></html> 
 381   
 382      >>> _, ids = ElementTree.XMLID("<html><body>text</body></html>") 
 383      >>> len(ids) 
 384      0 
 385      >>> _, ids = ElementTree.XMLID("<html><body id='body'>text</body></html>") 
 386      >>> len(ids) 
 387      1 
 388      >>> ids["body"].tag 
 389      'body' 
 390      """ 
 391   
 392 -def simpleparsefile(): 
 393      """ 
 394      Test the xmllib-based parser. 
 395   
 396      >>> from elementtree import SimpleXMLTreeBuilder 
 397      >>> parser = SimpleXMLTreeBuilder.TreeBuilder() 
 398      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
 399      >>> normalize_crlf(tree) 
 400      >>> tree.write(sys.stdout) 
 401      <root> 
 402         <element key="value">text</element> 
 403         <element>text</element>tail 
 404         <empty-element /> 
 405      </root> 
 406      """ 
 407   
 408  # doesn't work with lxml.etree 
 409  del simpleparsefile 
 410   
 411 -def iterparse(): 
 412      """ 
 413      Test iterparse interface. 
 414   
 415      >>> iterparse = ElementTree.iterparse 
 416   
 417      >>> context = iterparse("samples/simple.xml") 
 418      >>> for action, elem in context: 
 419      ...   print("%s %s" % (action, elem.tag)) 
 420      end element 
 421      end element 
 422      end empty-element 
 423      end root 
 424      >>> context.root.tag 
 425      'root' 
 426   
 427      >>> context = iterparse("samples/simple-ns.xml") 
 428      >>> for action, elem in context: 
 429      ...   print("%s %s" % (action, elem.tag)) 
 430      end {http://namespace/}element 
 431      end {http://namespace/}element 
 432      end {http://namespace/}empty-element 
 433      end {http://namespace/}root 
 434   
 435      >>> events = () 
 436      >>> context = iterparse("samples/simple.xml", events) 
 437      >>> for action, elem in context: 
 438      ...   print("%s %s" % (action, elem.tag)) 
 439   
 440      >>> events = () 
 441      >>> context = iterparse("samples/simple.xml", events=events) 
 442      >>> for action, elem in context: 
 443      ...   print("%s %s" % (action, elem.tag)) 
 444   
 445      >>> events = ("start", "end") 
 446      >>> context = iterparse("samples/simple.xml", events) 
 447      >>> for action, elem in context: 
 448      ...   print("%s %s" % (action, elem.tag)) 
 449      start root 
 450      start element 
 451      end element 
 452      start element 
 453      end element 
 454      start empty-element 
 455      end empty-element 
 456      end root 
 457   
 458      >>> events = ("start", "end", "start-ns", "end-ns") 
 459      >>> context = iterparse("samples/simple-ns.xml", events) 
 460      >>> for action, elem in context: 
 461      ...   if action in ("start", "end"): 
 462      ...     print("%s %s" % (action, elem.tag)) 
 463      ...   else: 
 464      ...     print("%s %s" % (action, elem)) 
 465      start-ns ('', 'http://namespace/') 
 466      start {http://namespace/}root 
 467      start {http://namespace/}element 
 468      end {http://namespace/}element 
 469      start {http://namespace/}element 
 470      end {http://namespace/}element 
 471      start {http://namespace/}empty-element 
 472      end {http://namespace/}empty-element 
 473      end {http://namespace/}root 
 474      end-ns None 
 475   
 476      """ 
 477   
 478 -def fancyparsefile(): 
 479      """ 
 480      Test the "fancy" parser. 
 481   
 482      Sanity check. 
 483      >>> from elementtree import XMLTreeBuilder 
 484      >>> parser = XMLTreeBuilder.FancyTreeBuilder() 
 485      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
 486      >>> normalize_crlf(tree) 
 487      >>> tree.write(sys.stdout) 
 488      <root> 
 489         <element key="value">text</element> 
 490         <element>text</element>tail 
 491         <empty-element /> 
 492      </root> 
 493   
 494      Callback check. 
 495      >>> class MyFancyParser(XMLTreeBuilder.FancyTreeBuilder): 
 496      ...     def start(self, elem): 
 497      ...         print("START %s" % elem.tag) 
 498      ...     def end(self, elem): 
 499      ...         print("END %s" % elem.tag) 
 500      >>> parser = MyFancyParser() 
 501      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
 502      START root 
 503      START element 
 504      END element 
 505      START element 
 506      END element 
 507      START empty-element 
 508      END empty-element 
 509      END root 
 510      """ 
 511   
 512  # doesn't work with lxml.etree 
 513  del fancyparsefile 
 514   
 515 -def writefile(): 
 516      """ 
 517      >>> elem = ElementTree.Element("tag") 
 518      >>> elem.text = "text" 
 519      >>> serialize(elem) 
 520      '<tag>text</tag>' 
 521      >>> ElementTree.SubElement(elem, "subtag").text = "subtext" 
 522      >>> serialize(elem) 
 523      '<tag>text<subtag>subtext</subtag></tag>' 
 524   
 525  ##     Test tag suppression 
 526  ##     >>> elem.tag = None 
 527  ##     >>> serialize(elem) 
 528  ##     'text<subtag>subtext</subtag>' 
 529      """ 
 530   
 531 -def writestring(): 
 532      """ 
 533      >>> elem = ElementTree.XML("<html><body>text</body></html>") 
 534      >>> print(repr(ElementTree.tostring(elem)).lstrip('b')) 
 535      '<html><body>text</body></html>' 
 536      >>> elem = ElementTree.fromstring("<html><body>text</body></html>") 
 537      >>> print(repr(ElementTree.tostring(elem)).lstrip('b')) 
 538      '<html><body>text</body></html>' 
 539      """ 
 540   
 541 -def encoding(): 
 542      r""" 
 543      Test encoding issues. 
 544   
 545      >>> elem = ElementTree.Element("tag") 
 546      >>> elem.text = u'abc' 
 547      >>> serialize(elem) 
 548      '<tag>abc</tag>' 
 549      >>> serialize(elem, encoding="utf-8") 
 550      '<tag>abc</tag>' 
 551      >>> serialize(elem, encoding="us-ascii") 
 552      '<tag>abc</tag>' 
 553      >>> serialize(elem, encoding="iso-8859-1").lower() 
 554      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>" 
 555   
 556      >>> elem.text = "<&\"\'>" 
 557      >>> serialize(elem) 
 558      '<tag>&lt;&amp;"\'&gt;</tag>' 
 559      >>> serialize(elem, encoding="utf-8") 
 560      '<tag>&lt;&amp;"\'&gt;</tag>' 
 561      >>> serialize(elem, encoding="us-ascii") # cdata characters 
 562      '<tag>&lt;&amp;"\'&gt;</tag>' 
 563      >>> serialize(elem, encoding="iso-8859-1").lower() 
 564      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag>&lt;&amp;"\'&gt;</tag>' 
 565   
 566      >>> elem.attrib["key"] = "<&\"\'>" 
 567      >>> elem.text = None 
 568      >>> serialize(elem) 
 569      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
 570      >>> serialize(elem, encoding="utf-8") 
 571      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
 572      >>> serialize(elem, encoding="us-ascii") 
 573      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
 574      >>> serialize(elem, encoding="iso-8859-1").lower() 
 575      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="&lt;&amp;&quot;\'&gt;"/>' 
 576   
 577      >>> elem.text = u'\xe5\xf6\xf6<>' 
 578      >>> elem.attrib.clear() 
 579      >>> serialize(elem) 
 580      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
 581      >>> serialize(elem, encoding="utf-8") 
 582      '<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>' 
 583      >>> serialize(elem, encoding="us-ascii") 
 584      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
 585      >>> serialize(elem, encoding="iso-8859-1").lower() 
 586      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6&lt;&gt;</tag>" 
 587   
 588      >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>' 
 589      >>> elem.text = None 
 590      >>> serialize(elem) 
 591      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
 592      >>> serialize(elem, encoding="utf-8") 
 593      '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;"/>' 
 594      >>> serialize(elem, encoding="us-ascii") 
 595      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
 596      >>> serialize(elem, encoding="iso-8859-1").lower() 
 597      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6&lt;&gt;"/>' 
 598      """ 
 599   
 600  if sys.version_info[0] >= 3: 
 601      encoding.__doc__ = encoding.__doc__.replace("u'", "'") 
 602   
 603 -def methods(): 
 604      r""" 
 605      Test serialization methods. 
 606   
 607      >>> e = ET.XML("<html><link/><script>1 &lt; 2</script></html>") 
 608      >>> e.tail = "\n" 
 609      >>> serialize(e) 
 610      '<html><link /><script>1 &lt; 2</script></html>\n' 
 611      >>> serialize(e, method=None) 
 612      '<html><link /><script>1 &lt; 2</script></html>\n' 
 613      >>> serialize(e, method="xml") 
 614      '<html><link /><script>1 &lt; 2</script></html>\n' 
 615      >>> serialize(e, method="html") 
 616      '<html><link><script>1 < 2</script></html>\n' 
 617      >>> serialize(e, method="text") 
 618      '1 < 2\n' 
 619   
 620      """ 
 621   
 622  # doesn't work with lxml.etree 
 623  del methods 
 624   
 625 -def iterators(): 
 626      """ 
 627      Test iterators. 
 628   
 629      >>> e = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>") 
 630      >>> summarize_list(e.iter()) 
 631      ['html', 'body', 'i'] 
 632      >>> summarize_list(e.find("body").iter()) 
 633      ['body', 'i'] 
 634      >>> "".join(e.itertext()) 
 635      'this is a paragraph...' 
 636      >>> "".join(e.find("body").itertext()) 
 637      'this is a paragraph.' 
 638      """ 
 639   
 640  ENTITY_XML = """\ 
 641  <!DOCTYPE points [ 
 642  <!ENTITY % user-entities SYSTEM 'user-entities.xml'> 
 643  %user-entities; 
 644  ]> 
 645  <document>&entity;</document> 
 646  """ 
 647   
 648 -def entity(): 
 649      """ 
 650      Test entity handling. 
 651   
 652      1) bad entities 
 653   
 654      >>> ElementTree.XML("<document>&entity;</document>") 
 655      Traceback (most recent call last): 
 656      ExpatError: undefined entity: line 1, column 10 
 657   
 658      >>> ElementTree.XML(ENTITY_XML) 
 659      Traceback (most recent call last): 
 660      ExpatError: undefined entity &entity;: line 5, column 10 
 661   
 662      (add more tests here) 
 663   
 664      """ 
 665   
 666  # doesn't work with lxml.etree 
 667  del entity 
 668   
 669 -def error(xml): 
 670      """ 
 671      Test error handling. 
 672   
 673      >>> error("foo").position 
 674      (1, 0) 
 675      >>> error("<tag>&foo;</tag>").position 
 676      (1, 5) 
 677      >>> error("foobar<").position 
 678      (1, 6) 
 679   
 680      """ 
 681      try: 
 682          ET.XML(xml) 
 683      except ET.ParseError: 
 684          return sys.exc_value 
 685   
 686  # doesn't work with lxml.etree -> different positions 
 687  del error 
 688   
 689 -def namespace(): 
 690      """ 
 691      Test namespace issues. 
 692   
 693      1) xml namespace 
 694   
 695      >>> elem = ElementTree.XML("<tag xml:lang='en' />") 
 696      >>> serialize(elem) # 1.1 
 697      '<tag xml:lang="en"/>' 
 698   
 699      2) other "well-known" namespaces 
 700   
 701      >>> elem = ElementTree.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />") 
 702      >>> serialize(elem) # 2.1 
 703      '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>' 
 704   
 705      >>> elem = ElementTree.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />") 
 706      >>> serialize(elem) # 2.2 
 707      '<html:html xmlns:html="http://www.w3.org/1999/xhtml"/>' 
 708   
 709      >>> elem = ElementTree.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />") 
 710      >>> serialize(elem) # 2.3 
 711      '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope"/>' 
 712   
 713      3) unknown namespaces 
 714   
 715      """ 
 716   
 717 -def qname(): 
 718      """ 
 719      Test QName handling. 
 720   
 721      1) decorated tags 
 722   
 723      >>> elem = ElementTree.Element("{uri}tag") 
 724      >>> serialize(elem) # 1.1 
 725      '<ns0:tag xmlns:ns0="uri"/>' 
 726      >>> elem = ElementTree.Element(ElementTree.QName("{uri}tag")) 
 727      >>> serialize(elem) # 1.2 
 728      '<ns0:tag xmlns:ns0="uri"/>' 
 729      >>> elem = ElementTree.Element(ElementTree.QName("uri", "tag")) 
 730      >>> serialize(elem) # 1.3 
 731      '<ns0:tag xmlns:ns0="uri"/>' 
 732   
 733  # ns/attribute order ... 
 734   
 735  ##     2) decorated attributes 
 736   
 737  ##     >>> elem.clear() 
 738  ##     >>> elem.attrib["{uri}key"] = "value" 
 739  ##     >>> serialize(elem) # 2.1 
 740  ##     '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>' 
 741   
 742  ##     >>> elem.clear() 
 743  ##     >>> elem.attrib[ElementTree.QName("{uri}key")] = "value" 
 744  ##     >>> serialize(elem) # 2.2 
 745  ##     '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>' 
 746   
 747  ##     3) decorated values are not converted by default, but the 
 748  ##        QName wrapper can be used for values 
 749   
 750  ##     >>> elem.clear() 
 751  ##     >>> elem.attrib["{uri}key"] = "{uri}value" 
 752  ##     >>> serialize(elem) # 3.1 
 753  ##     '<ns0:tag ns0:key="{uri}value" xmlns:ns0="uri"/>' 
 754   
 755  ##     >>> elem.clear() 
 756  ##     >>> elem.attrib["{uri}key"] = ElementTree.QName("{uri}value") 
 757  ##     >>> serialize(elem) # 3.2 
 758  ##     '<ns0:tag ns0:key="ns0:value" xmlns:ns0="uri"/>' 
 759   
 760  ##     >>> elem.clear() 
 761  ##     >>> subelem = ElementTree.Element("tag") 
 762  ##     >>> subelem.attrib["{uri1}key"] = ElementTree.QName("{uri2}value") 
 763  ##     >>> elem.append(subelem) 
 764  ##     >>> elem.append(subelem) 
 765  ##     >>> serialize(elem) # 3.3 
 766  ##     '<ns0:tag xmlns:ns0="uri"><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/></ns0:tag>' 
 767   
 768      """ 
 769   
 770 -def xpath_tokenizer(p): 
 771      """ 
 772      Test the XPath tokenizer. 
 773   
 774      >>> # tests from the xml specification 
 775      >>> xpath_tokenizer("*") 
 776      ['*'] 
 777      >>> xpath_tokenizer("text()") 
 778      ['text', '()'] 
 779      >>> xpath_tokenizer("@name") 
 780      ['@', 'name'] 
 781      >>> xpath_tokenizer("@*") 
 782      ['@', '*'] 
 783      >>> xpath_tokenizer("para[1]") 
 784      ['para', '[', '1', ']'] 
 785      >>> xpath_tokenizer("para[last()]") 
 786      ['para', '[', 'last', '()', ']'] 
 787      >>> xpath_tokenizer("*/para") 
 788      ['*', '/', 'para'] 
 789      >>> xpath_tokenizer("/doc/chapter[5]/section[2]") 
 790      ['/', 'doc', '/', 'chapter', '[', '5', ']', '/', 'section', '[', '2', ']'] 
 791      >>> xpath_tokenizer("chapter//para") 
 792      ['chapter', '//', 'para'] 
 793      >>> xpath_tokenizer("//para") 
 794      ['//', 'para'] 
 795      >>> xpath_tokenizer("//olist/item") 
 796      ['//', 'olist', '/', 'item'] 
 797      >>> xpath_tokenizer(".") 
 798      ['.'] 
 799      >>> xpath_tokenizer(".//para") 
 800      ['.', '//', 'para'] 
 801      >>> xpath_tokenizer("..") 
 802      ['..'] 
 803      >>> xpath_tokenizer("../@lang") 
 804      ['..', '/', '@', 'lang'] 
 805      >>> xpath_tokenizer("chapter[title]") 
 806      ['chapter', '[', 'title', ']'] 
 807      >>> xpath_tokenizer("employee[@secretary and @assistant]") 
 808      ['employee', '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']'] 
 809   
 810      >>> # additional tests 
 811      >>> xpath_tokenizer("{http://spam}egg") 
 812      ['{http://spam}egg'] 
 813      >>> xpath_tokenizer("./spam.egg") 
 814      ['.', '/', 'spam.egg'] 
 815      >>> xpath_tokenizer(".//{http://spam}egg") 
 816      ['.', '//', '{http://spam}egg'] 
 817      """ 
 818      out = [] 
 819      for op, tag in ElementPath.xpath_tokenizer(p): 
 820          out.append(op or tag) 
 821      return out 
 822   
 823  # 
 824  # xinclude tests (samples from appendix C of the xinclude specification) 
 825   
 826  XINCLUDE = {} 
 827   
 828  XINCLUDE["C1.xml"] = """\ 
 829  <?xml version='1.0'?> 
 830  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
 831    <p>120 Mz is adequate for an average home user.</p> 
 832    <xi:include href="disclaimer.xml"/> 
 833  </document> 
 834  """ 
 835   
 836  XINCLUDE["disclaimer.xml"] = """\ 
 837  <?xml version='1.0'?> 
 838  <disclaimer> 
 839    <p>The opinions represented herein represent those of the individual 
 840    and should not be interpreted as official policy endorsed by this 
 841    organization.</p> 
 842  </disclaimer> 
 843  """ 
 844   
 845  XINCLUDE["C2.xml"] = """\ 
 846  <?xml version='1.0'?> 
 847  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
 848    <p>This document has been accessed 
 849    <xi:include href="count.txt" parse="text"/> times.</p> 
 850  </document> 
 851  """ 
 852   
 853  XINCLUDE["count.txt"] = "324387" 
 854   
 855  XINCLUDE["C3.xml"] = """\ 
 856  <?xml version='1.0'?> 
 857  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
 858    <p>The following is the source of the "data.xml" resource:</p> 
 859    <example><xi:include href="data.xml" parse="text"/></example> 
 860  </document> 
 861  """ 
 862   
 863  XINCLUDE["data.xml"] = """\ 
 864  <?xml version='1.0'?> 
 865  <data> 
 866    <item><![CDATA[Brooks & Shields]]></item> 
 867  </data> 
 868  """ 
 869   
 870  XINCLUDE["C5.xml"] = """\ 
 871  <?xml version='1.0'?> 
 872  <div xmlns:xi="http://www.w3.org/2001/XInclude"> 
 873    <xi:include href="example.txt" parse="text"> 
 874      <xi:fallback> 
 875        <xi:include href="fallback-example.txt" parse="text"> 
 876          <xi:fallback><a href="mailto:bob@example.org">Report error</a></xi:fallback> 
 877        </xi:include> 
 878      </xi:fallback> 
 879    </xi:include> 
 880  </div> 
 881  """ 
 882   
 883  XINCLUDE["default.xml"] = """\ 
 884  <?xml version='1.0'?> 
 885  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
 886    <p>Example.</p> 
 887    <xi:include href="samples/simple.xml"/> 
 888  </document> 
 889  """ 
 890   
 891 -def xinclude_loader(href, parse="xml", encoding=None): 
 892      try: 
 893          data = XINCLUDE[href] 
 894      except KeyError: 
 895          raise IOError("resource not found") 
 896      if parse == "xml": 
 897          return ElementTree.XML(data) 
 898      return data 
 899   
 900 -def xinclude(): 
 901      r""" 
 902      Basic inclusion example (XInclude C.1) 
 903   
 904      >>> document = xinclude_loader("C1.xml") 
 905      >>> ElementInclude.include(document, xinclude_loader) 
 906      >>> print(serialize(document)) # C1 
 907      <document> 
 908        <p>120 Mz is adequate for an average home user.</p> 
 909        <disclaimer> 
 910        <p>The opinions represented herein represent those of the individual 
 911        and should not be interpreted as official policy endorsed by this 
 912        organization.</p> 
 913      </disclaimer> 
 914      </document> 
 915   
 916      Textual inclusion example (XInclude C.2) 
 917   
 918      >>> document = xinclude_loader("C2.xml") 
 919      >>> ElementInclude.include(document, xinclude_loader) 
 920      >>> print(serialize(document)) # C2 
 921      <document> 
 922        <p>This document has been accessed 
 923        324387 times.</p> 
 924      </document> 
 925   
 926      Textual inclusion of XML example (XInclude C.3) 
 927   
 928      >>> document = xinclude_loader("C3.xml") 
 929      >>> ElementInclude.include(document, xinclude_loader) 
 930      >>> print(serialize(document)) # C3 
 931      <document> 
 932        <p>The following is the source of the "data.xml" resource:</p> 
 933        <example>&lt;?xml version='1.0'?&gt; 
 934      &lt;data&gt; 
 935        &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt; 
 936      &lt;/data&gt; 
 937      </example> 
 938      </document> 
 939   
 940  ##     Fallback example (XInclude C.5) 
 941  ##     Note! Fallback support is not yet implemented 
 942   
 943  ##     >>> document = xinclude_loader("C5.xml") 
 944  ##     >>> ElementInclude.include(document, xinclude_loader) 
 945  ##     Traceback (most recent call last): 
 946  ##     IOError: resource not found 
 947  ##     >>> # print(serialize(document)) # C5 
 948   
 949      """ 
 950   
 951 -def xinclude_default(): 
 952      """ 
 953      >>> document = xinclude_loader("default.xml") 
 954      >>> ElementInclude.include(document) 
 955      >>> print(serialize(document)) # default 
 956      <document> 
 957        <p>Example.</p> 
 958        <root> 
 959         <element key="value">text</element> 
 960         <element>text</element>tail 
 961         <empty-element/> 
 962      </root> 
 963      </document> 
 964      """ 
 965   
 966  # 
 967  # xmlwriter 
 968   
 969 -def xmlwriter(): 
 970      r""" 
 971      >>> file = BytesIO() 
 972      >>> w = SimpleXMLWriter.XMLWriter(file) 
 973      >>> html = w.start("html") 
 974      >>> x = w.start("head") 
 975      >>> w.element("title", "my document") 
 976      >>> w.data("\n") 
 977      >>> w.element("meta", name="hello", value="goodbye") 
 978      >>> w.data("\n") 
 979      >>> w.end() 
 980      >>> x = w.start("body") 
 981      >>> w.element("h1", "this is a heading") 
 982      >>> w.data("\n") 
 983      >>> w.element("p", u"this is a paragraph") 
 984      >>> w.data("\n") 
 985      >>> w.element("p", u"reserved characters: <&>") 
 986      >>> w.data("\n") 
 987      >>> w.element("p", u"detta är också ett stycke") 
 988      >>> w.data("\n") 
 989      >>> w.close(html) 
 990      >>> print(file.getvalue()) 
 991      <html><head><title>my document</title> 
 992      <meta name="hello" value="goodbye" /> 
 993      </head><body><h1>this is a heading</h1> 
 994      <p>this is a paragraph</p> 
 995      <p>reserved characters: &lt;&amp;&gt;</p> 
 996      <p>detta &#228;r ocks&#229; ett stycke</p> 
 997      </body></html> 
 998      """ 
 999   
1000  # doesn't work with lxml.etree 
1001  del xmlwriter 
1002   
1003  # -------------------------------------------------------------------- 
1004  # reported bugs 
1005   
1006 -def bug_xmltoolkit21(): 
1007      """ 
1008      marshaller gives obscure errors for non-string values 
1009   
1010      >>> elem = ElementTree.Element(123) 
1011      >>> serialize(elem) # tag 
1012      Traceback (most recent call last): 
1013      TypeError: cannot serialize 123 (type int) 
1014      >>> elem = ElementTree.Element("elem") 
1015      >>> elem.text = 123 
1016      >>> serialize(elem) # text 
1017      Traceback (most recent call last): 
1018      TypeError: cannot serialize 123 (type int) 
1019      >>> elem = ElementTree.Element("elem") 
1020      >>> elem.tail = 123 
1021      >>> serialize(elem) # tail 
1022      Traceback (most recent call last): 
1023      TypeError: cannot serialize 123 (type int) 
1024      >>> elem = ElementTree.Element("elem") 
1025      >>> elem.set(123, "123") 
1026      >>> serialize(elem) # attribute key 
1027      Traceback (most recent call last): 
1028      TypeError: cannot serialize 123 (type int) 
1029      >>> elem = ElementTree.Element("elem") 
1030      >>> elem.set("123", 123) 
1031      >>> serialize(elem) # attribute value 
1032      Traceback (most recent call last): 
1033      TypeError: cannot serialize 123 (type int) 
1034   
1035      """ 
1036   
1037  # doesn't work with lxml.etree 
1038  del bug_xmltoolkit21 
1039   
1040 -def bug_xmltoolkit25(): 
1041      """ 
1042      typo in ElementTree.findtext 
1043   
1044      >>> tree = ElementTree.ElementTree(SAMPLE_XML) 
1045      >>> tree.findtext("tag") 
1046      'text' 
1047      >>> tree.findtext("section/tag") 
1048      'subtext' 
1049      """ 
1050   
1051 -def bug_xmltoolkit28(): 
1052      """ 
1053      .//tag causes exceptions 
1054   
1055      >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>") 
1056      >>> summarize_list(tree.findall(".//thead")) 
1057      [] 
1058      >>> summarize_list(tree.findall(".//tbody")) 
1059      ['tbody'] 
1060      """ 
1061   
1062 -def bug_xmltoolkitX1(): 
1063      """ 
1064      dump() doesn't flush the output buffer 
1065   
1066      >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>") 
1067      >>> ElementTree.dump(tree); sys.stdout.write("tail") 
1068      <doc><table><tbody /></table></doc> 
1069      tail 
1070      """ 
1071   
1072  # doesn't work with lxml.etree 
1073  del bug_xmltoolkitX1 
1074   
1075 -def bug_xmltoolkit39(): 
1076      """ 
1077      non-ascii element and attribute names doesn't work 
1078   
1079      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg />") 
1080      >>> ElementTree.tostring(tree, "utf-8") 
1081      '<t\\xc3\\xa4g />' 
1082   
1083      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><tag ättr='v&#228;lue' />") 
1084      >>> tree.attrib 
1085      {u'\\xe4ttr': u'v\\xe4lue'} 
1086      >>> ElementTree.tostring(tree, "utf-8") 
1087      '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />' 
1088   
1089      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg>text</täg>") 
1090      >>> ElementTree.tostring(tree, "utf-8") 
1091      '<t\\xc3\\xa4g>text</t\\xc3\\xa4g>' 
1092   
1093      >>> tree = ElementTree.Element(u"täg") 
1094      >>> ElementTree.tostring(tree, "utf-8") 
1095      '<t\\xc3\\xa4g />' 
1096   
1097      >>> tree = ElementTree.Element("tag") 
1098      >>> tree.set(u"ättr", u"välue") 
1099      >>> ElementTree.tostring(tree, "utf-8") 
1100      '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />' 
1101   
1102      """ 
1103   
1104  # doesn't work with lxml.etree 
1105  del bug_xmltoolkit39 
1106   
1107 -def bug_xmltoolkit45(): 
1108      """ 
1109      problems parsing mixed unicode/non-ascii html documents 
1110   
1111      latin-1 text 
1112      >>> p = HTMLTreeBuilder.TreeBuilder() 
1113      >>> p.feed("<p>välue</p>") 
1114      >>> serialize(p.close()) 
1115      '<p>v&#228;lue</p>' 
1116   
1117      utf-8 text 
1118      >>> p = HTMLTreeBuilder.TreeBuilder(encoding="utf-8") 
1119      >>> p.feed("<p>v\xc3\xa4lue</p>") 
1120      >>> serialize(p.close()) 
1121      '<p>v&#228;lue</p>' 
1122   
1123      utf-8 text using meta tag 
1124      >>> p = HTMLTreeBuilder.TreeBuilder() 
1125      >>> p.feed("<html><meta http-equiv='Content-Type' content='text/html; charset=utf-8'><p>v\xc3\xa4lue</p></html>") 
1126      >>> serialize(p.close().find("p")) 
1127      '<p>v&#228;lue</p>' 
1128   
1129      latin-1 character references 
1130      >>> p = HTMLTreeBuilder.TreeBuilder() 
1131      >>> p.feed("<p>v&#228;lue</p>") 
1132      >>> serialize(p.close()) 
1133      '<p>v&#228;lue</p>' 
1134   
1135      latin-1 character entities 
1136      >>> p = HTMLTreeBuilder.TreeBuilder() 
1137      >>> p.feed("<p>v&auml;lue</p>") 
1138      >>> serialize(p.close()) 
1139      '<p>v&#228;lue</p>' 
1140   
1141      mixed latin-1 text and unicode entities 
1142      >>> p = HTMLTreeBuilder.TreeBuilder() 
1143      >>> p.feed("<p>&#8221;välue&#8221;</p>") 
1144      >>> serialize(p.close()) 
1145      '<p>&#8221;v&#228;lue&#8221;</p>' 
1146   
1147      mixed unicode and latin-1 entities 
1148      >>> p = HTMLTreeBuilder.TreeBuilder() 
1149      >>> p.feed("<p>&#8221;v&auml;lue&#8221;</p>") 
1150      >>> serialize(p.close()) 
1151      '<p>&#8221;v&#228;lue&#8221;</p>' 
1152   
1153      """ 
1154   
1155  # doesn't work with lxml.etree 
1156  del bug_xmltoolkit45 
1157   
1158 -def bug_xmltoolkit46(): 
1159      """ 
1160      problems parsing open BR tags 
1161   
1162     >>> p = HTMLTreeBuilder.TreeBuilder() 
1163      >>> p.feed("<p>key<br>value</p>") 
1164      >>> serialize(p.close()) 
1165      '<p>key<br />value</p>' 
1166   
1167      """ 
1168   
1169  # doesn't work with lxml.etree 
1170  del bug_xmltoolkit46 
1171   
1172 -def bug_xmltoolkit54(): 
1173      """ 
1174      problems handling internally defined entities 
1175   
1176      >>> e = ElementTree.XML("<!DOCTYPE doc [<!ENTITY ldots '&#x8230;'>]><doc>&ldots;</doc>") 
1177      >>> serialize(e) 
1178      '<doc>&#33328;</doc>' 
1179      """ 
1180   
1181  # doesn't work with lxml.etree 
1182  del bug_xmltoolkit54 
1183   
1184 -def bug_xmltoolkit55(): 
1185      """ 
1186      make sure we're reporting the first error, not the last 
1187   
1188      >>> e = ElementTree.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'><doc>&ldots;&ndots;&rdots;</doc>") 
1189      Traceback (most recent call last): 
1190      ParseError: undefined entity &ldots;: line 1, column 36 
1191      """ 
1192   
1193  # doesn't work with lxml.etree 
1194  del bug_xmltoolkit55 
1195   
1196 -def bug_200708_version(): 
1197      """ 
1198      >>> parser = ET.XMLParser() 
1199      >>> parser.version 
1200      'Expat 2.0.0' 
1201      >>> parser.feed(open("samples/simple.xml").read()) 
1202      >>> print(serialize(parser.close())) 
1203      <root> 
1204         <element key="value">text</element> 
1205         <element>text</element>tail 
1206         <empty-element /> 
1207      </root> 
1208      """ 
1209   
1210  # doesn't work with lxml.etree 
1211  del bug_200708_version 
1212   
1213 -def bug_200708_newline(): 
1214      r""" 
1215   
1216      Preserve newlines in attributes. 
1217   
1218      >>> e = ET.Element('SomeTag', text="def _f():\n  return 3\n") 
1219      >>> ET.tostring(e) 
1220      '<SomeTag text="def _f():&#10;  return 3&#10;" />' 
1221      >>> ET.XML(ET.tostring(e)).get("text") 
1222      'def _f():\n  return 3\n' 
1223      >>> ET.tostring(ET.XML(ET.tostring(e))) 
1224      '<SomeTag text="def _f():&#10;  return 3&#10;" />' 
1225      """ 
1226   
1227  # doesn't work with lxml.etree 
1228  del bug_200708_newline 
1229   
1230 -def bug_200709_default_namespace(): 
1231      """ 
1232   
1233      >>> e = ET.Element("{default}elem") 
1234      >>> s = ET.SubElement(e, "{default}elem") 
1235      >>> serialize(e, default_namespace="default") # 1 
1236      '<elem xmlns="default"><elem /></elem>' 
1237   
1238      >>> e = ET.Element("{default}elem") 
1239      >>> s = ET.SubElement(e, "{default}elem") 
1240      >>> s = ET.SubElement(e, "{not-default}elem") 
1241      >>> serialize(e, default_namespace="default") # 2 
1242      '<elem xmlns="default" xmlns:ns1="not-default"><elem /><ns1:elem /></elem>' 
1243   
1244      >>> e = ET.Element("{default}elem") 
1245      >>> s = ET.SubElement(e, "{default}elem") 
1246      >>> s = ET.SubElement(e, "elem") # unprefixed name 
1247      >>> serialize(e, default_namespace="default") # 3 
1248      Traceback (most recent call last): 
1249      ValueError: cannot use non-qualified names with default_namespace option 
1250   
1251      """ 
1252   
1253  # doesn't work with lxml.etree 
1254  del bug_200709_default_namespace 
1255   
1256  # -------------------------------------------------------------------- 
1257   
1258  if __name__ == "__main__": 
1259      import doctest, selftest 
1260      failed, tested = doctest.testmod(selftest) 
1261      print("%d tests ok." % (tested - failed)) 
1262      if failed > 0: 
1263          print("%d tests failed. Exiting with non-zero return code." % failed) 
1264          sys.exit(1) 
1265