| /* |
| * Created on Mar 17, 2003 |
| * |
| * To change this generated comment go to |
| * Window>Preferences>Java>Code Generation>Code and Comments |
| */ |
| package org.eclipse.jst.j2ee.archive.test; |
| |
| import java.util.HashSet; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CharacterData; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.DocumentType; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| import org.xml.sax.EntityResolver; |
| |
| /** |
| * THE MASTER COPY of this class is in com.ibm.etools.commontests |
| * Please update the copy in commontests and then copy this class to |
| * where you need it if you are looking at a different copy |
| * |
| * @author jsholl |
| * |
| * To change this generated comment go to |
| * Window>Preferences>Java>Code Generation>Code and Comments |
| */ |
| public class DomComparitor { |
| private static EntityResolver entityResolver; |
| private static HashSet attributeList; |
| // TODO replace this with non xerces |
| // public static String compareDoms(InputSource source1, InputSource source2, HashSet ignorableAtts) throws Exception { |
| // attributeList = ignorableAtts; |
| // DOMParser parser = new DOMParser(); |
| // if (entityResolver == null) { |
| // parser.setEntityResolver(new EntityResolver() { |
| // public InputSource resolveEntity(String arg0, String arg1) throws SAXException, IOException { |
| // return null; |
| // } |
| // |
| // }); |
| // } else { |
| // parser.setEntityResolver(entityResolver); |
| // } |
| // parser.parse(source1); |
| // Document doc1 = parser.getDocument(); |
| // parser.parse(source2); |
| // Document doc2 = parser.getDocument(); |
| // return compareNodes(doc1, doc2); |
| // } |
| |
| // public static String compareDoms(InputSource source1, InputSource source2) throws Exception { |
| // return compareDoms(source1, source2, null); |
| // } |
| |
| |
| public static String compareNodes(Node node1, Node node2) throws Exception { |
| // System.out.println("checking A:" + node1); |
| // System.out.println("checking B:" + node2); |
| // System.out.println("nodeType=" + node1.getNodeType()); |
| // System.out.println("getNodeName=" + node1.getNodeName()); |
| // System.out.println("getNodeValue=" + node1.getNodeValue()); |
| |
| //Generic Node Testing |
| if (node1 == null && node2 == null) |
| return null; |
| else if ((node1 != null && node2 == null) || node1 == null && node2 != null) |
| return nullNodeEncountered(node1, node2); |
| else if (node1.getNodeType() != node2.getNodeType()) { |
| return mismatch("Node.getNodeType() " + node1.getNodeType() + " " + node2.getNodeType(), node1, node2); |
| } else if (node1.getNodeName() != node2.getNodeName()) { |
| return mismatch("Node.getNodeName() <" + node1.getNodeName() + "> <" + node2.getNodeName() + ">", node1, node2); |
| } else if (!(node1.getNodeValue() == null && node2.getNodeValue() == null)) { |
| if (node1.getNodeValue() == null) { |
| return mismatch("Node.getNodeValue() node A is null", node1, node2); |
| } else if (node2.getNodeValue() == null) { |
| return mismatch("Node.getNodeValue() node B is null", node1, node2); |
| } else if (!node1.getNodeValue().equals(node2.getNodeValue())) { |
| return mismatch("Node.getNodeValue() <" + node1.getNodeValue() + "> <" + node2.getNodeValue() + ">", node1, node2); |
| } |
| } else if (node1.hasAttributes() != node2.hasAttributes()) { |
| return mismatch("Node.hasAttributes() " + node1.hasAttributes() + " " + node2.hasAttributes(), node1, node2); |
| } else if (node1.hasChildNodes() != node2.hasChildNodes()) { |
| return mismatch("Node.hasChildNodes() " + node1.hasChildNodes() + " " + node2.hasChildNodes(), node1, node2); |
| } |
| //TODO strengthen node comparisons as necessary |
| //Specialized Node Testing |
| switch (node1.getNodeType()) { |
| case Node.TEXT_NODE : |
| case Node.CDATA_SECTION_NODE : |
| CharacterData cdata1 = (CharacterData) node1; |
| CharacterData cdata2 = (CharacterData) node2; |
| if (!cdata1.getData().equals(cdata2.getData())) { |
| return mismatch("CharacterData.getData() " + cdata1.getData() + " " + cdata2.getData(), node1, node2); |
| } |
| break; |
| case Node.ATTRIBUTE_NODE : |
| Attr attr1 = (Attr) node1; |
| Attr attr2 = (Attr) node2; |
| if (!attr1.getName().equals(attr2.getName())) { |
| return mismatch("Attr.getName() " + attr1.getName() + " " + attr2.getName(), node1, node2); |
| } |
| else if( attributeList != null && !attributeList.contains(attr1.getName()) && !attributeList.contains(attr2.getName())) { |
| if (!attr1.getValue().equals(attr2.getValue())) { |
| return mismatch("Attr.getValue() " + attr1.getValue() + " " + attr2.getValue(), node1, node2); |
| } else if (attr1.getSpecified() != attr2.getSpecified()) { |
| return mismatch("Attr.getSpecified() " + attr1.getSpecified() + " " + attr2.getSpecified(), node1, node2); |
| } |
| } |
| break; |
| case Node.DOCUMENT_NODE : |
| Document doc1 = (Document)node1; |
| Document doc2 = (Document)node2; |
| String result = compareNodes(doc1.getDoctype(), doc2.getDoctype()); |
| if(result != null){ |
| return result; |
| } |
| break; |
| case Node.DOCUMENT_TYPE_NODE: |
| DocumentType docType1 = (DocumentType)node1; |
| DocumentType docType2 = (DocumentType)node2; |
| if(!docType1.getPublicId().equals(docType2.getPublicId())){ |
| return mismatch("DocumentType.getPublicId() "+docType1.getPublicId()+ " "+docType2.getPublicId(), node1, node2); |
| } |
| break; |
| case Node.PROCESSING_INSTRUCTION_NODE : |
| ProcessingInstruction pInst1 = (ProcessingInstruction)node1; |
| ProcessingInstruction pInst2 = (ProcessingInstruction)node2; |
| //System.out.println("ProcessingInstruction todo"); |
| break; |
| case Node.DOCUMENT_FRAGMENT_NODE : |
| DocumentFragment frag1 = (DocumentFragment)node1; |
| DocumentFragment frag2 = (DocumentFragment)node2; |
| //System.out.println("DocumentFragment todo"); |
| break; |
| |
| case Node.ELEMENT_NODE : |
| case Node.COMMENT_NODE : |
| case Node.ENTITY_NODE : |
| case Node.NOTATION_NODE : |
| break; |
| |
| } |
| |
| //Recursion |
| NamedNodeMap attributes1 = node1.getAttributes(); |
| NamedNodeMap attributes2 = node2.getAttributes(); |
| |
| if (attributes1 != null && attributes2 != null) { |
| if (attributes1.getLength() != attributes2.getLength()) { |
| return mismatch("getAttributes().getLength() " + attributes1.getLength() + " " + attributes2.getLength(), node1, node2); |
| } |
| for (int i = 0; i < attributes1.getLength(); i++) { |
| Attr attr1 = (Attr) attributes1.item(i); |
| Attr attr2 = (Attr) attributes2.item(i); |
| if(!attr1.getName().equals(attr2.getName())){ |
| return mismatch("Attr.getName() " + attr1.getName() + " " + attr2.getName(), attr1, attr2); |
| } |
| if(attributeList != null && !attributeList.contains(attr1.getName()) && !attributeList.contains(attr2.getName())) { |
| String results = compareNodes(attr1, attr2); |
| if (null != results) { |
| return results; |
| } |
| } |
| } |
| |
| } else if (attributes1 != null || attributes2 != null) { |
| return mismatch("getAttributes() null", node1, node2); |
| } |
| |
| NodeList children1 = node1.getChildNodes(); |
| NodeList children2 = node2.getChildNodes(); |
| |
| // if (children1.getLength() != children2.getLength()) { |
| // return mismatch("getChildNodes().getLength() "+children1.getLength()+" "+children2.getLength(), node1, node2); |
| // } |
| |
| int count1 = 0; |
| int count2 = 0; |
| |
| //compare all children, skipping empty text nodes |
| while (count1 < children1.getLength() && count2 < children2.getLength()) { |
| Node child1 = children1.item(count1); |
| Node child2 = children2.item(count2); |
| if (child1.getNodeType() != child2.getNodeType()) { |
| if (child1.getNodeType() == Node.TEXT_NODE && (child1.getNodeValue() == null || child1.getNodeValue().trim().equals(""))) { |
| count1++; |
| continue; |
| } else if (child2.getNodeType() == Node.TEXT_NODE && (child2.getNodeValue() != null || child2.getNodeValue().trim().equals(""))) { |
| count2++; |
| continue; |
| } |
| } |
| count1++; |
| count2++; |
| String results = compareNodes(child1, child2); |
| if (null != results) { |
| return results; |
| } |
| } |
| //TODO there must be a way to tell the parser to ignore whitespace. |
| //be sure skip any empty text nodes at the end |
| while (count1 < children1.getLength()) { |
| Node child1 = children1.item(count1); |
| if (child1.getNodeType() == Node.TEXT_NODE && child1.getNodeValue() == null || child1.getNodeValue().trim().equals("")) { |
| count1++; |
| continue; |
| } |
| return nodeNotCompared(child1); |
| } |
| |
| while (count2 < children2.getLength()) { |
| Node child2 = children2.item(count2); |
| if (child2.getNodeType() == Node.TEXT_NODE && child2.getNodeValue() == null || child2.getNodeValue().trim().equals("")) { |
| count2++; |
| continue; |
| } |
| return nodeNotCompared(child2); |
| } |
| |
| // for (int i = 0; i < children1.getLength(); i++) { |
| // Node child1 = children1.item(i); |
| // Node child2 = children2.item(i); |
| // } |
| |
| return null; |
| } |
| |
| |
| public static String nullNodeEncountered(Node node1, Node node2) { |
| String message = "Null node encountered"; |
| Node nonNullNode = node1 == null ? node2 : node1; |
| char source = node1 == null ? 'B' : 'A'; |
| while (nonNullNode != null) { |
| message += source + nonNullNode.getNodeName() + "\n"; |
| nonNullNode = nonNullNode.getParentNode(); |
| } |
| return message; |
| |
| |
| } |
| |
| public static String nodeNotCompared(Node node) { |
| String message = "Node node compared:"; |
| while (node != null) { |
| message += node.getNodeName() + "\n"; |
| node = node.getParentNode(); |
| } |
| |
| return message; |
| } |
| |
| public static String mismatch(String mismatchtype, Node node1, Node node2) throws Exception { |
| String message = "Nodes A and B do not match because of node." + mismatchtype + "\n"; |
| while (node1 != null && node2 != null) { |
| message += "A:" + node1.getNodeName() + "\n"; |
| message += "B:" + node2.getNodeName() + "\n"; |
| node1 = node1.getParentNode(); |
| node2 = node2.getParentNode(); |
| } |
| |
| return message; |
| } |
| |
| public static void main(String[] args) { |
| } |
| /** |
| * @return |
| */ |
| public static EntityResolver getEntityResolver() { |
| return entityResolver; |
| } |
| |
| /** |
| * @param resolver |
| */ |
| public static void setEntityResolver(EntityResolver resolver) { |
| entityResolver = resolver; |
| } |
| |
| } |
