/* $Id$ */
/*
 * The Apache Software License, Version 1.1
 * 
 * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights 
 * reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:  
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 * 
 * 4. The names "Xerces" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written 
 *    permission, please contact apache\@apache.org.
 * 
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation, and was
 * originally based on software copyright (c) 1999, International
 * Business Machines, Inc., http://www.ibm.com .  For more information
 * on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

//
//  Various DOM tests.
//     Contents include
//       1.  Basic functionality for DOMString
//       2.  Regression tests for bugs fixed.
//     All individual are wrapped in a memory leak checker.
//
//     This is NOT a complete test of DOM functionality.
//

package dom.mem;
import org.w3c.dom.*;
import org.apache.xerces.dom.DocumentImpl;
import org.apache.xerces.dom.DOMImplementationImpl;
import org.apache.xerces.dom.NotationImpl;
import java.lang.reflect.*;
import dom.util.Assertion;

public class Test {

    /**
     * version 3.0 01/25/99
     * 
     * @return boolean
     * @param node java.lang.Object
     * @param mNameIndex int
     * @param signatureIndex int
     * @param parameters java.lang.Object[]
     * @param code short
     *
     * @author Philip W. Davis
     */
    public static boolean DOMExceptionsTest(Object node,
					    String methodName,
					    Class[] methodSignature,
					    Object[] parameters,
					    short code)
    {
	boolean asExpected = false;
	Method method;

	try {
	    method = node.getClass().getMethod(methodName,methodSignature);
	    method.invoke(node, parameters);
	} catch(InvocationTargetException exc) {
	    Throwable realE = exc.getTargetException(); 
	    if(realE instanceof DOMException) {
		asExpected = (((DOMException)realE).code== code);
		if(!asExpected)
		    System.out.println("Wrong DOMException(" +
				       ((DOMException)realE).code + ")");
	    } else {
		System.out.println("Wrong Exception (" + code + ")");
	    }
	    if(!asExpected) {
		System.out.println("Expected DOMException (" +
				   code + ") not thrown");
	    }
	} catch(Exception exc) {
	    System.out.println("test invocation failure (" + exc + ")");
	}
	return (asExpected);
    }

    public static void main(String argv[])
    {
    System.out.print("DOM Memory Test.\n");

    //
    //  Test Doc01      Create a new empty document
    //
    {
        Document    doc;
        doc = new DocumentImpl();
    }
    

    //
    //  Test Doc02      Create one of each kind of node using the
    //                  document createXXX methods.
    //                  Watch for memory leaks.
    //
    {
        //  Do all operations in a preconditioning step, to force the
        //  creation of implementation objects that are set up on first use.
        //  Don't watch for leaks in this block (no  / )
        Document doc = new DocumentImpl();
        Element     el = doc.createElement("Doc02Element");
        DocumentFragment frag = doc.createDocumentFragment ();
        Text  text = doc.createTextNode("Doc02TextNode");
        Comment comment = doc.createComment("Doc02Comment");
        CDATASection  cdataSec = doc.createCDATASection("Doc02CDataSection");
        DocumentType  docType = doc.getImplementation().createDocumentType("Doc02DocumentType", null, null);
        Notation notation = ((DocumentImpl) doc).createNotation("Doc02Notation");
        ProcessingInstruction pi = doc.createProcessingInstruction("Doc02PITarget",
                                    "Doc02PIData");
        NodeList    nodeList = doc.getElementsByTagName("*");
    }


    {
        Document doc = new DocumentImpl();
        Element     el = doc.createElement("Doc02Element");
    }
    

    {
        Document    doc = new DocumentImpl();
        DocumentFragment frag = doc.createDocumentFragment ();
    };
    

    {
        Document doc = new DocumentImpl();
        Element     el = doc.createElement("Doc02Element");
    }
    

    {
        Document doc = new DocumentImpl();
        Text  text = doc.createTextNode("Doc02TextNode");
    }
    

    {
        Document doc = new DocumentImpl();
        Comment comment = doc.createComment("Doc02Comment");
    }
    

    {
        Document doc = new DocumentImpl();
        CDATASection  cdataSec = doc.createCDATASection("Doc02CDataSection");
    }
    

    {
        Document doc = new DocumentImpl();
        DocumentType  docType = doc.getImplementation().createDocumentType("Doc02DocumentType", null, null);
    }
    

    {
        Document doc = new DocumentImpl();
        Notation notation = ((DocumentImpl)doc).createNotation("Doc02Notation");
    }
    

    {
        Document doc = new DocumentImpl();
        ProcessingInstruction pi = doc.createProcessingInstruction("Doc02PITarget",
                                    "Doc02PIData");
    }
    

    {
        Document doc = new DocumentImpl();
        Attr  attribute = doc.createAttribute("Doc02Attribute");
    }
    

    {
        Document doc = new DocumentImpl();
        EntityReference  er = doc.createEntityReference("Doc02EntityReference");
    }
    

    {
        Document doc = new DocumentImpl();
        NodeList    nodeList = doc.getElementsByTagName("*");
    }
    

    //
    //  Doc03 - Create a small document tree
    //
    
    {
        Document    doc = new DocumentImpl();
        Element     rootEl = doc.createElement("Doc03RootElement");
        doc.appendChild(rootEl);
        Text        textNode = doc.createTextNode("Doc03 text stuff");
        rootEl.appendChild(textNode);

        NodeList    nodeList = doc.getElementsByTagName("*");
    };
    

    //
    //  Attr01
    //
    {
        Document    doc = new DocumentImpl();
        Element     rootEl  = doc.createElement("RootElement");
        doc.appendChild(rootEl);
        {
            Attr        attr01  = doc.createAttribute("Attr01");
            rootEl.setAttributeNode(attr01);
        }
        
        
        {
            Attr attr02 = doc.createAttribute("Attr01");
            rootEl.setAttributeNode(attr02);  
        }
        
    };

    //
    //  Attr02
    //
    
    {
        Document    doc = new DocumentImpl();
        Element     rootEl  = doc.createElement("RootElement");
        doc.appendChild(rootEl);
        Attr        attr01  = doc.createAttribute("Attr02");
        rootEl.setAttributeNode(attr01);
        Attr        attr02 = doc.createAttribute("Attr02");
        rootEl.setAttributeNode(attr02);  
    }
    

    //
    //  Attr03
    //
    
    {
        Document    doc = new DocumentImpl();
        Element     rootEl  = doc.createElement("RootElement");
        doc.appendChild(rootEl);
        Attr        attr01  = doc.createAttribute("Attr03");
        rootEl.setAttributeNode(attr01);

        attr01.setValue("Attr03Value1");
        attr01.setValue("Attr03Value2");
    }
    

    //
    //  Text01
    //
    
    {
        Document    doc = new DocumentImpl();
        Element     rootEl  = doc.createElement("RootElement");
        doc.appendChild(rootEl);


        Text        txt1 = doc.createTextNode("Hello Goodbye");
        rootEl.appendChild(txt1);

        txt1.splitText(6);
        rootEl.normalize();

    }
    

    //
    //  Notation01
    //
    
    { 
	/*
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        DocumentType    dt  =
	  impl.createDocumentType("DocType_for_Notation01", null, null, null);
        doc.appendChild(dt);


        NamedNodeMap notationMap = dt.getNotations();
        Notation    nt1 = ((DocumentImpl) doc).createNotation("Notation01");
        ((NotationImpl) nt1).setPublicId("Notation01PublicId");
        notationMap.setNamedItem (nt1);
        Notation    nt2 = (Notation)notationMap.getNamedItem("Notation01");
        Assertion.assert(nt1==nt2);
        nt2 = new NotationImpl((DocumentImpl)doc, null);
        nt1 = null;
        nt2 = (Notation)notationMap.getNamedItem("Notation01");
      
    */
    }
    

    //
    //  NamedNodeMap01 - comparison operators.
    //
    
    {
        NamedNodeMap    nnm = null;
        Assertion.assert(nnm == null);

        Document        doc = new DocumentImpl();
        nnm = doc.getAttributes();    // Should be null, because node type
                                      //   is not Element.
        Assertion.assert(nnm == null);
        Assertion.assert(!(nnm != null));

        Element el = doc.createElement("NamedNodeMap01");
        NamedNodeMap nnm2 = el.getAttributes();    // Should be an empty, but non-null map.
        Assertion.assert(nnm2 != null);
        Assertion.assert(nnm != nnm2);
        nnm = nnm2;
        Assertion.assert(nnm == nnm2);
    }
    

    //
    //  importNode quick test
    //
    
    {
        Document    doc1 = new DocumentImpl();
        Document    doc2 = new DocumentImpl();
        
        Element     el1  = doc1.createElement("abc");
        doc1.appendChild(el1);
        Assertion.assert(el1.getParentNode() != null);
        el1.setAttribute("foo", "foovalue");
        Node        el2  = doc2.importNode(el1, true);
        Assertion.assert(el2.getParentNode() == null);
        String       tagName = el2.getNodeName();
        Assertion.equals(tagName, "abc");
        Assertion.assert(el2.getOwnerDocument() == doc2);
        Assertion.equals(((Element) el2).getAttribute("foo"), "foovalue");
        Assertion.assert(doc1 != doc2);
    }
    

    //
    //  getLength() tests.  Both Node CharacterData and NodeList implement
    //                  getLength().  Early versions of the DOM had a clash
    //                  between the two, originating in the implementation class
    //                  hirearchy, which has NodeList as a (distant) base class
    //                  of CharacterData.  This is a regression test to verify
    //                  that the problem stays fixed.
    //
    
    {
        Document     doc = new DocumentImpl();
        Text          tx = doc.createTextNode("Hello");
        Element       el = doc.createElement("abc");
        el.appendChild(tx);

        int     textLength = tx.getLength();
        Assertion.assert(textLength == 5);

        NodeList      nl = tx.getChildNodes();
        int      nodeListLen = nl.getLength();
        Assertion.assert(nodeListLen == 0);

        nl = el.getChildNodes();
        nodeListLen = nl.getLength();
        Assertion.assert(nodeListLen == 1);
    }


    //
    //  NodeList - comparison operators, basic operation.
    //
    
    {
        NodeList    nl = null;
        NodeList    nl2 = null;
        Assertion.assert(nl == null);
        Assertion.assert(!(nl != null));
        Assertion.assert(nl == nl2);

        Document        doc = new DocumentImpl();
        nl = doc.getChildNodes();    // Should be non-null, but empty

        Assertion.assert(nl != null);
        int len = nl.getLength();
        Assertion.assert(len == 0);

        Element el = doc.createElement("NodeList01");
        doc.appendChild(el);
        len = nl.getLength();
        Assertion.assert(len == 1);
        Assertion.assert(nl != nl2);
        nl2 = nl;
        Assertion.assert(nl == nl2);
    }
    

    //
    //  Name validity checking.
    //
    
    {
         Document        doc = new DocumentImpl();
         Assertion.assert(DOMExceptionsTest(doc, "createElement",
					  new Class[]{String.class},
					  new Object[]{"!@@ bad element name"},
					  DOMException.INVALID_CHARACTER_ERR));
    }
    

    //
    //  Assignment ops return value
    //
    
    {
        Document        doc = new DocumentImpl();
        Element el = doc.createElement("NodeList01");
        doc.appendChild(el);
        
        Element n1, n2, n3;
        
        n1 = n2 = n3 = el;
        Assertion.assert(n1 == n2);
        Assertion.assert(n1 == n3);
        Assertion.assert(n1 == el);
        Assertion.assert(n1 != null);
        n1 = n2 = n3 = null;
        Assertion.assert(n1 == null);
    }
    

    //
    //  Cloning of a node with attributes. Regression test for a ref counting 
    //  bug in attributes of cloned nodes that occured when the "owned" flag
    //  was not set in the clone.
    //
    
    {
        Document    doc = new DocumentImpl();
        Element     root = doc.createElement("CTestRoot");
        root.setAttribute("CTestAttr", "CTestAttrValue");

        String s = root.getAttribute("CTestAttr");
        Assertion.equals(s, "CTestAttrValue");

        Element     cloned = (Element)root.cloneNode(true);
        Attr a = cloned.getAttributeNode("CTestAttr");
        Assertion.assert(a != null);
        s = a.getValue();
        Assertion.equals(s, "CTestAttrValue");
        a = null;

        a = cloned.getAttributeNode("CTestAttr");
        Assertion.assert(a != null);
        s = a.getValue();
        Assertion.equals(s, "CTestAttrValue");

    }
    

    //
    //  DOM Level 2 tests.  These should be split out as a separate test.
    //


    //
    // hasFeature.  The set of supported options tested here is for Xerces 1.1
    //
    
    {
        DOMImplementation  impl = DOMImplementationImpl.getDOMImplementation();
        Assertion.assert(impl.hasFeature("XML", "2.0")    == true);
        Assertion.assert(impl.hasFeature("XML", null)       == true);
        //  We also support 1.0
        Assertion.assert(impl.hasFeature("XML", "1.0")    == true);
        Assertion.assert(impl.hasFeature("XML", "3.0")    == false);
        Assertion.assert(impl.hasFeature("Traversal", null) == true);


        Assertion.assert(impl.hasFeature("HTML", null)           == false);
        Assertion.assert(impl.hasFeature("Views", null)          == false);
        Assertion.assert(impl.hasFeature("StyleSheets", null)    == false);
        Assertion.assert(impl.hasFeature("CSS", null)            == false);
        Assertion.assert(impl.hasFeature("CSS2", null)           == false);
        Assertion.assert(impl.hasFeature("Events", null)         == true);
        Assertion.assert(impl.hasFeature("UIEvents", null)       == false);
        Assertion.assert(impl.hasFeature("MouseEvents", null)    == false);
        Assertion.assert(impl.hasFeature("MutationEvents", null) == true);
        Assertion.assert(impl.hasFeature("HTMLEvents", null)     == false);
        Assertion.assert(impl.hasFeature("Range", null)          == false);
    }
    

    //
    // CreateDocumentType
    //
    
    {
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        Assertion.assert(dt != null);
        Assertion.assert(dt.getNodeType() == Node.DOCUMENT_TYPE_NODE);
        Assertion.equals(dt.getNodeName(), qName);
        Assertion.assert(dt.getNamespaceURI() == null);
        Assertion.assert(dt.getPrefix() == null);
        Assertion.assert(dt.getLocalName() == null);
        Assertion.equals(dt.getPublicId(), pubId);
        Assertion.equals(dt.getSystemId(), sysId);
        Assertion.assert(dt.getInternalSubset() == null);
        Assertion.assert(dt.getOwnerDocument() == null);
        
        NamedNodeMap nnm = dt.getEntities();
        Assertion.assert(nnm.getLength() == 0);
        nnm = dt.getNotations();
        Assertion.assert(nnm.getLength() == 0);

        //
        // Qualified name without prefix should also work.
        //
        qName = "docName";
        dt = impl.createDocumentType(qName, pubId, sysId);

        Assertion.assert(dt != null);
        Assertion.assert(dt.getNodeType() == Node.DOCUMENT_TYPE_NODE);
        Assertion.equals(dt.getNodeName(), qName);
        Assertion.assert(dt.getNamespaceURI() == null);
        Assertion.assert(dt.getPrefix() == null);
        Assertion.assert(dt.getLocalName() == null);
        Assertion.equals(dt.getPublicId(), pubId);
        Assertion.equals(dt.getSystemId(), sysId);
        Assertion.assert(dt.getInternalSubset() == null);
        Assertion.assert(dt.getOwnerDocument() == null);

        // Creating a DocumentType with invalid or malformed qName should fail.
        Assertion.assert(DOMExceptionsTest(impl, "createDocumentType",
			new Class[]{String.class, String.class, String.class},
			new Object[]{"<docName", pubId, sysId},
			DOMException.INVALID_CHARACTER_ERR));     
        Assertion.assert(DOMExceptionsTest(impl, "createDocumentType",
			new Class[]{String.class, String.class, String.class},
			new Object[]{":docName", pubId, sysId},
			DOMException.NAMESPACE_ERR));     
        Assertion.assert(DOMExceptionsTest(impl, "createDocumentType",
			new Class[]{String.class, String.class, String.class},
			new Object[]{"docName:", pubId, sysId},
			DOMException.NAMESPACE_ERR));     
        Assertion.assert(DOMExceptionsTest(impl, "createDocumentType",
			new Class[]{String.class, String.class, String.class},
			new Object[]{"<doc::Name", pubId, sysId},
			DOMException.INVALID_CHARACTER_ERR));     
        Assertion.assert(DOMExceptionsTest(impl, "createDocumentType",
			new Class[]{String.class, String.class, String.class},
			new Object[]{"<doc:N:ame", pubId, sysId},
			DOMException.INVALID_CHARACTER_ERR));     
    }

    //
    //  DOMImplementation.CreateDocument
    //
    
    {
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        String docNSURI = "http://document.namespace";
        Document doc = impl.createDocument(docNSURI, qName, dt);

        Assertion.assert(dt.getOwnerDocument() == doc);
        Assertion.assert(doc.getOwnerDocument() == null);

        Assertion.assert(doc.getNodeType() == Node.DOCUMENT_NODE);
        Assertion.assert(doc.getDoctype() == dt);
        Assertion.equals(doc.getNodeName(), "#document");
        Assertion.assert(doc.getNodeValue() == null);

        Element el = doc.getDocumentElement();

        Assertion.equals(el.getLocalName(), "docName");
        Assertion.equals(el.getNamespaceURI(), docNSURI);
        Assertion.equals(el.getNodeName(), qName);
        Assertion.assert(el.getOwnerDocument() == doc);
        Assertion.assert(el.getParentNode() == doc);
        Assertion.equals(el.getPrefix(), "foo");
        Assertion.equals(el.getTagName(), qName);
        Assertion.assert(el.hasChildNodes() == false);

        //
        // Creating a second document with the same docType object should fail.
        //
        Assertion.assert(DOMExceptionsTest(impl, "createDocument",
					   new Class[]{String.class,
						       String.class,
						       DocumentType.class},
					   new Object[]{docNSURI, qName, dt},
					   DOMException.WRONG_DOCUMENT_ERR));

        // Namespace tests of createDocument are covered by createElementNS below
    }
    
    
    //
    //  CreateElementNS methods
    //
    
    {
        
        // Set up an initial (root element only) document.
        // 
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        String docNSURI = "http://document.namespace";
	Document doc = impl.createDocument(docNSURI, qName, dt);
        Element rootEl = doc.getDocumentElement();

        //
        // CreateElementNS
        //
        Element ela = doc.createElementNS("http://nsa", "a:ela");  // prefix and URI
        Element elb = doc.createElementNS("http://nsb", "elb");    //  URI, no prefix.
        Element elc = doc.createElementNS(null, "elc");              // No URI, no prefix.

        rootEl.appendChild(ela);
        rootEl.appendChild(elb);
        rootEl.appendChild(elc);

        Assertion.equals(ela.getNodeName(), "a:ela");
        Assertion.equals(ela.getNamespaceURI(), "http://nsa");
        Assertion.equals(ela.getPrefix(), "a");
        Assertion.equals(ela.getLocalName(), "ela");
        Assertion.equals(ela.getTagName(), "a:ela");

        Assertion.equals(elb.getNodeName(), "elb");
        Assertion.equals(elb.getNamespaceURI(), "http://nsb");
        Assertion.assert(elb.getPrefix() == null);
        Assertion.equals(elb.getLocalName(), "elb");
        Assertion.equals(elb.getTagName(), "elb");

        Assertion.equals(elc.getNodeName(), "elc");
        Assertion.assert(elc.getNamespaceURI() == null);
        Assertion.assert(elc.getPrefix() ==  null);
        Assertion.equals(elc.getLocalName(), "elc");
        Assertion.equals(elc.getTagName(), "elc");

        // Badly formed qualified name
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "<a"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", ":a"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a:"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a::a"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a:a:a"},
				      DOMException.NAMESPACE_ERR));

        // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
	String xmlURI = "http://www.w3.org/XML/1998/namespace";
	Assertion.equals(doc.createElementNS(xmlURI, "xml:a").getNamespaceURI(), xmlURI);
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "xml:a"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"", "xml:a"},
				      DOMException.NAMESPACE_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null, "xml:a"},
				      DOMException.NAMESPACE_ERR));

        //unlike Attribute, xmlns (no different from foo) can have any namespaceURI for Element
        Assertion.equals(doc.createElementNS("http://nsa", "xmlns").getNamespaceURI(), "http://nsa");
        Assertion.equals(doc.createElementNS(xmlURI, "xmlns").getNamespaceURI(), xmlURI);
        Assertion.equals(doc.createElementNS("", "xmlns").getNamespaceURI(), "");
        Assertion.assert(doc.createElementNS(null, "xmlns").getNamespaceURI() == null);

        //unlike Attribute, xmlns:a (no different from foo:a) can have any
	// namespaceURI for Element except null
        Assertion.equals(doc.createElementNS("http://nsa", "xmlns:a").getNamespaceURI(), "http://nsa");
        Assertion.equals(doc.createElementNS(xmlURI, "xmlns:a").getNamespaceURI(), xmlURI);
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null, "xmlns:a"},
				      DOMException.NAMESPACE_ERR));

        //In fact, any prefix != null should have a namespaceURI != null
        Assertion.equals(doc.createElementNS("http://nsa", "foo:a").getNamespaceURI(), "http://nsa");
	Assertion.assert(DOMExceptionsTest(doc, "createElementNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null, "foo:a"},
				      DOMException.NAMESPACE_ERR));

        //Change prefix
        Element elem = doc.createElementNS("http://nsa", "foo:a");
        elem.setPrefix("bar");
        Assertion.equals(elem.getNodeName(), "bar:a");
        Assertion.equals(elem.getNamespaceURI(), "http://nsa");
        Assertion.equals(elem.getPrefix(), "bar");
        Assertion.equals(elem.getLocalName(), "a");
        Assertion.equals(elem.getTagName(), "bar:a");
        //The spec does not prevent us from setting prefix to a node without prefix
        elem = doc.createElementNS("http://nsa", "a");
        Assertion.equals(elem.getPrefix(), null);
        elem.setPrefix("bar");
        Assertion.equals(elem.getNodeName(), "bar:a");
        Assertion.equals(elem.getNamespaceURI(), "http://nsa");
        Assertion.equals(elem.getPrefix(), "bar");
        Assertion.equals(elem.getLocalName(), "a");
        Assertion.equals(elem.getTagName(), "bar:a");
        //Special case for xml:a where namespaceURI must be xmlURI
        elem = doc.createElementNS(xmlURI, "foo:a");
        elem.setPrefix("xml");
        elem = doc.createElementNS("http://nsa", "foo:a");
        Assertion.assert(DOMExceptionsTest(elem, "setPrefix",
					  new Class[]{String.class},
					  new Object[]{"xml"},
					  DOMException.NAMESPACE_ERR));
        //However, there is no restriction on prefix xmlns
        elem.setPrefix("xmlns");
        //Also an element can not have a prefix with namespaceURI == null
        elem = doc.createElementNS(null, "a");
        Assertion.assert(DOMExceptionsTest(elem, "setPrefix",
					  new Class[]{String.class},
					  new Object[]{"foo"},
					  DOMException.NAMESPACE_ERR));

        //Only prefix of Element and Attribute can be changed
        Assertion.assert(DOMExceptionsTest(doc, "setPrefix",
					  new Class[]{String.class},
					  new Object[]{"foo"},
					  DOMException.NAMESPACE_ERR));

        //Prefix of readonly Element can not be changed.
        //However, there is no way to create such Element for testing yet.
    }
    

    //
    //  CreateAttributeNS methods
    //
    
    {
        
        // Set up an initial (root element only) document.
        // 
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        String docNSURI = "http://document.namespace";
        Document doc = impl.createDocument(docNSURI, qName, dt);
        Element rootEl = doc.getDocumentElement();

        //
        // CreateAttributeNS
        //
        Attr attra = doc.createAttributeNS("http://nsa", "a:attra");       // prefix and URI
        Attr attrb = doc.createAttributeNS("http://nsb", "attrb");         //  URI, no prefix.
        Attr attrc = doc.createAttributeNS(null, "attrc");    // No URI, no prefix.

        Assertion.equals(attra.getNodeName(), "a:attra");
        Assertion.equals(attra.getNamespaceURI(), "http://nsa");
        Assertion.equals(attra.getPrefix(), "a");
        Assertion.equals(attra.getLocalName(), "attra");
        Assertion.equals(attra.getName(), "a:attra");
        Assertion.assert(attra.getOwnerElement() == null);

        Assertion.equals(attrb.getNodeName(), "attrb");
        Assertion.equals(attrb.getNamespaceURI(), "http://nsb");
        Assertion.equals(attrb.getPrefix(), null);
        Assertion.equals(attrb.getLocalName(), "attrb");
        Assertion.equals(attrb.getName(), "attrb");
        Assertion.assert(attrb.getOwnerElement() == null);

        Assertion.equals(attrc.getNodeName(), "attrc");
        Assertion.assert(attrc.getNamespaceURI() == null);
        Assertion.assert(attrc.getPrefix() == null);
        Assertion.equals(attrc.getLocalName(), "attrc");
        Assertion.equals(attrc.getName(), "attrc");
        Assertion.assert(attrc.getOwnerElement() == null);


        // Badly formed qualified name
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "<a"},
				      DOMException.INVALID_CHARACTER_ERR));
	Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", ":a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a:"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a::a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "a:a:a"},
				      DOMException.NAMESPACE_ERR));

        // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
        String xmlURI = "http://www.w3.org/XML/1998/namespace";
        Assertion.equals(doc.createAttributeNS(xmlURI, "xml:a").getNamespaceURI(), xmlURI);
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "xml:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"", "xml:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null,  "xml:a"},
				      DOMException.NAMESPACE_ERR));

        //unlike Element, xmlns must have namespaceURI == "http://www.w3.org/2000/xmlns/"
        String xmlnsURI = "http://www.w3.org/2000/xmlns/";
        Assertion.equals(doc.createAttributeNS(xmlnsURI, "xmlns").getNamespaceURI(), xmlnsURI);
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "xmlns"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{xmlURI, "xmlns"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"", "xmlns"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null,  "xmlns"},
				      DOMException.NAMESPACE_ERR));

        //unlike Element, xmlns:a must have namespaceURI == "http://www.w3.org/2000/xmlns/"
        Assertion.equals(doc.createAttributeNS(xmlnsURI, "xmlns:a").getNamespaceURI(), xmlnsURI);
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"http://nsa", "xmlns:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{xmlURI, "xmlns:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"", "xmlns:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null,  "xmlns:a"},
				      DOMException.NAMESPACE_ERR));

        //In fact, any prefix != null should have a namespaceURI != null
        Assertion.equals(doc.createAttributeNS("http://nsa", "foo:a").getNamespaceURI(), "http://nsa");
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{"", "foo:a"},
				      DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(doc, "createAttributeNS",
				      new Class[]{String.class, String.class},
				      new Object[]{null,  "foo:a"},
				      DOMException.NAMESPACE_ERR));

        //Change prefix
        Attr attr = doc.createAttributeNS("http://nsa", "foo:a");
        attr.setPrefix("bar");
        Assertion.equals(attr.getNodeName(), "bar:a");
        Assertion.equals(attr.getNamespaceURI(), "http://nsa");
        Assertion.equals(attr.getPrefix(), "bar");
        Assertion.equals(attr.getLocalName(), "a");
        Assertion.equals(attr.getName(), "bar:a");
        //The spec does not prevent us from setting prefix to a node without prefix
        attr = doc.createAttributeNS("http://nsa", "a");
        Assertion.assert(attr.getPrefix() == null);
        attr.setPrefix("bar");
        Assertion.equals(attr.getNodeName(), "bar:a");
        Assertion.equals(attr.getNamespaceURI(), "http://nsa");
        Assertion.equals(attr.getPrefix(), "bar");
        Assertion.equals(attr.getLocalName(), "a");
        Assertion.equals(attr.getName(), "bar:a");
        //Special case for xml:a where namespaceURI must be xmlURI
        attr = doc.createAttributeNS(xmlURI, "foo:a");
        attr.setPrefix("xml");
        attr = doc.createAttributeNS("http://nsa", "foo:a");
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"xml"},
					   DOMException.NAMESPACE_ERR));
        //Special case for xmlns:a where namespaceURI must be xmlURI
        attr = doc.createAttributeNS(xmlnsURI, "foo:a");
        attr.setPrefix("xmlns");
        attr = doc.createAttributeNS("http://nsa", "foo:a");
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"xmlns"},
					   DOMException.NAMESPACE_ERR));
        //Special case for xmlns where no prefix can be set
        attr = doc.createAttributeNS(xmlnsURI, "xmlns");
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"xml"},
					   DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"foo"},
					   DOMException.NAMESPACE_ERR));
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"xmlns"},
					   DOMException.NAMESPACE_ERR));
        //Also an attribute can not have a prefix with namespaceURI == null
        attr = doc.createAttributeNS(null, "a");
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"foo"},
					   DOMException.NAMESPACE_ERR));
        
        //Only prefix of Element and Attribute can be changed
        Assertion.assert(DOMExceptionsTest(attr, "setPrefix",
					   new Class[]{String.class},
					   new Object[]{"foo"},
					   DOMException.NAMESPACE_ERR));

        //Prefix of readonly Attribute can not be changed.
        //However, there is no way to create such DOM_Attribute for testing yet.
    }
    

    //
    //  getElementsByTagName*
    //
    
    {
        
        // Set up an initial (root element only) document.
        // 
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        String docNSURI = "http://document.namespace";
	Document doc = impl.createDocument(docNSURI, qName, dt);
        Element rootEl = doc.getDocumentElement();

        //
        // Populate the document
        //
        Element ela = doc.createElementNS("http://nsa", "a:ela");  
        rootEl.appendChild(ela);
        Element elb = doc.createElementNS("http://nsb", "elb");   
        rootEl.appendChild(elb);
        Element elc = doc.createElementNS(null,           "elc");  
        rootEl.appendChild(elc);
        Element eld = doc.createElementNS("http://nsa", "d:ela");
        rootEl.appendChild(eld);
        Element ele = doc.createElementNS("http://nse", "elb");   
        rootEl.appendChild(ele);


        // 
        // Access with DOM Level 1 getElementsByTagName
        //

        NodeList nl = doc.getElementsByTagName("a:ela");
        Assertion.assert(nl.getLength() == 1);
        Assertion.assert(nl.item(0) == ela);

        nl = doc.getElementsByTagName("elb");
        Assertion.assert(nl.getLength() == 2);
        Assertion.assert(nl.item(0) == elb);
        Assertion.assert(nl.item(1) == ele);

        nl = doc.getElementsByTagName("d:ela");
        Assertion.assert(nl.getLength() == 1);
        Assertion.assert(nl.item(0) == eld);

        //
        //  Access with DOM Level 2 getElementsByTagNameNS
        //

        nl = doc.getElementsByTagNameNS(null, "elc");
        Assertion.assert(nl.getLength() == 1);
        Assertion.assert(nl.item(0) == elc);
       
        nl = doc.getElementsByTagNameNS("http://nsa", "ela");
        Assertion.assert(nl.getLength() == 2);
        Assertion.assert(nl.item(0) == ela);
        Assertion.assert(nl.item(1) == eld);

        nl = doc.getElementsByTagNameNS(null, "elb");
        Assertion.assert(nl.getLength() == 0);

        nl = doc.getElementsByTagNameNS("http://nsb", "elb");
        Assertion.assert(nl.getLength() == 1);
        Assertion.assert(nl.item(0) == elb);

        nl = doc.getElementsByTagNameNS("*", "elb");
        Assertion.assert(nl.getLength() == 2);
        Assertion.assert(nl.item(0) == elb);
        Assertion.assert(nl.item(1) == ele);

        nl = doc.getElementsByTagNameNS("http://nsa", "*");
        Assertion.assert(nl.getLength() == 2);
        Assertion.assert(nl.item(0) == ela);
        Assertion.assert(nl.item(1) == eld);

        nl = doc.getElementsByTagNameNS("*", "*");
        Assertion.assert(nl.getLength() == 6);     // Gets the document root element, plus 5 more

        Assertion.assert(nl.item(6) == null);
        // Assertion.assert(nl.item(-1) == 0);

        nl = rootEl.getElementsByTagNameNS("*", "*");
        Assertion.assert(nl.getLength() == 5);


        nl = doc.getElementsByTagNameNS("http://nsa", "d:ela");
        Assertion.assert(nl.getLength() == 0);


        //
        // Node lists are Live
        //

        nl = doc.getElementsByTagNameNS("*", "*");
        NodeList nla = ela.getElementsByTagNameNS("*", "*");

        Assertion.assert(nl.getLength() == 6); 
        Assertion.assert(nla.getLength() == 0);

        rootEl.removeChild(elc);
        Assertion.assert(nl.getLength() == 5);
        Assertion.assert(nla.getLength() == 0);

        ela.appendChild(elc);
        Assertion.assert(nl.getLength() == 6);
        Assertion.assert(nla.getLength() == 1);
    }


   //
    // Attributes and NamedNodeMaps.
    //
    {

        // Set up an initial (root element only) document.
        // 
        DOMImplementation impl = DOMImplementationImpl.getDOMImplementation();
        
        String qName = "foo:docName";
        String pubId = "pubId";
        String sysId = "http://sysId";
        DocumentType dt = impl.createDocumentType(qName, pubId, sysId);
        
        String docNSURI = "http://document.namespace";
        Document doc = impl.createDocument(docNSURI, qName, dt);
        Element rootEl = doc.getDocumentElement();

        //
        // Create a set of attributes and hang them on the root element.
        //
        Attr attra = doc.createAttributeNS("http://nsa", "a:attra");  
        rootEl.setAttributeNodeNS(attra);
        Attr attrb = doc.createAttributeNS("http://nsb", "attrb");   
        rootEl.setAttributeNodeNS(attrb);
        Attr attrc = doc.createAttributeNS(null,           "attrc");  
        rootEl.setAttributeNodeNS(attrc);
        Attr attrd = doc.createAttributeNS("http://nsa", "d:attra");
        rootEl.setAttributeNodeNS(attrd);
        Attr attre = doc.createAttributeNS("http://nse", "attrb");   
        rootEl.setAttributeNodeNS(attre);

        //
        // Check that the attribute nodes were created with the correct properties.
        //
        Assertion.equals(attra.getNodeName(), "a:attra");
        Assertion.equals(attra.getNamespaceURI(), "http://nsa");
        Assertion.equals(attra.getLocalName(), "attra");
        Assertion.equals(attra.getName(), "a:attra");
        Assertion.assert(attra.getNodeType() == Node.ATTRIBUTE_NODE);
        Assertion.equals(attra.getNodeValue(), "");
        Assertion.equals(attra.getPrefix(), "a");
        Assertion.assert(attra.getSpecified() == true);
        Assertion.equals(attra.getValue(), "");
        Assertion.assert(attra.getOwnerElement() == null);

        // Test methods of NamedNodeMap
        NamedNodeMap nnm = rootEl.getAttributes();
        Assertion.assert(nnm.getLength() == 4);
        Assertion.assert(nnm.getNamedItemNS("http://nsa", "attra") == attrd);
        Assertion.assert(nnm.getNamedItemNS("http://nsb", "attrb") == attrb);
        Assertion.assert(nnm.getNamedItemNS("http://nse", "attrb") == attre);
        Assertion.assert(nnm.getNamedItemNS(null, "attrc") == attrc);
        Assertion.assert(nnm.getNamedItemNS(null, "attra") == null);
        Assertion.assert(nnm.getNamedItemNS("http://nsa", "attrb") == null);
    }
    };
}