| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999-2002 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.apache.org. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package dom.rename; |
| |
| import java.io.PrintWriter; |
| |
| import org.w3c.dom.*; |
| |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| |
| import dom.util.Assertion; |
| import dom.ParserWrapper; |
| |
| /** |
| * A simple program to test Document.getElementById() and the management |
| * of ID attributes. Originally based on dom.Counter. |
| * This test takes as input input.xml file |
| * |
| * @author Andy Clark, IBM |
| * @author Arnaud Le Hors, IBM |
| * |
| * @version $Id$ |
| */ |
| public class Test implements UserDataHandler { |
| |
| // |
| // Constants |
| // |
| |
| // feature ids |
| |
| protected static final String NAMESPACES_FEATURE_ID = |
| "http://xml.org/sax/features/namespaces"; |
| |
| protected static final String VALIDATION_FEATURE_ID = |
| "http://xml.org/sax/features/validation"; |
| |
| protected static final String SCHEMA_VALIDATION_FEATURE_ID = |
| "http://apache.org/xml/features/validation/schema"; |
| |
| protected static final String SCHEMA_FULL_CHECKING_FEATURE_ID = |
| "http://apache.org/xml/features/validation/schema-full-checking"; |
| |
| protected static final String DEFERRED_DOM_FEATURE_ID = |
| "http://apache.org/xml/features/dom/defer-node-expansion"; |
| |
| // default settings |
| |
| protected static final String DEFAULT_PARSER_NAME = "dom.wrappers.Xerces"; |
| |
| protected static final boolean DEFAULT_NAMESPACES = true; |
| |
| protected static final boolean DEFAULT_VALIDATION = false; |
| |
| protected static final boolean DEFAULT_SCHEMA_VALIDATION = false; |
| |
| protected static final boolean DEFAULT_SCHEMA_FULL_CHECKING = false; |
| |
| // Xerces specific feature |
| protected static final boolean DEFAULT_DEFERRED_DOM = true; |
| |
| // |
| // Public methods |
| // |
| |
| /** Performs the actual test. */ |
| public void test(Document doc) { |
| |
| System.out.println("DOM rename Test..."); |
| |
| // getting the first "email" element |
| NodeList elements = doc.getElementsByTagName("email"); |
| Element child = (Element) elements.item(0); |
| Assertion.verify(child != null); |
| Assertion.equals(child.getNodeName(), "email"); |
| |
| // default must be there |
| Attr at = child.getAttributeNode("defaultEmailAttr"); |
| Assertion.verify(at != null); |
| Assertion.equals(at.getValue(), "defaultEmailValue"); |
| Assertion.verify(at.getSpecified() == false); |
| |
| // attach some data |
| child.setUserData("mydata", "yo", this); |
| Assertion.equals((String) child.getUserData("mydata"), "yo"); |
| |
| // renaming an element without a url |
| Element newChild = (Element) doc.renameNode(child, null, "url"); |
| |
| Assertion.equals(newChild.getNodeName(), "url"); |
| Assertion.verify(newChild.getNamespaceURI() == null); |
| |
| // old default must no longer be there |
| Assertion.verify(newChild.hasAttribute("defaultEmailAttr") == false); |
| Assertion.verify(at.getSpecified() == true); |
| |
| // new default must be there |
| at = newChild.getAttributeNode("defaultUrlAttr"); |
| Assertion.verify(at != null); |
| Assertion.equals(at.getValue(), "defaultUrlValue"); |
| Assertion.verify(at.getSpecified() == false); |
| |
| // data must still be there |
| Assertion.equals((String) newChild.getUserData("mydata"), "yo"); |
| // and handler must have been called if new node was created |
| if (newChild != child) { |
| Assertion.verify(lastOperation == UserDataHandler.NODE_RENAMED); |
| Assertion.verify(lastKey == "mydata"); |
| Assertion.equals((String) lastData, "yo"); |
| Assertion.verify(lastSource == child); |
| Assertion.verify(lastDestination == newChild); |
| resetHandlerData(); |
| } |
| |
| // renaming an element with a url |
| Element newChild2 = (Element) doc.renameNode(newChild, "ns1", "foo"); |
| |
| Assertion.equals(newChild2.getNodeName(), "foo"); |
| Assertion.equals(newChild2.getNamespaceURI(), "ns1"); |
| Assertion.verify(newChild2.hasAttribute("defaultUrlAttr") == false); |
| // data must still be there |
| Assertion.equals((String) newChild2.getUserData("mydata"), "yo"); |
| // and handler must have been called if new node was created |
| if (newChild2 != newChild) { |
| Assertion.verify(lastOperation == UserDataHandler.NODE_RENAMED); |
| Assertion.verify(lastKey == "mydata"); |
| Assertion.equals((String) lastData, "yo"); |
| Assertion.verify(lastSource == newChild); |
| Assertion.verify(lastDestination == newChild2); |
| resetHandlerData(); |
| } |
| |
| // getting the second "email" element |
| child = (Element) elements.item(1); |
| Assertion.verify(child != null); |
| Assertion.equals(child.getNodeName(), "email"); |
| |
| // default must be there |
| at = child.getAttributeNode("defaultEmailAttr"); |
| Assertion.verify(at != null); |
| Assertion.equals(at.getValue(), "defaultEmailValue"); |
| Assertion.verify(at.getSpecified() == false); |
| |
| // attach some data |
| at.setUserData("mydata", "yo", this); |
| Assertion.equals((String) at.getUserData("mydata"), "yo"); |
| |
| // renaming an attribute without a url |
| Attr newAt = (Attr) doc.renameNode(at, null, "foo"); |
| Assertion.verify(newAt != null); |
| Assertion.equals(newAt.getNodeName(), "foo"); |
| Assertion.equals(newAt.getNamespaceURI(), null); |
| Assertion.equals(newAt.getValue(), "defaultEmailValue"); |
| Assertion.verify(newAt.getSpecified() == true); |
| Assertion.verify(child.hasAttribute("foo") == true); |
| // default must be back |
| Assertion.verify(child.hasAttribute("defaultEmailAttr") == true); |
| // data must still be there |
| Assertion.equals((String) newAt.getUserData("mydata"), "yo"); |
| // and handler must have been called if new node was created |
| if (newAt != at) { |
| Assertion.verify(lastOperation == UserDataHandler.NODE_RENAMED); |
| Assertion.verify(lastKey == "mydata"); |
| Assertion.equals((String) lastData, "yo"); |
| Assertion.verify(lastSource == at); |
| Assertion.verify(lastDestination == newAt); |
| resetHandlerData(); |
| } |
| |
| // renaming an attribute with a url |
| Attr newAt2 = (Attr) doc.renameNode(newAt, "ns1", "bar"); |
| Assertion.verify(newAt2 != null); |
| Assertion.equals(newAt2.getNodeName(), "bar"); |
| Assertion.equals(newAt2.getNamespaceURI(), "ns1"); |
| Assertion.equals(newAt2.getValue(), "defaultEmailValue"); |
| Assertion.verify(newAt2.getSpecified() == true); |
| Assertion.verify(child.hasAttributeNS("ns1", "bar") == true); |
| // data must still be there |
| Assertion.equals((String) newAt2.getUserData("mydata"), "yo"); |
| // and handler must have been called if new node was created |
| if (newAt2 != newAt) { |
| Assertion.verify(lastOperation == UserDataHandler.NODE_RENAMED); |
| Assertion.verify(lastKey == "mydata"); |
| Assertion.equals((String) lastData, "yo"); |
| Assertion.verify(lastSource == newAt); |
| Assertion.verify(lastDestination == newAt2); |
| resetHandlerData(); |
| } |
| |
| |
| System.out.println("done."); |
| |
| } // test(Document) |
| |
| // UserDataHandler related data |
| short lastOperation = -1; |
| String lastKey; |
| Object lastData; |
| Node lastSource; |
| Node lastDestination; |
| |
| void resetHandlerData() { |
| lastOperation = -1; |
| lastKey = null; |
| lastData = null; |
| lastSource = null; |
| lastDestination = null; |
| } |
| |
| /** |
| * This method is called whenever the node for which this handler is |
| * registered is imported, cloned, or renamed. |
| * @param operation Specifies the type of operation that is being |
| * performed on the node. |
| * @param key Specifies the key for which this handler is being called. |
| * @param data Specifies the data for which this handler is being called. |
| * @param src Specifies the node being cloned, imported, or renamed. This |
| * is <code>null</code> when the node is being deleted. |
| * @param dst Specifies the node newly created if any, or |
| * <code>null</code>. |
| */ |
| public void handle(short operation, String key, Object data, |
| Node src, Node dst) { |
| lastOperation = operation; |
| lastKey = key; |
| lastData = data; |
| lastSource = src; |
| lastDestination = dst; |
| } |
| |
| // |
| // MAIN |
| // |
| |
| /** Main program entry point. */ |
| public static void main(String argv[]) { |
| |
| // is there anything to do? |
| /*if (argv.length == 0) { |
| printUsage(); |
| System.exit(1); |
| } */ |
| |
| |
| // variables |
| Test test = new Test(); |
| ParserWrapper parser = null; |
| boolean namespaces = DEFAULT_NAMESPACES; |
| boolean validation = DEFAULT_VALIDATION; |
| boolean schemaValidation = DEFAULT_SCHEMA_VALIDATION; |
| boolean schemaFullChecking = DEFAULT_SCHEMA_FULL_CHECKING; |
| boolean deferredDom = DEFAULT_DEFERRED_DOM; |
| |
| String inputfile="tests/dom/rename/input.xml"; |
| |
| // process arguments |
| for (int i = 0; i < argv.length; i++) { |
| String arg = argv[i]; |
| if (arg.startsWith("-")) { |
| String option = arg.substring(1); |
| if (option.equals("p")) { |
| // get parser name |
| if (++i == argv.length) { |
| System.err.println("error: Missing argument to -p" |
| + " option."); |
| } |
| String parserName = argv[i]; |
| |
| // create parser |
| try { |
| parser = (ParserWrapper) |
| Class.forName(parserName).newInstance(); |
| } |
| catch (Exception e) { |
| parser = null; |
| System.err.println("error: Unable to instantiate " |
| + "parser (" + parserName + ")"); |
| } |
| continue; |
| } |
| if (option.equalsIgnoreCase("n")) { |
| namespaces = option.equals("n"); |
| continue; |
| } |
| if (option.equalsIgnoreCase("v")) { |
| validation = option.equals("v"); |
| continue; |
| } |
| if (option.equalsIgnoreCase("s")) { |
| schemaValidation = option.equals("s"); |
| continue; |
| } |
| if (option.equalsIgnoreCase("f")) { |
| schemaFullChecking = option.equals("f"); |
| continue; |
| } |
| if (option.equalsIgnoreCase("d")) { |
| deferredDom = option.equals("d"); |
| continue; |
| } |
| if (option.equals("h")) { |
| printUsage(); |
| continue; |
| } |
| } |
| } |
| |
| // use default parser? |
| if (parser == null) { |
| |
| // create parser |
| try { |
| parser = (ParserWrapper) |
| Class.forName(DEFAULT_PARSER_NAME).newInstance(); |
| } |
| catch (Exception e) { |
| System.err.println("error: Unable to instantiate parser (" |
| + DEFAULT_PARSER_NAME + ")"); |
| System.exit(1); |
| } |
| } |
| |
| // set parser features |
| try { |
| parser.setFeature(NAMESPACES_FEATURE_ID, namespaces); |
| } |
| catch (SAXException e) { |
| System.err.println("warning: Parser does not support feature (" |
| + NAMESPACES_FEATURE_ID + ")"); |
| } |
| try { |
| parser.setFeature(VALIDATION_FEATURE_ID, validation); |
| } |
| catch (SAXException e) { |
| System.err.println("warning: Parser does not support feature (" |
| + VALIDATION_FEATURE_ID + ")"); |
| } |
| try { |
| parser.setFeature(SCHEMA_VALIDATION_FEATURE_ID, |
| schemaValidation); |
| } |
| catch (SAXException e) { |
| System.err.println("warning: Parser does not support feature (" |
| + SCHEMA_VALIDATION_FEATURE_ID + ")"); |
| } |
| try { |
| parser.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, |
| schemaFullChecking); |
| } |
| catch (SAXException e) { |
| System.err.println("warning: Parser does not support feature (" |
| + SCHEMA_FULL_CHECKING_FEATURE_ID + ")"); |
| } |
| |
| if (parser instanceof dom.wrappers.Xerces) { |
| try { |
| parser.setFeature(DEFERRED_DOM_FEATURE_ID, |
| deferredDom); |
| } |
| catch (SAXException e) { |
| System.err.println("warning: Parser does not support " + |
| "feature (" + |
| DEFERRED_DOM_FEATURE_ID + ")"); |
| } |
| } |
| |
| Document document = null; |
| // parse file |
| try { |
| document = parser.parse(inputfile); |
| } |
| catch (SAXParseException e) { |
| // ignore |
| } |
| catch (Exception e) { |
| System.err.println("error: Parse error occurred - " + |
| e.getMessage()); |
| Exception se = e; |
| if (e instanceof SAXException) { |
| se = ((SAXException)e).getException(); |
| } |
| if (se != null) |
| se.printStackTrace(System.err); |
| else |
| e.printStackTrace(System.err); |
| |
| return; |
| } |
| |
| test.test(document); |
| |
| |
| } // main(String[]) |
| |
| // |
| // Private static methods |
| // |
| |
| /** Prints the usage. */ |
| private static void printUsage() { |
| |
| System.err.println("usage: java dom.ids.Test (options) " + |
| "...data/personal.xml"); |
| System.err.println(); |
| |
| System.err.println("options:"); |
| System.err.println(" -p name Select parser by name."); |
| System.err.println(" -d | -D Turn on/off (Xerces) deferred DOM."); |
| System.err.println(" -n | -N Turn on/off namespace processing."); |
| System.err.println(" -v | -V Turn on/off validation."); |
| System.err.println(" -s | -S Turn on/off Schema validation " + |
| "support."); |
| System.err.println(" NOTE: Not supported by all parsers."); |
| System.err.println(" -f | -F Turn on/off Schema full checking."); |
| System.err.println(" NOTE: Requires use of -s and not " + |
| "supported by all parsers."); |
| System.err.println(" -h This help screen."); |
| System.err.println(); |
| |
| System.err.println("defaults:"); |
| System.err.println(" Parser: " + DEFAULT_PARSER_NAME); |
| System.err.println(" Xerces Deferred DOM: " + |
| (DEFAULT_DEFERRED_DOM ? "on" : "off")); |
| System.err.println(" Namespaces: " + |
| (DEFAULT_NAMESPACES ? "on" : "off")); |
| System.err.println(" Validation: " + |
| (DEFAULT_VALIDATION ? "on" : "off")); |
| System.err.println(" Schema: " + |
| (DEFAULT_SCHEMA_VALIDATION ? "on" : "off")); |
| System.err.println(" Schema full checking: " + |
| (DEFAULT_SCHEMA_FULL_CHECKING ? "on" : "off")); |
| |
| } // printUsage() |
| |
| } // class Test |
