| /* Copyright 2004 The Apache Software Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| |
| package dom.checkin; |
| |
| import dom.common.NodeWithChildrenTest; |
| import junit.framework.AssertionFailedError; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.w3c.dom.*; |
| import org.xml.sax.InputSource; |
| |
| import java.io.IOException; |
| import java.io.StringReader; |
| |
| |
| /** |
| * |
| * |
| */ |
| |
| public class DocumentTest extends NodeWithChildrenTest { |
| |
| |
| public DocumentTest(String s) { |
| super(s); |
| sXml = "<foo at0=\"val0\" at1=\"val1\" at2=\"val2\" at3=\"val3\" at4=\"val4\"><bar bat0=\"val0\"/></foo>"; |
| |
| sXmlNS = "<bar xmlns:other=\"uri:other\" xmlns:myns=\"uri:foo\">" + |
| "<foo at0=\"val0\" myns:at0=\"val01\" at2=\"val2\" myns:at3=\"val3\" at4=\"val4\">" + |
| "txt0<foo>nestedfoo</foo><myns:yana/>" + |
| "</foo>" + |
| "<myns:foo>nstext<ZeD/></myns:foo>" + |
| "</bar>"; |
| } |
| |
| public static Test suite() { |
| return new TestSuite(DocumentTest.class); |
| } |
| |
| |
| public void testNodeName() { |
| assertEquals("#document", m_node.getNodeName()); |
| } |
| |
| public void testNodeType() { |
| assertEquals(Node.DOCUMENT_NODE, m_node.getNodeType()); |
| } |
| |
| |
| public void testNodeValue() { |
| assertEquals(null, m_node.getNodeValue()); |
| } |
| |
| |
| public void testNextSibling() { |
| assertEquals(null, m_node.getNextSibling()); |
| } |
| |
| public void testPreviousSibling() { |
| assertEquals(null, m_node.getPreviousSibling()); |
| } |
| |
| public void testParent() { |
| assertEquals(null, m_node.getParentNode()); |
| } |
| |
| public void testOwnerDocument() { |
| assertEquals(null, m_node.getOwnerDocument());//API spec |
| } |
| |
| public void testChildNodes() { |
| assertEquals(1, m_node.getChildNodes().getLength()); |
| } |
| |
| public void testFirstChild() { |
| assertEquals("foo", m_node.getFirstChild().getLocalName()); |
| } |
| |
| public void testLastChild() { |
| assertEquals("foo", m_node.getLastChild().getLocalName()); |
| } |
| |
| |
| public void testAppendChild() { |
| try { |
| super.testAppendChild(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| |
| } |
| |
| public void testInsertBefore() { |
| try { |
| super.testInsertBefore(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testInsertBeforeNullTarget() { |
| try { |
| super.testInsertBeforeNullTarget(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testInsertExistingNode() { |
| try { |
| super.testInsertExistingNode(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testInsertBeforeInvalidRefNode() { |
| try { |
| super.testInsertBeforeInvalidRefNode(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } catch (AssertionFailedError af) { |
| assertEquals(((DOMException) af.getCause()).code, DOMException.HIERARCHY_REQUEST_ERR); |
| } |
| } |
| |
| public void testAppendChildIllegal0() { |
| try { |
| super.testAppendChildIllegal0(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } catch (AssertionFailedError af) { |
| assertEquals(((DOMException) af.getCause()).code, DOMException.HIERARCHY_REQUEST_ERR); |
| } |
| } |
| |
| public void testAppendChildIllegal1() { |
| try { |
| super.testAppendChildIllegal1(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } catch (AssertionFailedError af) { |
| assertEquals(((DOMException) af.getCause()).code, DOMException.HIERARCHY_REQUEST_ERR); |
| } |
| } |
| |
| public void testGetChildNodes() { |
| assertEquals(1, m_node.getChildNodes().getLength()); |
| } |
| |
| public void testSetPrefix() { |
| super.testSetPrefix(); //see charData--is the exception correct |
| } |
| |
| public void testAppendChildExisting() { |
| try { |
| super.testAppendChildExisting(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testNormalize() { |
| //unque doc child--normalize in elt. or text or comment, etc |
| } |
| |
| public void testInsertBeforeDocFrag() { |
| try { |
| super.testInsertBeforeDocFrag(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testAppendChildDocFrag() { |
| try { |
| super.testAppendChildDocFrag(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| public void testReplaceChildFront() { |
| Node node = m_doc.getDocumentElement(); |
| assertEquals(node,m_node.getFirstChild()); |
| Node newNode = m_doc.createElement("fooBAR"); |
| super.testReplaceChild(newNode, node); |
| assertEquals(m_doc.getDocumentElement(),newNode); |
| } |
| |
| public void testReplaceChildEnd() { |
| Node node = m_doc.getDocumentElement(); |
| assertEquals(node,m_node.getFirstChild()); |
| Node newNode = m_doc.createElement("fooBAR"); |
| super.testReplaceChild(newNode, node); |
| } |
| public void testReplaceChildDocFrag() { |
| try { |
| super.testReplaceChildDocFrag(); |
| } catch (DOMException de) { |
| assertEquals(DOMException.HIERARCHY_REQUEST_ERR, de.code); |
| } |
| } |
| |
| public void testCreateAttribute() { |
| Attr att = m_doc.createAttribute("at0"); |
| assertEquals(null, att.getOwnerElement()); |
| assertEquals(m_doc, att.getOwnerDocument()); |
| |
| assertFalse(att.hasChildNodes()); |
| assertEquals("", att.getValue()); |
| } |
| |
| public void testCreateAttributeNS() { |
| Attr att = m_doc.createAttributeNS("foo:uri", "at0"); |
| assertEquals("foo:uri", att.getNamespaceURI()); |
| assertEquals(null, att.getOwnerElement()); |
| assertEquals(m_doc, att.getOwnerDocument()); |
| } |
| |
| //not implem |
| public void testCreateCDATASection() { |
| CDATASection cdata=m_doc.createCDATASection("<CDATA Section>"); |
| assertEquals(null,cdata.getParentNode()); |
| assertEquals(m_doc,cdata.getOwnerDocument()); |
| |
| cdata=m_doc.createCDATASection(null); |
| assertEquals(null,cdata.getParentNode()); |
| assertEquals(m_doc,cdata.getOwnerDocument()); |
| assertEquals("",cdata.getData()); |
| } |
| |
| public void testCreateComment() { |
| Comment comment = m_doc.createComment("A comment"); |
| assertEquals(null, comment.getParentNode()); |
| assertEquals(m_doc, comment.getOwnerDocument()); |
| |
| comment = m_doc.createComment(null); |
| assertEquals("",comment.getData()); |
| } |
| |
| public void testCreateDocumentFragment() { |
| DocumentFragment doc_frag = m_doc.createDocumentFragment(); |
| assertEquals(null, doc_frag.getParentNode()); |
| assertEquals(m_doc, doc_frag.getOwnerDocument()); |
| |
| } |
| |
| public void testCreateElement() { |
| Element elt1 = m_doc.createElement("elt1"); |
| assertEquals(null, elt1.getParentNode()); |
| assertEquals(m_doc, elt1.getOwnerDocument()); |
| |
| } |
| |
| public void testCreateElementNS() { |
| Element elt1 = m_doc.createElementNS("uri:foo", "ns:elt1"); |
| assertEquals("uri:foo", elt1.getNamespaceURI()); |
| assertEquals(null, elt1.getParentNode()); |
| assertEquals(m_doc, elt1.getOwnerDocument()); |
| } |
| |
| public void testCreateEntityReference() { |
| //not implemented |
| } |
| |
| public void testCreateProcessingInstruction() { |
| ProcessingInstruction pi=null; |
| try{ |
| pi = m_doc.createProcessingInstruction("xml", "version 1.0"); |
| assertEquals(null, pi.getParentNode()); |
| assertEquals(m_doc, pi.getOwnerDocument()); |
| fail(" this is a no-go"); |
| }catch (Throwable t) { |
| //TODO: ensure right exception here |
| } |
| String val=null; |
| pi = m_doc.createProcessingInstruction("xml-foo",val); |
| assertEquals("",pi.getData()); |
| |
| |
| try{ |
| pi = m_doc.createProcessingInstruction(null,"foo"); |
| fail("PI target can't be null"); |
| }catch (IllegalArgumentException e) { |
| |
| } |
| |
| |
| try { |
| pi = m_doc.createProcessingInstruction("invalid@","foo"); |
| fail("Invalid pi name"); |
| } catch (DOMException de) { |
| assertEquals(DOMException.INVALID_CHARACTER_ERR, de.code); |
| } |
| |
| } |
| |
| public void testCreateTextNode() { |
| Text txt0 = m_doc.createTextNode("foo"); |
| assertEquals(null, txt0.getParentNode()); |
| assertEquals(m_doc, txt0.getOwnerDocument()); |
| |
| txt0 = m_doc.createTextNode(null); |
| assertEquals("",txt0.getData()); |
| } |
| |
| public void testGetDoctype() { |
| //TODO throws not impl exception assertEquals(null,m_doc.getDoctype()); |
| } |
| |
| public void testGetDocumentElement() { |
| assertEquals(m_doc.getDocumentElement(), m_node.getFirstChild()); |
| } |
| |
| /* public void testGetElementById() |
| { |
| // TODO |
| fail("Test Not implemented"); |
| } |
| */ |
| public void testGetElementsByTagName() { |
| //move node @ foo |
| m_node = m_docNS; |
| NodeList result = ((Document) m_node).getElementsByTagName("*"); |
| int nEltCount = 6;//num elts in the XML |
| assertEquals(nEltCount, result.getLength()); |
| |
| result = ((Document) m_node).getElementsByTagName("zed"); |
| assertEquals(0, result.getLength()); |
| |
| } |
| |
| //elts need to come out in preorder order |
| public void testGetElementsByTagNamePreorder() { |
| m_node = m_docNS; |
| NodeList result = ((Document) m_node).getElementsByTagName("foo"); |
| assertEquals(2, result.getLength()); |
| assertEquals("txt0", result.item(0).getFirstChild().getNodeValue()); |
| assertEquals("nestedfoo", result.item(1).getFirstChild().getNodeValue()); |
| } |
| |
| |
| public void testGetElementsByTagNameDNE() { |
| m_node = m_docNS; |
| NodeList result = ((Document) m_node).getElementsByTagName("foobar"); |
| assertEquals(0, result.getLength()); |
| } |
| |
| public void testGetElementsByTagNameNS() { |
| m_node = m_docNS; |
| NodeList result = ((Document) m_node).getElementsByTagNameNS("*", "*"); |
| int nEltCount = 6; |
| assertEquals(nEltCount, result.getLength()); |
| |
| result = ((Document) m_node).getElementsByTagNameNS("*", "foo"); |
| nEltCount = 3; |
| assertEquals(nEltCount, result.getLength()); |
| assertEquals("txt0", result.item(0).getFirstChild().getNodeValue()); |
| assertEquals("nestedfoo", result.item(1).getFirstChild().getNodeValue()); |
| assertEquals("nstext", result.item(2).getFirstChild().getNodeValue()); |
| |
| |
| result = ((Document) m_node).getElementsByTagNameNS("uri:foo", "foo"); |
| assertEquals(1, result.getLength()); |
| assertEquals("nstext", result.item(0).getFirstChild().getNodeValue()); |
| |
| result = ((Document) m_node).getElementsByTagNameNS(null, "foo"); |
| assertEquals("txt0", result.item(0).getFirstChild().getNodeValue()); |
| assertEquals("nestedfoo", result.item(1).getFirstChild().getNodeValue()); |
| NodeList result1 = ((Document) m_node).getElementsByTagNameNS("", "foo"); |
| assertEquals(true, compareNodeList(result, result1)); |
| |
| |
| result = ((Document) m_node).getElementsByTagNameNS(null, "*"); |
| assertEquals(4, result.getLength()); |
| assertEquals("ZeD", ((Element) result.item(3)).getTagName()); |
| } |
| |
| public void testGetElementsByTagNameNS_DNE() { |
| m_node = m_docNS; |
| NodeList result = ((Document) m_node).getElementsByTagNameNS("uri:foo", "zed"); |
| assertEquals(0, result.getLength()); |
| |
| result = ((Document) m_node).getElementsByTagNameNS("foo:uri_DNE", "foo"); |
| assertEquals(0, result.getLength()); |
| |
| } |
| |
| public void testGetImplementation() { |
| assertTrue(m_doc.getImplementation().toString().startsWith("org.apache.xmlbeans.impl.newstore")); |
| } |
| |
| public void testImportNode() { |
| |
| Node toImport = m_docNS.getFirstChild(); |
| ((Document) m_node).importNode(toImport, true); |
| |
| toImport = m_docNS.getLastChild(); |
| ((Document) m_node).importNode(toImport, false); |
| |
| org.apache.xerces.parsers.DOMParser parser = new org.apache.xerces.parsers.DOMParser(); |
| |
| try { |
| parser.parse(new InputSource(new StringReader(sXmlNS))); |
| } catch (org.xml.sax.SAXException se) { |
| se.printStackTrace(); |
| } catch (IOException ioe) { |
| ioe.printStackTrace(System.err); |
| } |
| |
| Document xercesDocument = parser.getDocument(); |
| assertFalse(xercesDocument == null); |
| toImport = xercesDocument.getFirstChild(); |
| ((Document) m_node).importNode(toImport, true); |
| |
| toImport = xercesDocument.getLastChild(); |
| ((Document) m_node).importNode(toImport, false); |
| |
| toImport = null; |
| ((Document) m_node).importNode(toImport, false); |
| |
| ((Document) m_node).importNode(toImport, true); |
| |
| } |
| /** |
| * ATTRIBUTE_NODE |
| * The ownerElement attribute is set to null |
| * and the specified flag is set to true on the generated Attr |
| * The descendants of the source Attr are recursively imported and the resulting |
| * nodes reassembled to form the corresponding subtree |
| * Note that the deep parameter has no effect on Attr nodes; |
| * they always carry their children with them when imported |
| */ |
| |
| public void testImportAttrNode(){ |
| Node toImport=m_doc.getFirstChild().getAttributes().item(0); |
| toImport.appendChild(m_doc.createTextNode("more text")); |
| Node imported=m_docNS.importNode(toImport, false); |
| |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.ATTRIBUTE_NODE, imported.getNodeType()); |
| assertEquals(2, imported.getChildNodes().getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| } |
| /** |
| * DOCUMENT_FRAGMENT_NODE |
| * If the deep option was set to true, |
| * the descendants of the source element are |
| * recursively imported and the resulting nodes reassembled to form the |
| * corresponding subtree. |
| * Otherwise, this simply generates an empty DocumentFragment. |
| |
| */ |
| public void testImportDocFrag(){ |
| Node toImport=m_doc.createDocumentFragment(); |
| toImport.appendChild(m_doc.getFirstChild()); |
| toImport.appendChild(m_doc.createTextNode("some text")); |
| |
| Node imported=m_docNS.importNode(toImport, false); |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.DOCUMENT_FRAGMENT_NODE, imported.getNodeType()); |
| assertEquals(false, imported.hasChildNodes()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| imported=m_docNS.importNode(toImport, true); |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.DOCUMENT_FRAGMENT_NODE, imported.getNodeType()); |
| assertEquals(2, imported.getChildNodes().getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| } |
| |
| /** |
| * DOCUMENT_NODE |
| * Document nodes cannot be imported. |
| */ |
| |
| public void testImportDocument(){ |
| |
| DOMException e1=null; |
| try{ |
| m_docNS.importNode(m_doc, false); |
| }catch (DOMException de){ |
| e1=de; |
| } |
| try{ |
| m_docNS.importNode(m_doc, true); |
| fail("This should fail"); |
| }catch (DOMException de){ |
| assertEquals(DOMException.NOT_SUPPORTED_ERR, de.code); |
| } |
| if (e1==null) |
| fail("Cant import doc node"); |
| assertEquals(DOMException.NOT_SUPPORTED_ERR, e1.code); |
| } |
| |
| |
| /** |
| * ELEMENT_NODE |
| * Specified attribute nodes of the source element are imported, |
| * and the generated Attr nodes are attached to the generated Element. |
| * Default attributes are not copied, though |
| * if the document being imported into defines default |
| * attributes for this element name, those are assigned. |
| * If the importNode deep parameter was set to true, the descendants of |
| * the source element are recursively imported and the resulting nodes |
| * reassembled to form the corresponding subtree. |
| */ |
| //TODO: specified and default attributes |
| public void testImportElement(){ |
| Node toImport=m_doc.getFirstChild(); |
| Node imported=m_docNS.importNode(toImport, false); |
| |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.ELEMENT_NODE, imported.getNodeType()); |
| assertEquals(0, imported.getChildNodes().getLength()); |
| assertEquals(5, imported.getAttributes().getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| imported=m_docNS.importNode(toImport, true); |
| |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.ELEMENT_NODE, imported.getNodeType()); |
| assertEquals(1, imported.getChildNodes().getLength()); |
| assertEquals(5, imported.getAttributes().getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| } |
| |
| /** |
| * DOCUMENT_TYPE_NODE |
| * Test in ../ImportUnsupportedNodes |
| */ |
| /** |
| * ENTITY_NODE |
| * Test in ../ImportUnsupportedNodes |
| */ |
| |
| /** |
| * ENTITY_REFERENCE_NODE |
| * Test in ../ImportUnsupportedNodes |
| */ |
| /** |
| * NOTATION_NODE |
| * Test in ../ImportUnsupportedNodes |
| */ |
| /** |
| * PROCESSING_INSTRUCTION_NODE |
| * The imported node copies its target and data |
| * values from those of the source node. |
| */ |
| public void testImportPI(){ |
| Node pi=m_doc.createProcessingInstruction("xml-stylesheet","do something"); |
| m_doc.getFirstChild().appendChild(pi); |
| |
| Node imported=m_docNS.importNode(pi, false ); |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.PROCESSING_INSTRUCTION_NODE, imported.getNodeType()); |
| assertEquals("do something", ((ProcessingInstruction)imported).getData()); |
| assertEquals("xml-stylesheet", ((ProcessingInstruction)imported).getTarget()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| |
| } |
| /** |
| *TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE |
| * These three types of nodes inheriting from CharacterData copy their |
| * data and length attributes from those of the source node. |
| */ |
| public void testImportChars(){ |
| //import CDATA--nothing to do--it's always text |
| |
| //import text |
| Node txt=m_doc.createTextNode("some text"); |
| m_doc.getFirstChild().appendChild(txt); |
| |
| Node imported= m_docNS.importNode(m_doc.getFirstChild().getLastChild(),false); |
| |
| assertEquals(null, imported.getParentNode()); |
| assertEquals(Node.TEXT_NODE, imported.getNodeType()); |
| assertEquals("some text", ((Text)imported).getData()); |
| assertEquals(9, ((Text)imported).getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| |
| |
| //import Comment |
| txt=m_doc.createComment("some text"); |
| m_doc.getFirstChild().appendChild(txt); |
| assertEquals(null, imported.getParentNode()); |
| imported= m_docNS.importNode(m_doc.getFirstChild().getLastChild(),false); |
| |
| assertEquals(Node.COMMENT_NODE, imported.getNodeType()); |
| assertEquals("some text", ((Comment)imported).getData()); |
| assertEquals(9, ((Comment)imported).getLength()); |
| assertEquals(imported.getOwnerDocument(),m_docNS); |
| |
| |
| |
| } |
| public void testImportNodeNull() { |
| Node _Null = null; |
| ((Document) m_node).importNode(_Null, true); |
| ((Document) m_node).importNode(_Null, false); |
| |
| } |
| |
| public void moveToNode() { |
| m_node = m_doc; |
| |
| } |
| |
| public void setUp() throws Exception { |
| |
| super.setUp(); |
| moveToNode(); |
| } |
| } |