[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_xml_etree.py

# xml.etree test.  This file contains enough tests to make sure that\r
# all included components work as they should.\r
# Large parts are extracted from the upstream test suite.\r
\r
# IMPORTANT: the same doctests are run from "test_xml_etree_c" in\r
# order to ensure consistency between the C implementation and the\r
# Python implementation.\r
#\r
# For this purpose, the module-level "ET" symbol is temporarily\r
# monkey-patched when running the "test_xml_etree_c" test suite.\r
# Don't re-import "xml.etree.ElementTree" module in the docstring,\r
# except if the test is specific to the Python implementation.\r
\r
import sys\r
import cgi\r
\r
from test import test_support\r
from test.test_support import findfile\r
\r
from xml.etree import ElementTree as ET\r
\r
SIMPLE_XMLFILE = findfile("simple.xml", subdir="xmltestdata")\r
SIMPLE_NS_XMLFILE = findfile("simple-ns.xml", subdir="xmltestdata")\r
\r
SAMPLE_XML = """\\r
<body>\r
  <tag class='a'>text</tag>\r
  <tag class='b' />\r
  <section>\r
    <tag class='b' id='inner'>subtext</tag>\r
  </section>\r
</body>\r
"""\r
\r
SAMPLE_SECTION = """\\r
<section>\r
  <tag class='b' id='inner'>subtext</tag>\r
  <nexttag />\r
  <nextsection>\r
    <tag />\r
  </nextsection>\r
</section>\r
"""\r
\r
SAMPLE_XML_NS = """\r
<body xmlns="http://effbot.org/ns">\r
  <tag>text</tag>\r
  <tag />\r
  <section>\r
    <tag>subtext</tag>\r
  </section>\r
</body>\r
"""\r
\r
\r
def sanity():\r
    """\r
    Import sanity.\r
\r
    >>> from xml.etree import ElementTree\r
    >>> from xml.etree import ElementInclude\r
    >>> from xml.etree import ElementPath\r
    """\r
\r
def check_method(method):\r
    if not hasattr(method, '__call__'):\r
        print method, "not callable"\r
\r
def serialize(elem, to_string=True, **options):\r
    import StringIO\r
    file = StringIO.StringIO()\r
    tree = ET.ElementTree(elem)\r
    tree.write(file, **options)\r
    if to_string:\r
        return file.getvalue()\r
    else:\r
        file.seek(0)\r
        return file\r
\r
def summarize(elem):\r
    if elem.tag == ET.Comment:\r
        return "<Comment>"\r
    return elem.tag\r
\r
def summarize_list(seq):\r
    return [summarize(elem) for elem in seq]\r
\r
def normalize_crlf(tree):\r
    for elem in tree.iter():\r
        if elem.text:\r
            elem.text = elem.text.replace("\r\n", "\n")\r
        if elem.tail:\r
            elem.tail = elem.tail.replace("\r\n", "\n")\r
\r
def check_string(string):\r
    len(string)\r
    for char in string:\r
        if len(char) != 1:\r
            print "expected one-character string, got %r" % char\r
    new_string = string + ""\r
    new_string = string + " "\r
    string[:0]\r
\r
def check_mapping(mapping):\r
    len(mapping)\r
    keys = mapping.keys()\r
    items = mapping.items()\r
    for key in keys:\r
        item = mapping[key]\r
    mapping["key"] = "value"\r
    if mapping["key"] != "value":\r
        print "expected value string, got %r" % mapping["key"]\r
\r
def check_element(element):\r
    if not ET.iselement(element):\r
        print "not an element"\r
    if not hasattr(element, "tag"):\r
        print "no tag member"\r
    if not hasattr(element, "attrib"):\r
        print "no attrib member"\r
    if not hasattr(element, "text"):\r
        print "no text member"\r
    if not hasattr(element, "tail"):\r
        print "no tail member"\r
\r
    check_string(element.tag)\r
    check_mapping(element.attrib)\r
    if element.text is not None:\r
        check_string(element.text)\r
    if element.tail is not None:\r
        check_string(element.tail)\r
    for elem in element:\r
        check_element(elem)\r
\r
# --------------------------------------------------------------------\r
# element tree tests\r
\r
def interface():\r
    r"""\r
    Test element tree interface.\r
\r
    >>> element = ET.Element("tag")\r
    >>> check_element(element)\r
    >>> tree = ET.ElementTree(element)\r
    >>> check_element(tree.getroot())\r
\r
    >>> element = ET.Element("t\xe4g", key="value")\r
    >>> tree = ET.ElementTree(element)\r
    >>> repr(element)   # doctest: +ELLIPSIS\r
    "<Element 't\\xe4g' at 0x...>"\r
    >>> element = ET.Element("tag", key="value")\r
\r
    Make sure all standard element methods exist.\r
\r
    >>> check_method(element.append)\r
    >>> check_method(element.extend)\r
    >>> check_method(element.insert)\r
    >>> check_method(element.remove)\r
    >>> check_method(element.getchildren)\r
    >>> check_method(element.find)\r
    >>> check_method(element.iterfind)\r
    >>> check_method(element.findall)\r
    >>> check_method(element.findtext)\r
    >>> check_method(element.clear)\r
    >>> check_method(element.get)\r
    >>> check_method(element.set)\r
    >>> check_method(element.keys)\r
    >>> check_method(element.items)\r
    >>> check_method(element.iter)\r
    >>> check_method(element.itertext)\r
    >>> check_method(element.getiterator)\r
\r
    These methods return an iterable. See bug 6472.\r
\r
    >>> check_method(element.iter("tag").next)\r
    >>> check_method(element.iterfind("tag").next)\r
    >>> check_method(element.iterfind("*").next)\r
    >>> check_method(tree.iter("tag").next)\r
    >>> check_method(tree.iterfind("tag").next)\r
    >>> check_method(tree.iterfind("*").next)\r
\r
    These aliases are provided:\r
\r
    >>> assert ET.XML == ET.fromstring\r
    >>> assert ET.PI == ET.ProcessingInstruction\r
    >>> assert ET.XMLParser == ET.XMLTreeBuilder\r
    """\r
\r
def simpleops():\r
    """\r
    Basic method sanity checks.\r
\r
    >>> elem = ET.XML("<body><tag/></body>")\r
    >>> serialize(elem)\r
    '<body><tag /></body>'\r
    >>> e = ET.Element("tag2")\r
    >>> elem.append(e)\r
    >>> serialize(elem)\r
    '<body><tag /><tag2 /></body>'\r
    >>> elem.remove(e)\r
    >>> serialize(elem)\r
    '<body><tag /></body>'\r
    >>> elem.insert(0, e)\r
    >>> serialize(elem)\r
    '<body><tag2 /><tag /></body>'\r
    >>> elem.remove(e)\r
    >>> elem.extend([e])\r
    >>> serialize(elem)\r
    '<body><tag /><tag2 /></body>'\r
    >>> elem.remove(e)\r
\r
    >>> element = ET.Element("tag", key="value")\r
    >>> serialize(element) # 1\r
    '<tag key="value" />'\r
    >>> subelement = ET.Element("subtag")\r
    >>> element.append(subelement)\r
    >>> serialize(element) # 2\r
    '<tag key="value"><subtag /></tag>'\r
    >>> element.insert(0, subelement)\r
    >>> serialize(element) # 3\r
    '<tag key="value"><subtag /><subtag /></tag>'\r
    >>> element.remove(subelement)\r
    >>> serialize(element) # 4\r
    '<tag key="value"><subtag /></tag>'\r
    >>> element.remove(subelement)\r
    >>> serialize(element) # 5\r
    '<tag key="value" />'\r
    >>> element.remove(subelement)\r
    Traceback (most recent call last):\r
    ValueError: list.remove(x): x not in list\r
    >>> serialize(element) # 6\r
    '<tag key="value" />'\r
    >>> element[0:0] = [subelement, subelement, subelement]\r
    >>> serialize(element[1])\r
    '<subtag />'\r
    >>> element[1:9] == [element[1], element[2]]\r
    True\r
    >>> element[:9:2] == [element[0], element[2]]\r
    True\r
    >>> del element[1:2]\r
    >>> serialize(element)\r
    '<tag key="value"><subtag /><subtag /></tag>'\r
    """\r
\r
def cdata():\r
    """\r
    Test CDATA handling (etc).\r
\r
    >>> serialize(ET.XML("<tag>hello</tag>"))\r
    '<tag>hello</tag>'\r
    >>> serialize(ET.XML("<tag>&#104;&#101;&#108;&#108;&#111;</tag>"))\r
    '<tag>hello</tag>'\r
    >>> serialize(ET.XML("<tag><![CDATA[hello]]></tag>"))\r
    '<tag>hello</tag>'\r
    """\r
\r
# Only with Python implementation\r
def simplefind():\r
    """\r
    Test find methods using the elementpath fallback.\r
\r
    >>> from xml.etree import ElementTree\r
\r
    >>> CurrentElementPath = ElementTree.ElementPath\r
    >>> ElementTree.ElementPath = ElementTree._SimpleElementPath()\r
    >>> elem = ElementTree.XML(SAMPLE_XML)\r
    >>> elem.find("tag").tag\r
    'tag'\r
    >>> ElementTree.ElementTree(elem).find("tag").tag\r
    'tag'\r
    >>> elem.findtext("tag")\r
    'text'\r
    >>> elem.findtext("tog")\r
    >>> elem.findtext("tog", "default")\r
    'default'\r
    >>> ElementTree.ElementTree(elem).findtext("tag")\r
    'text'\r
    >>> summarize_list(elem.findall("tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall(".//tag"))\r
    ['tag', 'tag', 'tag']\r
\r
    Path syntax doesn't work in this case.\r
\r
    >>> elem.find("section/tag")\r
    >>> elem.findtext("section/tag")\r
    >>> summarize_list(elem.findall("section/tag"))\r
    []\r
\r
    >>> ElementTree.ElementPath = CurrentElementPath\r
    """\r
\r
def find():\r
    """\r
    Test find methods (including xpath syntax).\r
\r
    >>> elem = ET.XML(SAMPLE_XML)\r
    >>> elem.find("tag").tag\r
    'tag'\r
    >>> ET.ElementTree(elem).find("tag").tag\r
    'tag'\r
    >>> elem.find("section/tag").tag\r
    'tag'\r
    >>> elem.find("./tag").tag\r
    'tag'\r
    >>> ET.ElementTree(elem).find("./tag").tag\r
    'tag'\r
    >>> ET.ElementTree(elem).find("/tag").tag\r
    'tag'\r
    >>> elem[2] = ET.XML(SAMPLE_SECTION)\r
    >>> elem.find("section/nexttag").tag\r
    'nexttag'\r
    >>> ET.ElementTree(elem).find("section/tag").tag\r
    'tag'\r
    >>> ET.ElementTree(elem).find("tog")\r
    >>> ET.ElementTree(elem).find("tog/foo")\r
    >>> elem.findtext("tag")\r
    'text'\r
    >>> elem.findtext("section/nexttag")\r
    ''\r
    >>> elem.findtext("section/nexttag", "default")\r
    ''\r
    >>> elem.findtext("tog")\r
    >>> elem.findtext("tog", "default")\r
    'default'\r
    >>> ET.ElementTree(elem).findtext("tag")\r
    'text'\r
    >>> ET.ElementTree(elem).findtext("tog/foo")\r
    >>> ET.ElementTree(elem).findtext("tog/foo", "default")\r
    'default'\r
    >>> ET.ElementTree(elem).findtext("./tag")\r
    'text'\r
    >>> ET.ElementTree(elem).findtext("/tag")\r
    'text'\r
    >>> elem.findtext("section/tag")\r
    'subtext'\r
    >>> ET.ElementTree(elem).findtext("section/tag")\r
    'subtext'\r
    >>> summarize_list(elem.findall("."))\r
    ['body']\r
    >>> summarize_list(elem.findall("tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall("tog"))\r
    []\r
    >>> summarize_list(elem.findall("tog/foo"))\r
    []\r
    >>> summarize_list(elem.findall("*"))\r
    ['tag', 'tag', 'section']\r
    >>> summarize_list(elem.findall(".//tag"))\r
    ['tag', 'tag', 'tag', 'tag']\r
    >>> summarize_list(elem.findall("section/tag"))\r
    ['tag']\r
    >>> summarize_list(elem.findall("section//tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall("section/*"))\r
    ['tag', 'nexttag', 'nextsection']\r
    >>> summarize_list(elem.findall("section//*"))\r
    ['tag', 'nexttag', 'nextsection', 'tag']\r
    >>> summarize_list(elem.findall("section/.//*"))\r
    ['tag', 'nexttag', 'nextsection', 'tag']\r
    >>> summarize_list(elem.findall("*/*"))\r
    ['tag', 'nexttag', 'nextsection']\r
    >>> summarize_list(elem.findall("*//*"))\r
    ['tag', 'nexttag', 'nextsection', 'tag']\r
    >>> summarize_list(elem.findall("*/tag"))\r
    ['tag']\r
    >>> summarize_list(elem.findall("*/./tag"))\r
    ['tag']\r
    >>> summarize_list(elem.findall("./tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall(".//tag"))\r
    ['tag', 'tag', 'tag', 'tag']\r
    >>> summarize_list(elem.findall("././tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall(".//tag[@class]"))\r
    ['tag', 'tag', 'tag']\r
    >>> summarize_list(elem.findall(".//tag[@class='a']"))\r
    ['tag']\r
    >>> summarize_list(elem.findall(".//tag[@class='b']"))\r
    ['tag', 'tag']\r
    >>> summarize_list(elem.findall(".//tag[@id]"))\r
    ['tag']\r
    >>> summarize_list(elem.findall(".//section[tag]"))\r
    ['section']\r
    >>> summarize_list(elem.findall(".//section[element]"))\r
    []\r
    >>> summarize_list(elem.findall("../tag"))\r
    []\r
    >>> summarize_list(elem.findall("section/../tag"))\r
    ['tag', 'tag']\r
    >>> summarize_list(ET.ElementTree(elem).findall("./tag"))\r
    ['tag', 'tag']\r
\r
    Following example is invalid in 1.2.\r
    A leading '*' is assumed in 1.3.\r
\r
    >>> elem.findall("section//") == elem.findall("section//*")\r
    True\r
\r
    ET's Path module handles this case incorrectly; this gives\r
    a warning in 1.3, and the behaviour will be modified in 1.4.\r
\r
    >>> summarize_list(ET.ElementTree(elem).findall("/tag"))\r
    ['tag', 'tag']\r
\r
    >>> elem = ET.XML(SAMPLE_XML_NS)\r
    >>> summarize_list(elem.findall("tag"))\r
    []\r
    >>> summarize_list(elem.findall("{http://effbot.org/ns}tag"))\r
    ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag']\r
    >>> summarize_list(elem.findall(".//{http://effbot.org/ns}tag"))\r
    ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag']\r
    """\r
\r
def file_init():\r
    """\r
    >>> import StringIO\r
\r
    >>> stringfile = StringIO.StringIO(SAMPLE_XML)\r
    >>> tree = ET.ElementTree(file=stringfile)\r
    >>> tree.find("tag").tag\r
    'tag'\r
    >>> tree.find("section/tag").tag\r
    'tag'\r
\r
    >>> tree = ET.ElementTree(file=SIMPLE_XMLFILE)\r
    >>> tree.find("element").tag\r
    'element'\r
    >>> tree.find("element/../empty-element").tag\r
    'empty-element'\r
    """\r
\r
def bad_find():\r
    """\r
    Check bad or unsupported path expressions.\r
\r
    >>> elem = ET.XML(SAMPLE_XML)\r
    >>> elem.findall("/tag")\r
    Traceback (most recent call last):\r
    SyntaxError: cannot use absolute path on element\r
    """\r
\r
def path_cache():\r
    """\r
    Check that the path cache behaves sanely.\r
\r
    >>> elem = ET.XML(SAMPLE_XML)\r
    >>> for i in range(10): ET.ElementTree(elem).find('./'+str(i))\r
    >>> cache_len_10 = len(ET.ElementPath._cache)\r
    >>> for i in range(10): ET.ElementTree(elem).find('./'+str(i))\r
    >>> len(ET.ElementPath._cache) == cache_len_10\r
    True\r
    >>> for i in range(20): ET.ElementTree(elem).find('./'+str(i))\r
    >>> len(ET.ElementPath._cache) > cache_len_10\r
    True\r
    >>> for i in range(600): ET.ElementTree(elem).find('./'+str(i))\r
    >>> len(ET.ElementPath._cache) < 500\r
    True\r
    """\r
\r
def copy():\r
    """\r
    Test copy handling (etc).\r
\r
    >>> import copy\r
    >>> e1 = ET.XML("<tag>hello<foo/></tag>")\r
    >>> e2 = copy.copy(e1)\r
    >>> e3 = copy.deepcopy(e1)\r
    >>> e1.find("foo").tag = "bar"\r
    >>> serialize(e1)\r
    '<tag>hello<bar /></tag>'\r
    >>> serialize(e2)\r
    '<tag>hello<bar /></tag>'\r
    >>> serialize(e3)\r
    '<tag>hello<foo /></tag>'\r
\r
    """\r
\r
def attrib():\r
    """\r
    Test attribute handling.\r
\r
    >>> elem = ET.Element("tag")\r
    >>> elem.get("key") # 1.1\r
    >>> elem.get("key", "default") # 1.2\r
    'default'\r
    >>> elem.set("key", "value")\r
    >>> elem.get("key") # 1.3\r
    'value'\r
\r
    >>> elem = ET.Element("tag", key="value")\r
    >>> elem.get("key") # 2.1\r
    'value'\r
    >>> elem.attrib # 2.2\r
    {'key': 'value'}\r
\r
    >>> attrib = {"key": "value"}\r
    >>> elem = ET.Element("tag", attrib)\r
    >>> attrib.clear() # check for aliasing issues\r
    >>> elem.get("key") # 3.1\r
    'value'\r
    >>> elem.attrib # 3.2\r
    {'key': 'value'}\r
\r
    >>> attrib = {"key": "value"}\r
    >>> elem = ET.Element("tag", **attrib)\r
    >>> attrib.clear() # check for aliasing issues\r
    >>> elem.get("key") # 4.1\r
    'value'\r
    >>> elem.attrib # 4.2\r
    {'key': 'value'}\r
\r
    >>> elem = ET.Element("tag", {"key": "other"}, key="value")\r
    >>> elem.get("key") # 5.1\r
    'value'\r
    >>> elem.attrib # 5.2\r
    {'key': 'value'}\r
\r
    >>> elem = ET.Element('test')\r
    >>> elem.text = "aa"\r
    >>> elem.set('testa', 'testval')\r
    >>> elem.set('testb', 'test2')\r
    >>> ET.tostring(elem)\r
    '<test testa="testval" testb="test2">aa</test>'\r
    >>> sorted(elem.keys())\r
    ['testa', 'testb']\r
    >>> sorted(elem.items())\r
    [('testa', 'testval'), ('testb', 'test2')]\r
    >>> elem.attrib['testb']\r
    'test2'\r
    >>> elem.attrib['testb'] = 'test1'\r
    >>> elem.attrib['testc'] = 'test2'\r
    >>> ET.tostring(elem)\r
    '<test testa="testval" testb="test1" testc="test2">aa</test>'\r
    """\r
\r
def makeelement():\r
    """\r
    Test makeelement handling.\r
\r
    >>> elem = ET.Element("tag")\r
    >>> attrib = {"key": "value"}\r
    >>> subelem = elem.makeelement("subtag", attrib)\r
    >>> if subelem.attrib is attrib:\r
    ...     print "attrib aliasing"\r
    >>> elem.append(subelem)\r
    >>> serialize(elem)\r
    '<tag><subtag key="value" /></tag>'\r
\r
    >>> elem.clear()\r
    >>> serialize(elem)\r
    '<tag />'\r
    >>> elem.append(subelem)\r
    >>> serialize(elem)\r
    '<tag><subtag key="value" /></tag>'\r
    >>> elem.extend([subelem, subelem])\r
    >>> serialize(elem)\r
    '<tag><subtag key="value" /><subtag key="value" /><subtag key="value" /></tag>'\r
    >>> elem[:] = [subelem]\r
    >>> serialize(elem)\r
    '<tag><subtag key="value" /></tag>'\r
    >>> elem[:] = tuple([subelem])\r
    >>> serialize(elem)\r
    '<tag><subtag key="value" /></tag>'\r
\r
    """\r
\r
def parsefile():\r
    """\r
    Test parsing from file.\r
\r
    >>> tree = ET.parse(SIMPLE_XMLFILE)\r
    >>> normalize_crlf(tree)\r
    >>> tree.write(sys.stdout)\r
    <root>\r
       <element key="value">text</element>\r
       <element>text</element>tail\r
       <empty-element />\r
    </root>\r
    >>> tree = ET.parse(SIMPLE_NS_XMLFILE)\r
    >>> normalize_crlf(tree)\r
    >>> tree.write(sys.stdout)\r
    <ns0:root xmlns:ns0="namespace">\r
       <ns0:element key="value">text</ns0:element>\r
       <ns0:element>text</ns0:element>tail\r
       <ns0:empty-element />\r
    </ns0:root>\r
\r
    >>> with open(SIMPLE_XMLFILE) as f:\r
    ...     data = f.read()\r
\r
    >>> parser = ET.XMLParser()\r
    >>> parser.version  # doctest: +ELLIPSIS\r
    'Expat ...'\r
    >>> parser.feed(data)\r
    >>> print serialize(parser.close())\r
    <root>\r
       <element key="value">text</element>\r
       <element>text</element>tail\r
       <empty-element />\r
    </root>\r
\r
    >>> parser = ET.XMLTreeBuilder() # 1.2 compatibility\r
    >>> parser.feed(data)\r
    >>> print serialize(parser.close())\r
    <root>\r
       <element key="value">text</element>\r
       <element>text</element>tail\r
       <empty-element />\r
    </root>\r
\r
    >>> target = ET.TreeBuilder()\r
    >>> parser = ET.XMLParser(target=target)\r
    >>> parser.feed(data)\r
    >>> print serialize(parser.close())\r
    <root>\r
       <element key="value">text</element>\r
       <element>text</element>tail\r
       <empty-element />\r
    </root>\r
    """\r
\r
def parseliteral():\r
    """\r
    >>> element = ET.XML("<html><body>text</body></html>")\r
    >>> ET.ElementTree(element).write(sys.stdout)\r
    <html><body>text</body></html>\r
    >>> element = ET.fromstring("<html><body>text</body></html>")\r
    >>> ET.ElementTree(element).write(sys.stdout)\r
    <html><body>text</body></html>\r
    >>> sequence = ["<html><body>", "text</bo", "dy></html>"]\r
    >>> element = ET.fromstringlist(sequence)\r
    >>> print ET.tostring(element)\r
    <html><body>text</body></html>\r
    >>> print "".join(ET.tostringlist(element))\r
    <html><body>text</body></html>\r
    >>> ET.tostring(element, "ascii")\r
    "<?xml version='1.0' encoding='ascii'?>\\n<html><body>text</body></html>"\r
    >>> _, ids = ET.XMLID("<html><body>text</body></html>")\r
    >>> len(ids)\r
    0\r
    >>> _, ids = ET.XMLID("<html><body id='body'>text</body></html>")\r
    >>> len(ids)\r
    1\r
    >>> ids["body"].tag\r
    'body'\r
    """\r
\r
def iterparse():\r
    """\r
    Test iterparse interface.\r
\r
    >>> iterparse = ET.iterparse\r
\r
    >>> context = iterparse(SIMPLE_XMLFILE)\r
    >>> action, elem = next(context)\r
    >>> print action, elem.tag\r
    end element\r
    >>> for action, elem in context:\r
    ...   print action, elem.tag\r
    end element\r
    end empty-element\r
    end root\r
    >>> context.root.tag\r
    'root'\r
\r
    >>> context = iterparse(SIMPLE_NS_XMLFILE)\r
    >>> for action, elem in context:\r
    ...   print action, elem.tag\r
    end {namespace}element\r
    end {namespace}element\r
    end {namespace}empty-element\r
    end {namespace}root\r
\r
    >>> events = ()\r
    >>> context = iterparse(SIMPLE_XMLFILE, events)\r
    >>> for action, elem in context:\r
    ...   print action, elem.tag\r
\r
    >>> events = ()\r
    >>> context = iterparse(SIMPLE_XMLFILE, events=events)\r
    >>> for action, elem in context:\r
    ...   print action, elem.tag\r
\r
    >>> events = ("start", "end")\r
    >>> context = iterparse(SIMPLE_XMLFILE, events)\r
    >>> for action, elem in context:\r
    ...   print action, elem.tag\r
    start root\r
    start element\r
    end element\r
    start element\r
    end element\r
    start empty-element\r
    end empty-element\r
    end root\r
\r
    >>> events = ("start", "end", "start-ns", "end-ns")\r
    >>> context = iterparse(SIMPLE_NS_XMLFILE, events)\r
    >>> for action, elem in context:\r
    ...   if action in ("start", "end"):\r
    ...     print action, elem.tag\r
    ...   else:\r
    ...     print action, elem\r
    start-ns ('', 'namespace')\r
    start {namespace}root\r
    start {namespace}element\r
    end {namespace}element\r
    start {namespace}element\r
    end {namespace}element\r
    start {namespace}empty-element\r
    end {namespace}empty-element\r
    end {namespace}root\r
    end-ns None\r
\r
    >>> events = ("start", "end", "bogus")\r
    >>> with open(SIMPLE_XMLFILE, "rb") as f:\r
    ...     iterparse(f, events)\r
    Traceback (most recent call last):\r
    ValueError: unknown event 'bogus'\r
\r
    >>> import StringIO\r
\r
    >>> source = StringIO.StringIO(\r
    ...     "<?xml version='1.0' encoding='iso-8859-1'?>\\n"\r
    ...     "<body xmlns='http://&#233;ffbot.org/ns'\\n"\r
    ...     "      xmlns:cl\\xe9='http://effbot.org/ns'>text</body>\\n")\r
    >>> events = ("start-ns",)\r
    >>> context = iterparse(source, events)\r
    >>> for action, elem in context:\r
    ...     print action, elem\r
    start-ns ('', u'http://\\xe9ffbot.org/ns')\r
    start-ns (u'cl\\xe9', 'http://effbot.org/ns')\r
\r
    >>> source = StringIO.StringIO("<document />junk")\r
    >>> try:\r
    ...   for action, elem in iterparse(source):\r
    ...     print action, elem.tag\r
    ... except ET.ParseError, v:\r
    ...   print v\r
    junk after document element: line 1, column 12\r
    """\r
\r
def writefile():\r
    """\r
    >>> elem = ET.Element("tag")\r
    >>> elem.text = "text"\r
    >>> serialize(elem)\r
    '<tag>text</tag>'\r
    >>> ET.SubElement(elem, "subtag").text = "subtext"\r
    >>> serialize(elem)\r
    '<tag>text<subtag>subtext</subtag></tag>'\r
\r
    Test tag suppression\r
    >>> elem.tag = None\r
    >>> serialize(elem)\r
    'text<subtag>subtext</subtag>'\r
    >>> elem.insert(0, ET.Comment("comment"))\r
    >>> serialize(elem)     # assumes 1.3\r
    'text<!--comment--><subtag>subtext</subtag>'\r
    >>> elem[0] = ET.PI("key", "value")\r
    >>> serialize(elem)\r
    'text<?key value?><subtag>subtext</subtag>'\r
    """\r
\r
def custom_builder():\r
    """\r
    Test parser w. custom builder.\r
\r
    >>> with open(SIMPLE_XMLFILE) as f:\r
    ...     data = f.read()\r
    >>> class Builder:\r
    ...     def start(self, tag, attrib):\r
    ...         print "start", tag\r
    ...     def end(self, tag):\r
    ...         print "end", tag\r
    ...     def data(self, text):\r
    ...         pass\r
    >>> builder = Builder()\r
    >>> parser = ET.XMLParser(target=builder)\r
    >>> parser.feed(data)\r
    start root\r
    start element\r
    end element\r
    start element\r
    end element\r
    start empty-element\r
    end empty-element\r
    end root\r
\r
    >>> with open(SIMPLE_NS_XMLFILE) as f:\r
    ...     data = f.read()\r
    >>> class Builder:\r
    ...     def start(self, tag, attrib):\r
    ...         print "start", tag\r
    ...     def end(self, tag):\r
    ...         print "end", tag\r
    ...     def data(self, text):\r
    ...         pass\r
    ...     def pi(self, target, data):\r
    ...         print "pi", target, repr(data)\r
    ...     def comment(self, data):\r
    ...         print "comment", repr(data)\r
    >>> builder = Builder()\r
    >>> parser = ET.XMLParser(target=builder)\r
    >>> parser.feed(data)\r
    pi pi 'data'\r
    comment ' comment '\r
    start {namespace}root\r
    start {namespace}element\r
    end {namespace}element\r
    start {namespace}element\r
    end {namespace}element\r
    start {namespace}empty-element\r
    end {namespace}empty-element\r
    end {namespace}root\r
\r
    """\r
\r
def getchildren():\r
    """\r
    Test Element.getchildren()\r
\r
    >>> with open(SIMPLE_XMLFILE, "r") as f:\r
    ...     tree = ET.parse(f)\r
    >>> for elem in tree.getroot().iter():\r
    ...     summarize_list(elem.getchildren())\r
    ['element', 'element', 'empty-element']\r
    []\r
    []\r
    []\r
    >>> for elem in tree.getiterator():\r
    ...     summarize_list(elem.getchildren())\r
    ['element', 'element', 'empty-element']\r
    []\r
    []\r
    []\r
\r
    >>> elem = ET.XML(SAMPLE_XML)\r
    >>> len(elem.getchildren())\r
    3\r
    >>> len(elem[2].getchildren())\r
    1\r
    >>> elem[:] == elem.getchildren()\r
    True\r
    >>> child1 = elem[0]\r
    >>> child2 = elem[2]\r
    >>> del elem[1:2]\r
    >>> len(elem.getchildren())\r
    2\r
    >>> child1 == elem[0]\r
    True\r
    >>> child2 == elem[1]\r
    True\r
    >>> elem[0:2] = [child2, child1]\r
    >>> child2 == elem[0]\r
    True\r
    >>> child1 == elem[1]\r
    True\r
    >>> child1 == elem[0]\r
    False\r
    >>> elem.clear()\r
    >>> elem.getchildren()\r
    []\r
    """\r
\r
def writestring():\r
    """\r
    >>> elem = ET.XML("<html><body>text</body></html>")\r
    >>> ET.tostring(elem)\r
    '<html><body>text</body></html>'\r
    >>> elem = ET.fromstring("<html><body>text</body></html>")\r
    >>> ET.tostring(elem)\r
    '<html><body>text</body></html>'\r
    """\r
\r
def check_encoding(encoding):\r
    """\r
    >>> check_encoding("ascii")\r
    >>> check_encoding("us-ascii")\r
    >>> check_encoding("iso-8859-1")\r
    >>> check_encoding("iso-8859-15")\r
    >>> check_encoding("cp437")\r
    >>> check_encoding("mac-roman")\r
    """\r
    ET.XML("<?xml version='1.0' encoding='%s'?><xml />" % encoding)\r
\r
def encoding():\r
    r"""\r
    Test encoding issues.\r
\r
    >>> elem = ET.Element("tag")\r
    >>> elem.text = u"abc"\r
    >>> serialize(elem)\r
    '<tag>abc</tag>'\r
    >>> serialize(elem, encoding="utf-8")\r
    '<tag>abc</tag>'\r
    >>> serialize(elem, encoding="us-ascii")\r
    '<tag>abc</tag>'\r
    >>> serialize(elem, encoding="iso-8859-1")\r
    "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>"\r
\r
    >>> elem.text = "<&\"\'>"\r
    >>> serialize(elem)\r
    '<tag>&lt;&amp;"\'&gt;</tag>'\r
    >>> serialize(elem, encoding="utf-8")\r
    '<tag>&lt;&amp;"\'&gt;</tag>'\r
    >>> serialize(elem, encoding="us-ascii") # cdata characters\r
    '<tag>&lt;&amp;"\'&gt;</tag>'\r
    >>> serialize(elem, encoding="iso-8859-1")\r
    '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag>&lt;&amp;"\'&gt;</tag>'\r
\r
    >>> elem.attrib["key"] = "<&\"\'>"\r
    >>> elem.text = None\r
    >>> serialize(elem)\r
    '<tag key="&lt;&amp;&quot;\'&gt;" />'\r
    >>> serialize(elem, encoding="utf-8")\r
    '<tag key="&lt;&amp;&quot;\'&gt;" />'\r
    >>> serialize(elem, encoding="us-ascii")\r
    '<tag key="&lt;&amp;&quot;\'&gt;" />'\r
    >>> serialize(elem, encoding="iso-8859-1")\r
    '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="&lt;&amp;&quot;\'&gt;" />'\r
\r
    >>> elem.text = u'\xe5\xf6\xf6<>'\r
    >>> elem.attrib.clear()\r
    >>> serialize(elem)\r
    '<tag>&#229;&#246;&#246;&lt;&gt;</tag>'\r
    >>> serialize(elem, encoding="utf-8")\r
    '<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>'\r
    >>> serialize(elem, encoding="us-ascii")\r
    '<tag>&#229;&#246;&#246;&lt;&gt;</tag>'\r
    >>> serialize(elem, encoding="iso-8859-1")\r
    "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6&lt;&gt;</tag>"\r
\r
    >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>'\r
    >>> elem.text = None\r
    >>> serialize(elem)\r
    '<tag key="&#229;&#246;&#246;&lt;&gt;" />'\r
    >>> serialize(elem, encoding="utf-8")\r
    '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;" />'\r
    >>> serialize(elem, encoding="us-ascii")\r
    '<tag key="&#229;&#246;&#246;&lt;&gt;" />'\r
    >>> serialize(elem, encoding="iso-8859-1")\r
    '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6&lt;&gt;" />'\r
    """\r
\r
def methods():\r
    r"""\r
    Test serialization methods.\r
\r
    >>> e = ET.XML("<html><link/><script>1 &lt; 2</script></html>")\r
    >>> e.tail = "\n"\r
    >>> serialize(e)\r
    '<html><link /><script>1 &lt; 2</script></html>\n'\r
    >>> serialize(e, method=None)\r
    '<html><link /><script>1 &lt; 2</script></html>\n'\r
    >>> serialize(e, method="xml")\r
    '<html><link /><script>1 &lt; 2</script></html>\n'\r
    >>> serialize(e, method="html")\r
    '<html><link><script>1 < 2</script></html>\n'\r
    >>> serialize(e, method="text")\r
    '1 < 2\n'\r
    """\r
\r
def iterators():\r
    """\r
    Test iterators.\r
\r
    >>> e = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")\r
    >>> summarize_list(e.iter())\r
    ['html', 'body', 'i']\r
    >>> summarize_list(e.find("body").iter())\r
    ['body', 'i']\r
    >>> summarize(next(e.iter()))\r
    'html'\r
    >>> "".join(e.itertext())\r
    'this is a paragraph...'\r
    >>> "".join(e.find("body").itertext())\r
    'this is a paragraph.'\r
    >>> next(e.itertext())\r
    'this is a '\r
\r
    Method iterparse should return an iterator. See bug 6472.\r
\r
    >>> sourcefile = serialize(e, to_string=False)\r
    >>> next(ET.iterparse(sourcefile))  # doctest: +ELLIPSIS\r
    ('end', <Element 'i' at 0x...>)\r
\r
    >>> tree = ET.ElementTree(None)\r
    >>> tree.iter()\r
    Traceback (most recent call last):\r
    AttributeError: 'NoneType' object has no attribute 'iter'\r
    """\r
\r
ENTITY_XML = """\\r
<!DOCTYPE points [\r
<!ENTITY % user-entities SYSTEM 'user-entities.xml'>\r
%user-entities;\r
]>\r
<document>&entity;</document>\r
"""\r
\r
def entity():\r
    """\r
    Test entity handling.\r
\r
    1) good entities\r
\r
    >>> e = ET.XML("<document title='&#x8230;'>test</document>")\r
    >>> serialize(e)\r
    '<document title="&#33328;">test</document>'\r
\r
    2) bad entities\r
\r
    >>> ET.XML("<document>&entity;</document>")\r
    Traceback (most recent call last):\r
    ParseError: undefined entity: line 1, column 10\r
\r
    >>> ET.XML(ENTITY_XML)\r
    Traceback (most recent call last):\r
    ParseError: undefined entity &entity;: line 5, column 10\r
\r
    3) custom entity\r
\r
    >>> parser = ET.XMLParser()\r
    >>> parser.entity["entity"] = "text"\r
    >>> parser.feed(ENTITY_XML)\r
    >>> root = parser.close()\r
    >>> serialize(root)\r
    '<document>text</document>'\r
    """\r
\r
def error(xml):\r
    """\r
\r
    Test error handling.\r
\r
    >>> issubclass(ET.ParseError, SyntaxError)\r
    True\r
    >>> error("foo").position\r
    (1, 0)\r
    >>> error("<tag>&foo;</tag>").position\r
    (1, 5)\r
    >>> error("foobar<").position\r
    (1, 6)\r
\r
    """\r
    try:\r
        ET.XML(xml)\r
    except ET.ParseError:\r
        return sys.exc_value\r
\r
def namespace():\r
    """\r
    Test namespace issues.\r
\r
    1) xml namespace\r
\r
    >>> elem = ET.XML("<tag xml:lang='en' />")\r
    >>> serialize(elem) # 1.1\r
    '<tag xml:lang="en" />'\r
\r
    2) other "well-known" namespaces\r
\r
    >>> elem = ET.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")\r
    >>> serialize(elem) # 2.1\r
    '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" />'\r
\r
    >>> elem = ET.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")\r
    >>> serialize(elem) # 2.2\r
    '<html:html xmlns:html="http://www.w3.org/1999/xhtml" />'\r
\r
    >>> elem = ET.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")\r
    >>> serialize(elem) # 2.3\r
    '<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope" />'\r
\r
    3) unknown namespaces\r
    >>> elem = ET.XML(SAMPLE_XML_NS)\r
    >>> print serialize(elem)\r
    <ns0:body xmlns:ns0="http://effbot.org/ns">\r
      <ns0:tag>text</ns0:tag>\r
      <ns0:tag />\r
      <ns0:section>\r
        <ns0:tag>subtext</ns0:tag>\r
      </ns0:section>\r
    </ns0:body>\r
    """\r
\r
def qname():\r
    """\r
    Test QName handling.\r
\r
    1) decorated tags\r
\r
    >>> elem = ET.Element("{uri}tag")\r
    >>> serialize(elem) # 1.1\r
    '<ns0:tag xmlns:ns0="uri" />'\r
    >>> elem = ET.Element(ET.QName("{uri}tag"))\r
    >>> serialize(elem) # 1.2\r
    '<ns0:tag xmlns:ns0="uri" />'\r
    >>> elem = ET.Element(ET.QName("uri", "tag"))\r
    >>> serialize(elem) # 1.3\r
    '<ns0:tag xmlns:ns0="uri" />'\r
    >>> elem = ET.Element(ET.QName("uri", "tag"))\r
    >>> subelem = ET.SubElement(elem, ET.QName("uri", "tag1"))\r
    >>> subelem = ET.SubElement(elem, ET.QName("uri", "tag2"))\r
    >>> serialize(elem) # 1.4\r
    '<ns0:tag xmlns:ns0="uri"><ns0:tag1 /><ns0:tag2 /></ns0:tag>'\r
\r
    2) decorated attributes\r
\r
    >>> elem.clear()\r
    >>> elem.attrib["{uri}key"] = "value"\r
    >>> serialize(elem) # 2.1\r
    '<ns0:tag xmlns:ns0="uri" ns0:key="value" />'\r
\r
    >>> elem.clear()\r
    >>> elem.attrib[ET.QName("{uri}key")] = "value"\r
    >>> serialize(elem) # 2.2\r
    '<ns0:tag xmlns:ns0="uri" ns0:key="value" />'\r
\r
    3) decorated values are not converted by default, but the\r
       QName wrapper can be used for values\r
\r
    >>> elem.clear()\r
    >>> elem.attrib["{uri}key"] = "{uri}value"\r
    >>> serialize(elem) # 3.1\r
    '<ns0:tag xmlns:ns0="uri" ns0:key="{uri}value" />'\r
\r
    >>> elem.clear()\r
    >>> elem.attrib["{uri}key"] = ET.QName("{uri}value")\r
    >>> serialize(elem) # 3.2\r
    '<ns0:tag xmlns:ns0="uri" ns0:key="ns0:value" />'\r
\r
    >>> elem.clear()\r
    >>> subelem = ET.Element("tag")\r
    >>> subelem.attrib["{uri1}key"] = ET.QName("{uri2}value")\r
    >>> elem.append(subelem)\r
    >>> elem.append(subelem)\r
    >>> serialize(elem) # 3.3\r
    '<ns0:tag xmlns:ns0="uri" xmlns:ns1="uri1" xmlns:ns2="uri2"><tag ns1:key="ns2:value" /><tag ns1:key="ns2:value" /></ns0:tag>'\r
\r
    4) Direct QName tests\r
\r
    >>> str(ET.QName('ns', 'tag'))\r
    '{ns}tag'\r
    >>> str(ET.QName('{ns}tag'))\r
    '{ns}tag'\r
    >>> q1 = ET.QName('ns', 'tag')\r
    >>> q2 = ET.QName('ns', 'tag')\r
    >>> q1 == q2\r
    True\r
    >>> q2 = ET.QName('ns', 'other-tag')\r
    >>> q1 == q2\r
    False\r
    >>> q1 == 'ns:tag'\r
    False\r
    >>> q1 == '{ns}tag'\r
    True\r
    """\r
\r
def doctype_public():\r
    """\r
    Test PUBLIC doctype.\r
\r
    >>> elem = ET.XML('<!DOCTYPE html PUBLIC'\r
    ...   ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'\r
    ...   ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'\r
    ...   '<html>text</html>')\r
\r
    """\r
\r
def xpath_tokenizer(p):\r
    """\r
    Test the XPath tokenizer.\r
\r
    >>> # tests from the xml specification\r
    >>> xpath_tokenizer("*")\r
    ['*']\r
    >>> xpath_tokenizer("text()")\r
    ['text', '()']\r
    >>> xpath_tokenizer("@name")\r
    ['@', 'name']\r
    >>> xpath_tokenizer("@*")\r
    ['@', '*']\r
    >>> xpath_tokenizer("para[1]")\r
    ['para', '[', '1', ']']\r
    >>> xpath_tokenizer("para[last()]")\r
    ['para', '[', 'last', '()', ']']\r
    >>> xpath_tokenizer("*/para")\r
    ['*', '/', 'para']\r
    >>> xpath_tokenizer("/doc/chapter[5]/section[2]")\r
    ['/', 'doc', '/', 'chapter', '[', '5', ']', '/', 'section', '[', '2', ']']\r
    >>> xpath_tokenizer("chapter//para")\r
    ['chapter', '//', 'para']\r
    >>> xpath_tokenizer("//para")\r
    ['//', 'para']\r
    >>> xpath_tokenizer("//olist/item")\r
    ['//', 'olist', '/', 'item']\r
    >>> xpath_tokenizer(".")\r
    ['.']\r
    >>> xpath_tokenizer(".//para")\r
    ['.', '//', 'para']\r
    >>> xpath_tokenizer("..")\r
    ['..']\r
    >>> xpath_tokenizer("../@lang")\r
    ['..', '/', '@', 'lang']\r
    >>> xpath_tokenizer("chapter[title]")\r
    ['chapter', '[', 'title', ']']\r
    >>> xpath_tokenizer("employee[@secretary and @assistant]")\r
    ['employee', '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']']\r
\r
    >>> # additional tests\r
    >>> xpath_tokenizer("{http://spam}egg")\r
    ['{http://spam}egg']\r
    >>> xpath_tokenizer("./spam.egg")\r
    ['.', '/', 'spam.egg']\r
    >>> xpath_tokenizer(".//{http://spam}egg")\r
    ['.', '//', '{http://spam}egg']\r
    """\r
    from xml.etree import ElementPath\r
    out = []\r
    for op, tag in ElementPath.xpath_tokenizer(p):\r
        out.append(op or tag)\r
    return out\r
\r
def processinginstruction():\r
    """\r
    Test ProcessingInstruction directly\r
\r
    >>> ET.tostring(ET.ProcessingInstruction('test', 'instruction'))\r
    '<?test instruction?>'\r
    >>> ET.tostring(ET.PI('test', 'instruction'))\r
    '<?test instruction?>'\r
\r
    Issue #2746\r
\r
    >>> ET.tostring(ET.PI('test', '<testing&>'))\r
    '<?test <testing&>?>'\r
    >>> ET.tostring(ET.PI('test', u'<testing&>\xe3'), 'latin1')\r
    "<?xml version='1.0' encoding='latin1'?>\\n<?test <testing&>\\xe3?>"\r
    """\r
\r
#\r
# xinclude tests (samples from appendix C of the xinclude specification)\r
\r
XINCLUDE = {}\r
\r
XINCLUDE["C1.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>120 Mz is adequate for an average home user.</p>\r
  <xi:include href="disclaimer.xml"/>\r
</document>\r
"""\r
\r
XINCLUDE["disclaimer.xml"] = """\\r
<?xml version='1.0'?>\r
<disclaimer>\r
  <p>The opinions represented herein represent those of the individual\r
  and should not be interpreted as official policy endorsed by this\r
  organization.</p>\r
</disclaimer>\r
"""\r
\r
XINCLUDE["C2.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>This document has been accessed\r
  <xi:include href="count.txt" parse="text"/> times.</p>\r
</document>\r
"""\r
\r
XINCLUDE["count.txt"] = "324387"\r
\r
XINCLUDE["C2b.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>This document has been <em>accessed</em>\r
  <xi:include href="count.txt" parse="text"/> times.</p>\r
</document>\r
"""\r
\r
XINCLUDE["C3.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>The following is the source of the "data.xml" resource:</p>\r
  <example><xi:include href="data.xml" parse="text"/></example>\r
</document>\r
"""\r
\r
XINCLUDE["data.xml"] = """\\r
<?xml version='1.0'?>\r
<data>\r
  <item><![CDATA[Brooks & Shields]]></item>\r
</data>\r
"""\r
\r
XINCLUDE["C5.xml"] = """\\r
<?xml version='1.0'?>\r
<div xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <xi:include href="example.txt" parse="text">\r
    <xi:fallback>\r
      <xi:include href="fallback-example.txt" parse="text">\r
        <xi:fallback><a href="mailto:bob@example.org">Report error</a></xi:fallback>\r
      </xi:include>\r
    </xi:fallback>\r
  </xi:include>\r
</div>\r
"""\r
\r
XINCLUDE["default.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>Example.</p>\r
  <xi:include href="{}"/>\r
</document>\r
""".format(cgi.escape(SIMPLE_XMLFILE, True))\r
\r
def xinclude_loader(href, parse="xml", encoding=None):\r
    try:\r
        data = XINCLUDE[href]\r
    except KeyError:\r
        raise IOError("resource not found")\r
    if parse == "xml":\r
        from xml.etree.ElementTree import XML\r
        return XML(data)\r
    return data\r
\r
def xinclude():\r
    r"""\r
    Basic inclusion example (XInclude C.1)\r
\r
    >>> from xml.etree import ElementTree as ET\r
    >>> from xml.etree import ElementInclude\r
\r
    >>> document = xinclude_loader("C1.xml")\r
    >>> ElementInclude.include(document, xinclude_loader)\r
    >>> print serialize(document) # C1\r
    <document>\r
      <p>120 Mz is adequate for an average home user.</p>\r
      <disclaimer>\r
      <p>The opinions represented herein represent those of the individual\r
      and should not be interpreted as official policy endorsed by this\r
      organization.</p>\r
    </disclaimer>\r
    </document>\r
\r
    Textual inclusion example (XInclude C.2)\r
\r
    >>> document = xinclude_loader("C2.xml")\r
    >>> ElementInclude.include(document, xinclude_loader)\r
    >>> print serialize(document) # C2\r
    <document>\r
      <p>This document has been accessed\r
      324387 times.</p>\r
    </document>\r
\r
    Textual inclusion after sibling element (based on modified XInclude C.2)\r
\r
    >>> document = xinclude_loader("C2b.xml")\r
    >>> ElementInclude.include(document, xinclude_loader)\r
    >>> print(serialize(document)) # C2b\r
    <document>\r
      <p>This document has been <em>accessed</em>\r
      324387 times.</p>\r
    </document>\r
\r
    Textual inclusion of XML example (XInclude C.3)\r
\r
    >>> document = xinclude_loader("C3.xml")\r
    >>> ElementInclude.include(document, xinclude_loader)\r
    >>> print serialize(document) # C3\r
    <document>\r
      <p>The following is the source of the "data.xml" resource:</p>\r
      <example>&lt;?xml version='1.0'?&gt;\r
    &lt;data&gt;\r
      &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt;\r
    &lt;/data&gt;\r
    </example>\r
    </document>\r
\r
    Fallback example (XInclude C.5)\r
    Note! Fallback support is not yet implemented\r
\r
    >>> document = xinclude_loader("C5.xml")\r
    >>> ElementInclude.include(document, xinclude_loader)\r
    Traceback (most recent call last):\r
    IOError: resource not found\r
    >>> # print serialize(document) # C5\r
    """\r
\r
def xinclude_default():\r
    """\r
    >>> from xml.etree import ElementInclude\r
\r
    >>> document = xinclude_loader("default.xml")\r
    >>> ElementInclude.include(document)\r
    >>> print serialize(document) # default\r
    <document>\r
      <p>Example.</p>\r
      <root>\r
       <element key="value">text</element>\r
       <element>text</element>tail\r
       <empty-element />\r
    </root>\r
    </document>\r
    """\r
\r
#\r
# badly formatted xi:include tags\r
\r
XINCLUDE_BAD = {}\r
\r
XINCLUDE_BAD["B1.xml"] = """\\r
<?xml version='1.0'?>\r
<document xmlns:xi="http://www.w3.org/2001/XInclude">\r
  <p>120 Mz is adequate for an average home user.</p>\r
  <xi:include href="disclaimer.xml" parse="BAD_TYPE"/>\r
</document>\r
"""\r
\r
XINCLUDE_BAD["B2.xml"] = """\\r
<?xml version='1.0'?>\r
<div xmlns:xi="http://www.w3.org/2001/XInclude">\r
    <xi:fallback></xi:fallback>\r
</div>\r
"""\r
\r
def xinclude_failures():\r
    r"""\r
    Test failure to locate included XML file.\r
\r
    >>> from xml.etree import ElementInclude\r
\r
    >>> def none_loader(href, parser, encoding=None):\r
    ...     return None\r
\r
    >>> document = ET.XML(XINCLUDE["C1.xml"])\r
    >>> ElementInclude.include(document, loader=none_loader)\r
    Traceback (most recent call last):\r
    FatalIncludeError: cannot load 'disclaimer.xml' as 'xml'\r
\r
    Test failure to locate included text file.\r
\r
    >>> document = ET.XML(XINCLUDE["C2.xml"])\r
    >>> ElementInclude.include(document, loader=none_loader)\r
    Traceback (most recent call last):\r
    FatalIncludeError: cannot load 'count.txt' as 'text'\r
\r
    Test bad parse type.\r
\r
    >>> document = ET.XML(XINCLUDE_BAD["B1.xml"])\r
    >>> ElementInclude.include(document, loader=none_loader)\r
    Traceback (most recent call last):\r
    FatalIncludeError: unknown parse type in xi:include tag ('BAD_TYPE')\r
\r
    Test xi:fallback outside xi:include.\r
\r
    >>> document = ET.XML(XINCLUDE_BAD["B2.xml"])\r
    >>> ElementInclude.include(document, loader=none_loader)\r
    Traceback (most recent call last):\r
    FatalIncludeError: xi:fallback tag must be child of xi:include ('{http://www.w3.org/2001/XInclude}fallback')\r
    """\r
\r
# --------------------------------------------------------------------\r
# reported bugs\r
\r
def bug_xmltoolkit21():\r
    """\r
\r
    marshaller gives obscure errors for non-string values\r
\r
    >>> elem = ET.Element(123)\r
    >>> serialize(elem) # tag\r
    Traceback (most recent call last):\r
    TypeError: cannot serialize 123 (type int)\r
    >>> elem = ET.Element("elem")\r
    >>> elem.text = 123\r
    >>> serialize(elem) # text\r
    Traceback (most recent call last):\r
    TypeError: cannot serialize 123 (type int)\r
    >>> elem = ET.Element("elem")\r
    >>> elem.tail = 123\r
    >>> serialize(elem) # tail\r
    Traceback (most recent call last):\r
    TypeError: cannot serialize 123 (type int)\r
    >>> elem = ET.Element("elem")\r
    >>> elem.set(123, "123")\r
    >>> serialize(elem) # attribute key\r
    Traceback (most recent call last):\r
    TypeError: cannot serialize 123 (type int)\r
    >>> elem = ET.Element("elem")\r
    >>> elem.set("123", 123)\r
    >>> serialize(elem) # attribute value\r
    Traceback (most recent call last):\r
    TypeError: cannot serialize 123 (type int)\r
\r
    """\r
\r
def bug_xmltoolkit25():\r
    """\r
\r
    typo in ElementTree.findtext\r
\r
    >>> elem = ET.XML(SAMPLE_XML)\r
    >>> tree = ET.ElementTree(elem)\r
    >>> tree.findtext("tag")\r
    'text'\r
    >>> tree.findtext("section/tag")\r
    'subtext'\r
\r
    """\r
\r
def bug_xmltoolkit28():\r
    """\r
\r
    .//tag causes exceptions\r
\r
    >>> tree = ET.XML("<doc><table><tbody/></table></doc>")\r
    >>> summarize_list(tree.findall(".//thead"))\r
    []\r
    >>> summarize_list(tree.findall(".//tbody"))\r
    ['tbody']\r
\r
    """\r
\r
def bug_xmltoolkitX1():\r
    """\r
\r
    dump() doesn't flush the output buffer\r
\r
    >>> tree = ET.XML("<doc><table><tbody/></table></doc>")\r
    >>> ET.dump(tree); sys.stdout.write("tail")\r
    <doc><table><tbody /></table></doc>\r
    tail\r
\r
    """\r
\r
def bug_xmltoolkit39():\r
    """\r
\r
    non-ascii element and attribute names doesn't work\r
\r
    >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g />")\r
    >>> ET.tostring(tree, "utf-8")\r
    '<t\\xc3\\xa4g />'\r
\r
    >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><tag \xe4ttr='v&#228;lue' />")\r
    >>> tree.attrib\r
    {u'\\xe4ttr': u'v\\xe4lue'}\r
    >>> ET.tostring(tree, "utf-8")\r
    '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'\r
\r
    >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g>text</t\xe4g>")\r
    >>> ET.tostring(tree, "utf-8")\r
    '<t\\xc3\\xa4g>text</t\\xc3\\xa4g>'\r
\r
    >>> tree = ET.Element(u"t\u00e4g")\r
    >>> ET.tostring(tree, "utf-8")\r
    '<t\\xc3\\xa4g />'\r
\r
    >>> tree = ET.Element("tag")\r
    >>> tree.set(u"\u00e4ttr", u"v\u00e4lue")\r
    >>> ET.tostring(tree, "utf-8")\r
    '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'\r
\r
    """\r
\r
def bug_xmltoolkit54():\r
    """\r
\r
    problems handling internally defined entities\r
\r
    >>> e = ET.XML("<!DOCTYPE doc [<!ENTITY ldots '&#x8230;'>]><doc>&ldots;</doc>")\r
    >>> serialize(e)\r
    '<doc>&#33328;</doc>'\r
\r
    """\r
\r
def bug_xmltoolkit55():\r
    """\r
\r
    make sure we're reporting the first error, not the last\r
\r
    >>> e = ET.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'><doc>&ldots;&ndots;&rdots;</doc>")\r
    Traceback (most recent call last):\r
    ParseError: undefined entity &ldots;: line 1, column 36\r
\r
    """\r
\r
class ExceptionFile:\r
    def read(self, x):\r
        raise IOError\r
\r
def xmltoolkit60():\r
    """\r
\r
    Handle crash in stream source.\r
    >>> tree = ET.parse(ExceptionFile())\r
    Traceback (most recent call last):\r
    IOError\r
\r
    """\r
\r
XMLTOOLKIT62_DOC = """<?xml version="1.0" encoding="UTF-8"?>\r
<!DOCTYPE patent-application-publication SYSTEM "pap-v15-2001-01-31.dtd" []>\r
<patent-application-publication>\r
<subdoc-abstract>\r
<paragraph id="A-0001" lvl="0">A new cultivar of Begonia plant named &lsquo;BCT9801BEG&rsquo;.</paragraph>\r
</subdoc-abstract>\r
</patent-application-publication>"""\r
\r
\r
def xmltoolkit62():\r
    """\r
\r
    Don't crash when using custom entities.\r
\r
    >>> xmltoolkit62()\r
    u'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.'\r
\r
    """\r
    ENTITIES = {u'rsquo': u'\u2019', u'lsquo': u'\u2018'}\r
    parser = ET.XMLTreeBuilder()\r
    parser.entity.update(ENTITIES)\r
    parser.feed(XMLTOOLKIT62_DOC)\r
    t = parser.close()\r
    return t.find('.//paragraph').text\r
\r
def xmltoolkit63():\r
    """\r
\r
    Check reference leak.\r
    >>> xmltoolkit63()\r
    >>> count = sys.getrefcount(None)\r
    >>> for i in range(1000):\r
    ...     xmltoolkit63()\r
    >>> sys.getrefcount(None) - count\r
    0\r
\r
    """\r
    tree = ET.TreeBuilder()\r
    tree.start("tag", {})\r
    tree.data("text")\r
    tree.end("tag")\r
\r
# --------------------------------------------------------------------\r
\r
\r
def bug_200708_newline():\r
    r"""\r
\r
    Preserve newlines in attributes.\r
\r
    >>> e = ET.Element('SomeTag', text="def _f():\n  return 3\n")\r
    >>> ET.tostring(e)\r
    '<SomeTag text="def _f():&#10;  return 3&#10;" />'\r
    >>> ET.XML(ET.tostring(e)).get("text")\r
    'def _f():\n  return 3\n'\r
    >>> ET.tostring(ET.XML(ET.tostring(e)))\r
    '<SomeTag text="def _f():&#10;  return 3&#10;" />'\r
\r
    """\r
\r
def bug_200708_close():\r
    """\r
\r
    Test default builder.\r
    >>> parser = ET.XMLParser() # default\r
    >>> parser.feed("<element>some text</element>")\r
    >>> summarize(parser.close())\r
    'element'\r
\r
    Test custom builder.\r
    >>> class EchoTarget:\r
    ...     def close(self):\r
    ...         return ET.Element("element") # simulate root\r
    >>> parser = ET.XMLParser(EchoTarget())\r
    >>> parser.feed("<element>some text</element>")\r
    >>> summarize(parser.close())\r
    'element'\r
\r
    """\r
\r
def bug_200709_default_namespace():\r
    """\r
\r
    >>> e = ET.Element("{default}elem")\r
    >>> s = ET.SubElement(e, "{default}elem")\r
    >>> serialize(e, default_namespace="default") # 1\r
    '<elem xmlns="default"><elem /></elem>'\r
\r
    >>> e = ET.Element("{default}elem")\r
    >>> s = ET.SubElement(e, "{default}elem")\r
    >>> s = ET.SubElement(e, "{not-default}elem")\r
    >>> serialize(e, default_namespace="default") # 2\r
    '<elem xmlns="default" xmlns:ns1="not-default"><elem /><ns1:elem /></elem>'\r
\r
    >>> e = ET.Element("{default}elem")\r
    >>> s = ET.SubElement(e, "{default}elem")\r
    >>> s = ET.SubElement(e, "elem") # unprefixed name\r
    >>> serialize(e, default_namespace="default") # 3\r
    Traceback (most recent call last):\r
    ValueError: cannot use non-qualified names with default_namespace option\r
\r
    """\r
\r
def bug_200709_register_namespace():\r
    """\r
\r
    >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))\r
    '<ns0:title xmlns:ns0="http://namespace.invalid/does/not/exist/" />'\r
    >>> ET.register_namespace("foo", "http://namespace.invalid/does/not/exist/")\r
    >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))\r
    '<foo:title xmlns:foo="http://namespace.invalid/does/not/exist/" />'\r
\r
    And the Dublin Core namespace is in the default list:\r
\r
    >>> ET.tostring(ET.Element("{http://purl.org/dc/elements/1.1/}title"))\r
    '<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/" />'\r
\r
    """\r
\r
def bug_200709_element_comment():\r
    """\r
\r
    Not sure if this can be fixed, really (since the serializer needs\r
    ET.Comment, not cET.comment).\r
\r
    >>> a = ET.Element('a')\r
    >>> a.append(ET.Comment('foo'))\r
    >>> a[0].tag == ET.Comment\r
    True\r
\r
    >>> a = ET.Element('a')\r
    >>> a.append(ET.PI('foo'))\r
    >>> a[0].tag == ET.PI\r
    True\r
\r
    """\r
\r
def bug_200709_element_insert():\r
    """\r
\r
    >>> a = ET.Element('a')\r
    >>> b = ET.SubElement(a, 'b')\r
    >>> c = ET.SubElement(a, 'c')\r
    >>> d = ET.Element('d')\r
    >>> a.insert(0, d)\r
    >>> summarize_list(a)\r
    ['d', 'b', 'c']\r
    >>> a.insert(-1, d)\r
    >>> summarize_list(a)\r
    ['d', 'b', 'd', 'c']\r
\r
    """\r
\r
def bug_200709_iter_comment():\r
    """\r
\r
    >>> a = ET.Element('a')\r
    >>> b = ET.SubElement(a, 'b')\r
    >>> comment_b = ET.Comment("TEST-b")\r
    >>> b.append(comment_b)\r
    >>> summarize_list(a.iter(ET.Comment))\r
    ['<Comment>']\r
\r
    """\r
\r
# --------------------------------------------------------------------\r
# reported on bugs.python.org\r
\r
def bug_1534630():\r
    """\r
\r
    >>> bob = ET.TreeBuilder()\r
    >>> e = bob.data("data")\r
    >>> e = bob.start("tag", {})\r
    >>> e = bob.end("tag")\r
    >>> e = bob.close()\r
    >>> serialize(e)\r
    '<tag />'\r
\r
    """\r
\r
def check_issue6233():\r
    """\r
\r
    >>> e = ET.XML("<?xml version='1.0' encoding='utf-8'?><body>t\\xc3\\xa3g</body>")\r
    >>> ET.tostring(e, 'ascii')\r
    "<?xml version='1.0' encoding='ascii'?>\\n<body>t&#227;g</body>"\r
    >>> e = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><body>t\\xe3g</body>")\r
    >>> ET.tostring(e, 'ascii')\r
    "<?xml version='1.0' encoding='ascii'?>\\n<body>t&#227;g</body>"\r
\r
    """\r
\r
def check_issue3151():\r
    """\r
\r
    >>> e = ET.XML('<prefix:localname xmlns:prefix="${stuff}"/>')\r
    >>> e.tag\r
    '{${stuff}}localname'\r
    >>> t = ET.ElementTree(e)\r
    >>> ET.tostring(e)\r
    '<ns0:localname xmlns:ns0="${stuff}" />'\r
\r
    """\r
\r
def check_issue6565():\r
    """\r
\r
    >>> elem = ET.XML("<body><tag/></body>")\r
    >>> summarize_list(elem)\r
    ['tag']\r
    >>> newelem = ET.XML(SAMPLE_XML)\r
    >>> elem[:] = newelem[:]\r
    >>> summarize_list(elem)\r
    ['tag', 'tag', 'section']\r
\r
    """\r
\r
# --------------------------------------------------------------------\r
\r
\r
class CleanContext(object):\r
    """Provide default namespace mapping and path cache."""\r
    checkwarnings = None\r
\r
    def __init__(self, quiet=False):\r
        if sys.flags.optimize >= 2:\r
            # under -OO, doctests cannot be run and therefore not all warnings\r
            # will be emitted\r
            quiet = True\r
        deprecations = (\r
            # Search behaviour is broken if search path starts with "/".\r
            ("This search is broken in 1.3 and earlier, and will be fixed "\r
             "in a future version.  If you rely on the current behaviour, "\r
             "change it to '.+'", FutureWarning),\r
            # Element.getchildren() and Element.getiterator() are deprecated.\r
            ("This method will be removed in future versions.  "\r
             "Use .+ instead.", DeprecationWarning),\r
            ("This method will be removed in future versions.  "\r
             "Use .+ instead.", PendingDeprecationWarning),\r
            # XMLParser.doctype() is deprecated.\r
            ("This method of XMLParser is deprecated.  Define doctype.. "\r
             "method on the TreeBuilder target.", DeprecationWarning))\r
        self.checkwarnings = test_support.check_warnings(*deprecations,\r
                                                         quiet=quiet)\r
\r
    def __enter__(self):\r
        from xml.etree import ElementTree\r
        self._nsmap = ElementTree._namespace_map\r
        self._path_cache = ElementTree.ElementPath._cache\r
        # Copy the default namespace mapping\r
        ElementTree._namespace_map = self._nsmap.copy()\r
        # Copy the path cache (should be empty)\r
        ElementTree.ElementPath._cache = self._path_cache.copy()\r
        self.checkwarnings.__enter__()\r
\r
    def __exit__(self, *args):\r
        from xml.etree import ElementTree\r
        # Restore mapping and path cache\r
        ElementTree._namespace_map = self._nsmap\r
        ElementTree.ElementPath._cache = self._path_cache\r
        self.checkwarnings.__exit__(*args)\r
\r
\r
def test_main(module_name='xml.etree.ElementTree'):\r
    from test import test_xml_etree\r
\r
    use_py_module = (module_name == 'xml.etree.ElementTree')\r
\r
    # The same doctests are used for both the Python and the C implementations\r
    assert test_xml_etree.ET.__name__ == module_name\r
\r
    # XXX the C module should give the same warnings as the Python module\r
    with CleanContext(quiet=not use_py_module):\r
        test_support.run_doctest(test_xml_etree, verbosity=True)\r
\r
    # The module should not be changed by the tests\r
    assert test_xml_etree.ET.__name__ == module_name\r
\r
if __name__ == '__main__':\r
    test_main()\r