# test for xml.dom.minidom

import os

import sys

import pickle

from StringIO import StringIO

from test.test_support import verbose, run_unittest, TestSkipped

import unittest

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

# The tests of DocumentType importing use these helpers to construct

# the documents to work with, since not all DOM builders actually

# create the DocumentType nodes.

def create_doc_without_doctype(doctype=None):

    return getDOMImplementation().createDocument(None, "doc", doctype)

def create_nonempty_doctype():

    doctype = getDOMImplementation().createDocumentType("doc", None, None)

    doctype.entities._seq = []

    doctype.notations._seq = []

    notation = xml.dom.minidom.Notation("my-notation", None,

                                        "http://xml.python.org/notations/my")

    doctype.notations._seq.append(notation)

    entity = xml.dom.minidom.Entity("my-entity", None,

                                    "http://xml.python.org/entities/my",

                                    "my-notation")

    entity.version = "1.0"

    entity.encoding = "utf-8"

    entity.actualEncoding = "us-ascii"

    doctype.entities._seq.append(entity)

    return doctype

def create_doc_with_doctype():

    doctype = create_nonempty_doctype()

    doc = create_doc_without_doctype(doctype)

    doctype.entities.item(0).ownerDocument = doc

    doctype.notations.item(0).ownerDocument = doc

    return doc

class MinidomTest(unittest.TestCase):

    def tearDown(self):

        try:

            Node.allnodes

        except AttributeError:

            # We don't actually have the minidom from the standard library,

            # but are picking up the PyXML version from site-packages.

            pass

        else:

            self.confirm(len(Node.allnodes) == 0,

                    "assertion: len(Node.allnodes) == 0")

            if len(Node.allnodes):

                print "Garbage left over:"

                if verbose:

                    print Node.allnodes.items()[0:10]

                else:

                    # Don't print specific nodes if repeatable results

                    # are needed

                    print len(Node.allnodes)

            Node.allnodes = {}

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

        self.assertTrue(test, testname)

    def checkWholeText(self, node, s):

        t = node.wholeText

        self.confirm(t == s, "looking for %s, found %s" % (repr(s), repr(t)))

    def testParseFromFile(self):

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

        dom.unlink()

        self.confirm(isinstance(dom,Document))

    def testGetElementsByTagName(self):

        dom = parse(tstfile)

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

                dom.documentElement.getElementsByTagName("LI"))

        dom.unlink()

    def testInsertBefore(self):

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

        root = dom.documentElement

        elem = root.childNodes[0]

        nelem = dom.createElement("element")

        root.insertBefore(nelem, elem)

        self.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)

        self.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)

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

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

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

        dom.documentElement.insertBefore(frag, None)

        self.confirm(tuple(dom.documentElement.childNodes) ==

                     (orig, c1, c2, c3),

                     "insertBefore(<fragment>, None)")

        frag.unlink()

        dom.unlink()

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

        dom.documentElement.insertBefore(frag, orig)

        self.confirm(tuple(dom.documentElement.childNodes) ==

                     (c1, c2, c3, orig),

                     "insertBefore(<fragment>, orig)")

        frag.unlink()

        dom.unlink()

    def testAppendChild(self):

        dom = parse(tstfile)

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

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

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

        dom.unlink()

    def testAppendChildFragment(self):

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

        dom.documentElement.appendChild(frag)

        self.confirm(tuple(dom.documentElement.childNodes) ==

                     (orig, c1, c2, c3),

                     "appendChild(<fragment>)")

        frag.unlink()

        dom.unlink()

    def testReplaceChildFragment(self):

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

        dom.documentElement.replaceChild(frag, orig)

        orig.unlink()

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

                "replaceChild(<fragment>)")

        frag.unlink()

        dom.unlink()

    def testLegalChildren(self):

        dom = Document()

        elem = dom.createElement('element')

        text = dom.createTextNode('text')

        self.assertRaises(xml.dom.HierarchyRequestErr, dom.appendChild, text)

        dom.appendChild(elem)

        self.assertRaises(xml.dom.HierarchyRequestErr, dom.insertBefore, text,

                          elem)

        self.assertRaises(xml.dom.HierarchyRequestErr, dom.replaceChild, text,

                          elem)

        nodemap = elem.attributes

        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItem,

                          text)

        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItemNS,

                          text)

        elem.appendChild(text)

        dom.unlink()

    def testNamedNodeMapSetItem(self):

        dom = Document()

        elem = dom.createElement('element')

        attrs = elem.attributes

        attrs["foo"] = "bar"

        a = attrs.item(0)

        self.confirm(a.ownerDocument is dom,

                "NamedNodeMap.__setitem__() sets ownerDocument")

        self.confirm(a.ownerElement is elem,

                "NamedNodeMap.__setitem__() sets ownerElement")

        self.confirm(a.value == "bar",

                "NamedNodeMap.__setitem__() sets value")

        self.confirm(a.nodeValue == "bar",

                "NamedNodeMap.__setitem__() sets nodeValue")

        elem.unlink()

        dom.unlink()

    def testNonZero(self):

        dom = parse(tstfile)

        self.confirm(dom)# should not be zero

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

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

        dom.unlink()

    def testUnlink(self):

        dom = parse(tstfile)

        dom.unlink()

    def testElement(self):

        dom = Document()

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

        self.confirm(dom.documentElement)

        dom.unlink()

    def testAAA(self):

        dom = parseString("<abc/>")

        el = dom.documentElement

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

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

        a = el.getAttributeNode("spam")

        self.confirm(a.ownerDocument is dom,

                "setAttribute() sets ownerDocument")

        self.confirm(a.ownerElement is dom.documentElement,

                "setAttribute() sets ownerElement")

        dom.unlink()

    def testAAB(self):

        dom = parseString("<abc/>")

        el = dom.documentElement

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

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

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

        dom.unlink()

    def testAddAttr(self):

        dom = Document()

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

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

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

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

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

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

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

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

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

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

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

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

        dom.unlink()

    def testDeleteAttr(self):

        dom = Document()

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

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

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

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

        del child.attributes["def"]

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

        dom.unlink()

    def testRemoveAttr(self):

        dom = Document()

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

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

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

        child.removeAttribute("def")

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

        dom.unlink()

    def testRemoveAttrNS(self):

        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")

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

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

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

        dom.unlink()

    def testRemoveAttributeNode(self):

        dom = Document()

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

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

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

        node = child.getAttributeNode("spam")

        child.removeAttributeNode(node)

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

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

        dom.unlink()

    def testChangeAttr(self):

        dom = parseString("<abc/>")

        el = dom.documentElement

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

        self.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")

        self.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"

        self.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")

        self.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"

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

        pass

    def testGetAttrValues(self): pass

    def testGetAttrLength(self): pass

    def testGetAttribute(self): pass

    def testGetAttributeNS(self): pass

    def testGetAttributeNode(self): pass

    def testGetElementsByTagNameNS(self):

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

        <minidom:myelem/>

        </foo>"""

        dom = parseString(d)

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

                                           "myelem")

        self.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(self, doc, nsuri,

                                                              lname):

        nodelist = doc.getElementsByTagNameNS(nsuri, lname)

        self.confirm(len(nodelist) == 0)

    def testGetEmptyNodeListFromElementsByTagNameNS(self):

        doc = parseString('<doc/>')

        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(

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

        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(

            doc, '*', 'splat')

        self.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>')

        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(

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

        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(

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

        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(

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

    def testElementReprAndStr(self):

        dom = Document()

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

        string1 = repr(el)

        string2 = str(el)

        self.confirm(string1 == string2)

        dom.unlink()

    def testElementReprAndStrUnicode(self):

        dom = Document()

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

        string1 = repr(el)

        string2 = str(el)

        self.confirm(string1 == string2)

        dom.unlink()

    def testElementReprAndStrUnicodeNS(self):

        dom = Document()

        el = dom.appendChild(

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

        string1 = repr(el)

        string2 = str(el)

        self.confirm(string1 == string2)

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

        dom.unlink()

    def testAttributeRepr(self):

        dom = Document()

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

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

        self.confirm(str(node) == repr(node))

        dom.unlink()

    def testTextNodeRepr(self): pass

    def testWriteXML(self):

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

        dom = parseString(str)

        domstr = dom.toxml()

        dom.unlink()

        self.confirm(str == domstr)

    def testAltNewline(self):

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

        dom = parseString(str)

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

        dom.unlink()

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

    def testProcessingInstruction(self):

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

        pi = dom.documentElement.firstChild

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

    def testTextRepr(self): pass

    def testWriteText(self): pass

    def testDocumentElement(self): pass

    def testTooManyDocumentElements(self):

        doc = parseString("<doc/>")

        elem = doc.createElement("extra")

        # Should raise an exception when adding an extra document element.

        self.assertRaises(xml.dom.HierarchyRequestErr, doc.appendChild, elem)

        elem.unlink()

        doc.unlink()

    def testCreateElementNS(self): pass

    def testCreateAttributeNS(self): pass

    def testParse(self): pass

    def testParseString(self): pass

    def testComment(self): pass

    def testAttrListItem(self): pass

    def testAttrListItems(self): pass

    def testAttrListItemNS(self): pass

    def testAttrListKeys(self): pass

    def testAttrListKeysNS(self): pass

    def testRemoveNamedItem(self):

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

        e = doc.documentElement

        attrs = e.attributes

        a1 = e.getAttributeNode("a")

        a2 = attrs.removeNamedItem("a")

        self.confirm(a1.isSameNode(a2))

        self.assertRaises(xml.dom.NotFoundErr, attrs.removeNamedItem, "a")

    def testRemoveNamedItemNS(self):