# test for xml.dom.minidom

import os

import sys

import pickle

import traceback

from StringIO import StringIO

from test.test_support import verbose

import xml.dom

import xml.dom.minidom

import xml.parsers.expat

from xml.dom.minidom import parse, Node, Document, parseString

from xml.dom.minidom import getDOMImplementation

if __name__ == "__main__":

    base = sys.argv[0]

else:

    base = __file__

tstfile = os.path.join(os.path.dirname(base), "test"+os.extsep+"xml")

del base

def confirm(test, testname = "Test"):

    if not test:

        print "Failed " + testname

        raise Exception

def testParseFromFile():

    dom = parse(StringIO(open(tstfile).read()))

    dom.unlink()

    confirm(isinstance(dom,Document))

def testGetElementsByTagName():

    dom = parse(tstfile)

    confirm(dom.getElementsByTagName("LI") == \

            dom.documentElement.getElementsByTagName("LI"))

    dom.unlink()

def testInsertBefore():

    dom = parseString("<doc><foo/></doc>")

    root = dom.documentElement

    elem = root.childNodes[0]

    nelem = dom.createElement("element")

    root.insertBefore(nelem, elem)

    confirm(len(root.childNodes) == 2

            and root.childNodes.length == 2

            and root.childNodes[0] is nelem

            and root.childNodes.item(0) is nelem

            and root.childNodes[1] is elem

            and root.childNodes.item(1) is elem

            and root.firstChild is nelem

            and root.lastChild is elem

            and root.toxml() == "<doc><element/><foo/></doc>"

            , "testInsertBefore -- node properly placed in tree")

    nelem = dom.createElement("element")

    root.insertBefore(nelem, None)

    confirm(len(root.childNodes) == 3

            and root.childNodes.length == 3

            and root.childNodes[1] is elem

            and root.childNodes.item(1) is elem

            and root.childNodes[2] is nelem

            and root.childNodes.item(2) is nelem

            and root.lastChild is nelem

            and nelem.previousSibling is elem

            and root.toxml() == "<doc><element/><foo/><element/></doc>"

            , "testInsertBefore -- node properly placed in tree")

    nelem2 = dom.createElement("bar")

    root.insertBefore(nelem2, nelem)

    confirm(len(root.childNodes) == 4

            and root.childNodes.length == 4

            and root.childNodes[2] is nelem2

            and root.childNodes.item(2) is nelem2

            and root.childNodes[3] is nelem

            and root.childNodes.item(3) is nelem

            and nelem2.nextSibling is nelem

            and nelem.previousSibling is nelem2

            and root.toxml() == "<doc><element/><foo/><bar/><element/></doc>"

            , "testInsertBefore -- node properly placed in tree")

    dom.unlink()

def _create_fragment_test_nodes():

    dom = parseString("<doc/>")

    orig = dom.createTextNode("original")

    c1 = dom.createTextNode("foo")

    c2 = dom.createTextNode("bar")

    c3 = dom.createTextNode("bat")

    dom.documentElement.appendChild(orig)

    frag = dom.createDocumentFragment()

    frag.appendChild(c1)

    frag.appendChild(c2)

    frag.appendChild(c3)

    return dom, orig, c1, c2, c3, frag

def testInsertBeforeFragment():

    dom, orig, c1, c2, c3, frag = _create_fragment_test_nodes()

    dom.documentElement.insertBefore(frag, None)

    confirm(tuple(dom.documentElement.childNodes) == (orig, c1, c2, c3),

            "insertBefore(<fragment>, None)")

    frag.unlink()

    dom.unlink()

    #

    dom, orig, c1, c2, c3, frag = _create_fragment_test_nodes()

    dom.documentElement.insertBefore(frag, orig)

    confirm(tuple(dom.documentElement.childNodes) == (c1, c2, c3, orig),

            "insertBefore(<fragment>, orig)")

    frag.unlink()

    dom.unlink()

def testAppendChild():

    dom = parse(tstfile)

    dom.documentElement.appendChild(dom.createComment(u"Hello"))

    confirm(dom.documentElement.childNodes[-1].nodeName == "#comment")

    confirm(dom.documentElement.childNodes[-1].data == "Hello")

    dom.unlink()

def testAppendChildFragment():

    dom, orig, c1, c2, c3, frag = _create_fragment_test_nodes()

    dom.documentElement.appendChild(frag)

    confirm(tuple(dom.documentElement.childNodes) == (orig, c1, c2, c3),

            "appendChild(<fragment>)")

    frag.unlink()

    dom.unlink()

def testReplaceChildFragment():

    dom, orig, c1, c2, c3, frag = _create_fragment_test_nodes()

    dom.documentElement.replaceChild(frag, orig)

    orig.unlink()

    confirm(tuple(dom.documentElement.childNodes) == (c1, c2, c3),

            "replaceChild(<fragment>)")

    frag.unlink()

    dom.unlink()

def testLegalChildren():

    dom = Document()

    elem = dom.createElement('element')

    text = dom.createTextNode('text')

    try: dom.appendChild(text)

    except xml.dom.HierarchyRequestErr: pass

    else:

        print "dom.appendChild didn't raise HierarchyRequestErr"

    dom.appendChild(elem)

    try: dom.insertBefore(text, elem)

    except xml.dom.HierarchyRequestErr: pass

    else:

        print "dom.appendChild didn't raise HierarchyRequestErr"

    try: dom.replaceChild(text, elem)

    except xml.dom.HierarchyRequestErr: pass

    else:

        print "dom.appendChild didn't raise HierarchyRequestErr"

    nodemap = elem.attributes

    try: nodemap.setNamedItem(text)

    except xml.dom.HierarchyRequestErr: pass

    else:

        print "NamedNodeMap.setNamedItem didn't raise HierarchyRequestErr"

    try: nodemap.setNamedItemNS(text)

    except xml.dom.HierarchyRequestErr: pass

    else:

        print "NamedNodeMap.setNamedItemNS didn't raise HierarchyRequestErr"

    elem.appendChild(text)

    dom.unlink()

def testNamedNodeMapSetItem():

    dom = Document()

    elem = dom.createElement('element')

    attrs = elem.attributes

    attrs["foo"] = "bar"

    a = attrs.item(0)

    confirm(a.ownerDocument is dom,

            "NamedNodeMap.__setitem__() sets ownerDocument")

    confirm(a.ownerElement is elem,

            "NamedNodeMap.__setitem__() sets ownerElement")

    confirm(a.value == "bar",

            "NamedNodeMap.__setitem__() sets value")

    confirm(a.nodeValue == "bar",

            "NamedNodeMap.__setitem__() sets nodeValue")

    elem.unlink()

    dom.unlink()

def testNonZero():

    dom = parse(tstfile)

    confirm(dom)# should not be zero

    dom.appendChild(dom.createComment("foo"))

    confirm(not dom.childNodes[-1].childNodes)

    dom.unlink()

def testUnlink():

    dom = parse(tstfile)

    dom.unlink()

def testElement():

    dom = Document()

    dom.appendChild(dom.createElement("abc"))

    confirm(dom.documentElement)

    dom.unlink()

def testAAA():

    dom = parseString("<abc/>")

    el = dom.documentElement

    el.setAttribute("spam", "jam2")

    confirm(el.toxml() == '<abc spam="jam2"/>', "testAAA")

    a = el.getAttributeNode("spam")

    confirm(a.ownerDocument is dom,

            "setAttribute() sets ownerDocument")

    confirm(a.ownerElement is dom.documentElement,

            "setAttribute() sets ownerElement")

    dom.unlink()

def testAAB():

    dom = parseString("<abc/>")

    el = dom.documentElement

    el.setAttribute("spam", "jam")

    el.setAttribute("spam", "jam2")

    confirm(el.toxml() == '<abc spam="jam2"/>', "testAAB")

    dom.unlink()

def testAddAttr():

    dom = Document()

    child = dom.appendChild(dom.createElement("abc"))

    child.setAttribute("def", "ghi")

    confirm(child.getAttribute("def") == "ghi")

    confirm(child.attributes["def"].value == "ghi")

    child.setAttribute("jkl", "mno")

    confirm(child.getAttribute("jkl") == "mno")

    confirm(child.attributes["jkl"].value == "mno")

    confirm(len(child.attributes) == 2)

    child.setAttribute("def", "newval")

    confirm(child.getAttribute("def") == "newval")

    confirm(child.attributes["def"].value == "newval")

    confirm(len(child.attributes) == 2)

    dom.unlink()

def testDeleteAttr():

    dom = Document()

    child = dom.appendChild(dom.createElement("abc"))

    confirm(len(child.attributes) == 0)

    child.setAttribute("def", "ghi")

    confirm(len(child.attributes) == 1)

    del child.attributes["def"]

    confirm(len(child.attributes) == 0)

    dom.unlink()

def testRemoveAttr():

    dom = Document()

    child = dom.appendChild(dom.createElement("abc"))

    child.setAttribute("def", "ghi")

    confirm(len(child.attributes) == 1)

    child.removeAttribute("def")

    confirm(len(child.attributes) == 0)

    dom.unlink()

def testRemoveAttrNS():

    dom = Document()

    child = dom.appendChild(

            dom.createElementNS("http://www.python.org", "python:abc"))

    child.setAttributeNS("http://www.w3.org", "xmlns:python",

                                            "http://www.python.org")

    child.setAttributeNS("http://www.python.org", "python:abcattr", "foo")

    confirm(len(child.attributes) == 2)

    child.removeAttributeNS("http://www.python.org", "abcattr")

    confirm(len(child.attributes) == 1)

    dom.unlink()

def testRemoveAttributeNode():

    dom = Document()

    child = dom.appendChild(dom.createElement("foo"))

    child.setAttribute("spam", "jam")

    confirm(len(child.attributes) == 1)

    node = child.getAttributeNode("spam")

    child.removeAttributeNode(node)

    confirm(len(child.attributes) == 0

            and child.getAttributeNode("spam") is None)

    dom.unlink()

def testChangeAttr():

    dom = parseString("<abc/>")

    el = dom.documentElement

    el.setAttribute("spam", "jam")

    confirm(len(el.attributes) == 1)

    el.setAttribute("spam", "bam")

    # Set this attribute to be an ID and make sure that doesn't change

    # when changing the value:

    el.setIdAttribute("spam")

    confirm(len(el.attributes) == 1

            and el.attributes["spam"].value == "bam"

            and el.attributes["spam"].nodeValue == "bam"

            and el.getAttribute("spam") == "bam"

            and el.getAttributeNode("spam").isId)

    el.attributes["spam"] = "ham"

    confirm(len(el.attributes) == 1

            and el.attributes["spam"].value == "ham"

            and el.attributes["spam"].nodeValue == "ham"

            and el.getAttribute("spam") == "ham"

            and el.attributes["spam"].isId)

    el.setAttribute("spam2", "bam")

    confirm(len(el.attributes) == 2

            and el.attributes["spam"].value == "ham"

            and el.attributes["spam"].nodeValue == "ham"

            and el.getAttribute("spam") == "ham"

            and el.attributes["spam2"].value == "bam"

            and el.attributes["spam2"].nodeValue == "bam"

            and el.getAttribute("spam2") == "bam")

    el.attributes["spam2"] = "bam2"

    confirm(len(el.attributes) == 2

            and el.attributes["spam"].value == "ham"

            and el.attributes["spam"].nodeValue == "ham"

            and el.getAttribute("spam") == "ham"

            and el.attributes["spam2"].value == "bam2"

            and el.attributes["spam2"].nodeValue == "bam2"

            and el.getAttribute("spam2") == "bam2")

    dom.unlink()

def testGetAttrList():

    pass

def testGetAttrValues(): pass

def testGetAttrLength(): pass

def testGetAttribute(): pass

def testGetAttributeNS(): pass

def testGetAttributeNode(): pass

def testGetElementsByTagNameNS():

    d="""<foo xmlns:minidom='http://pyxml.sf.net/minidom'>

    <minidom:myelem/>

    </foo>"""

    dom = parseString(d)

    elems = dom.getElementsByTagNameNS("http://pyxml.sf.net/minidom", "myelem")

    confirm(len(elems) == 1

            and elems[0].namespaceURI == "http://pyxml.sf.net/minidom"

            and elems[0].localName == "myelem"

            and elems[0].prefix == "minidom"

            and elems[0].tagName == "minidom:myelem"

            and elems[0].nodeName == "minidom:myelem")

    dom.unlink()

def get_empty_nodelist_from_elements_by_tagName_ns_helper(doc, nsuri, lname):

    nodelist = doc.getElementsByTagNameNS(nsuri, lname)

    confirm(len(nodelist) == 0)

def testGetEmptyNodeListFromElementsByTagNameNS():

    doc = parseString('<doc/>')

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, 'http://xml.python.org/namespaces/a', 'localname')

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, '*', 'splat')

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, 'http://xml.python.org/namespaces/a', '*')

    doc = parseString('<doc xmlns="http://xml.python.org/splat"><e/></doc>')

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, "http://xml.python.org/splat", "not-there")

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, "*", "not-there")

    get_empty_nodelist_from_elements_by_tagName_ns_helper(

        doc, "http://somewhere.else.net/not-there", "e")

def testElementReprAndStr():

    dom = Document()

    el = dom.appendChild(dom.createElement("abc"))

    string1 = repr(el)

    string2 = str(el)

    confirm(string1 == string2)

    dom.unlink()

# commented out until Fredrick's fix is checked in

def _testElementReprAndStrUnicode():

    dom = Document()

    el = dom.appendChild(dom.createElement(u"abc"))

    string1 = repr(el)

    string2 = str(el)

    confirm(string1 == string2)

    dom.unlink()

# commented out until Fredrick's fix is checked in

def _testElementReprAndStrUnicodeNS():

    dom = Document()

    el = dom.appendChild(

        dom.createElementNS(u"http://www.slashdot.org", u"slash:abc"))

    string1 = repr(el)

    string2 = str(el)

    confirm(string1 == string2)

    confirm(string1.find("slash:abc") != -1)

    dom.unlink()

def testAttributeRepr():

    dom = Document()

    el = dom.appendChild(dom.createElement(u"abc"))

    node = el.setAttribute("abc", "def")

    confirm(str(node) == repr(node))

    dom.unlink()

def testTextNodeRepr(): pass

def testWriteXML():

    str = '<?xml version="1.0" ?><a b="c"/>'

    dom = parseString(str)

    domstr = dom.toxml()

    dom.unlink()

    confirm(str == domstr)

def testAltNewline():

    str = '<?xml version="1.0" ?>\n<a b="c"/>\n'

    dom = parseString(str)

    domstr = dom.toprettyxml(newl="\r\n")

    dom.unlink()

    confirm(domstr == str.replace("\n", "\r\n"))

def testProcessingInstruction():

    dom = parseString('<e><?mypi \t\n data \t\n ?></e>')

    pi = dom.documentElement.firstChild

    confirm(pi.target == "mypi"

            and pi.data == "data \t\n "

            and pi.nodeName == "mypi"

            and pi.nodeType == Node.PROCESSING_INSTRUCTION_NODE

            and pi.attributes is None

            and not pi.hasChildNodes()

            and len(pi.childNodes) == 0

            and pi.firstChild is None

            and pi.lastChild is None

            and pi.localName is None

            and pi.namespaceURI == xml.dom.EMPTY_NAMESPACE)

def testProcessingInstructionRepr(): pass

def testTextRepr(): pass

def testWriteText(): pass

def testDocumentElement(): pass

def testTooManyDocumentElements():

    doc = parseString("<doc/>")

    elem = doc.createElement("extra")

    try:

        doc.appendChild(elem)

    except xml.dom.HierarchyRequestErr:

        pass

    else:

        print "Failed to catch expected exception when" \

              " adding extra document element."

    elem.unlink()

    doc.unlink()

def testCreateElementNS(): pass

def testCreateAttributeNS(): pass

def testParse(): pass

def testParseString(): pass

def testComment(): pass

def testAttrListItem(): pass

def testAttrListItems(): pass

def testAttrListItemNS(): pass

def testAttrListKeys(): pass

def testAttrListKeysNS(): pass

def testRemoveNamedItem():

    doc = parseString("<doc a=''/>")

    e = doc.documentElement

    attrs = e.attributes

    a1 = e.getAttributeNode("a")

    a2 = attrs.removeNamedItem("a")

    confirm(a1.isSameNode(a2))

    try:

        attrs.removeNamedItem("a")

    except xml.dom.NotFoundErr:

        pass

def testRemoveNamedItemNS():

    doc = parseString("<doc xmlns:a='http://xml.python.org/' a:b=''/>")

    e = doc.documentElement

    attrs = e.attributes

    a1 = e.getAttributeNodeNS("http://xml.python.org/", "b")

    a2 = attrs.removeNamedItemNS("http://xml.python.org/", "b")

    confirm(a1.isSameNode(a2))

    try:

        attrs.removeNamedItemNS("http://xml.python.org/", "b")

    except xml.dom.NotFoundErr:

        pass

def testAttrListValues(): pass

def testAttrListLength(): pass

def testAttrList__getitem__(): pass

def testAttrList__setitem__(): pass

def testSetAttrValueandNodeValue(): pass

def testParseElement(): pass

def testParseAttributes(): pass

def testParseElementNamespaces(): pass

def testParseAttributeNamespaces(): pass

def testParseProcessingInstructions(): pass