diff options
Diffstat (limited to 'id/server/idserverlib/src/test/java/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java')
| -rw-r--r-- | id/server/idserverlib/src/test/java/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java | 477 |
1 files changed, 477 insertions, 0 deletions
diff --git a/id/server/idserverlib/src/test/java/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java b/id/server/idserverlib/src/test/java/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java new file mode 100644 index 000000000..6e10a06d8 --- /dev/null +++ b/id/server/idserverlib/src/test/java/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java @@ -0,0 +1,477 @@ +/* +* Copyright 2003 Federal Chancellery Austria +* +* 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 test.at.gv.egovernment.moa.id.proxy.builder; + +import java.io.PrintStream; +import java.util.ArrayList; + +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.w3c.dom.Text; + +import at.gv.egovernment.moa.util.Base64Utils; + +/** + * @author Administrator + * + * To change this generated comment edit the template variable "typecomment": + * Window>Preferences>Java>Templates. + * To enable and disable the creation of type comments go to + * Window>Preferences>Java>Code Generation. + */ +public class DOMTreeCompare { + + boolean debug = true; + + private static PrintStream Log = null; + + static + { + Log = System.out; + } + + public boolean compareElements(Element root1, Element root2) + { + //Log.println("----- Compare Elements:"+root1.getNodeName()+" "+root2.getNodeName()); + filterTree(root1); + filterTree(root2); + return compareNodes(root1,root2,0,"root/",false); + } + + private boolean compareNodes(Node n1, Node n2, int level,String path,boolean attribute) + { + /*try { + Log.println(DOMUtils.serializeNode(n1)); + } + catch(Exception e) + { + e.printStackTrace(); + }*/ + boolean equal = false; + //Log.println("----- Compare Node "+level+":"+n1+" "+n2); + //Log.println("----- Compare Node "+level+":"+n1.getNodeName()+" "+n2.getNodeName()); + //Log.println("----- Checking:"+path+getPathString(n1)); + NodeList nl1 = n1.getChildNodes(); + NodeList nl2 = n2.getChildNodes(); + + int size1 = nl1.getLength(); + int size2 = nl2.getLength(); + + if(debug)display_one(n1); + if(debug)display_one(n2); + + + if(debug) + if(n1.getNodeName().equals("Base64Content") && n2.getNodeName().equals("Base64Content")) + { + try { + Log.println("CONT:"+new String(Base64Utils.decode(strip(n1.getChildNodes().item(0).getNodeValue()),false))); + Log.println("CONT:"+new String(Base64Utils.decode(strip(n2.getChildNodes().item(0).getNodeValue()),false))); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + if(size1 != size2) + { + Log.println("----- Anzahl der Kinder nicht gleich:"+path+getPathString(n1)+":"+getPathString(n2)); + return false; + } + + equal = compareNodeExact(n1,n2,level,path+getPathString(n1)+"/"); + if(!equal) + { + Log.println("----- Knoten sind nicht identisch:"+path+getPathString(n1)); + return false; + } + + if(n1.hasAttributes() || n2.hasAttributes()) + { + equal = compareNodeAttriubtes(n1,n2,level+1,path+getPathString(n1)+"/(a)"); + if(!equal) + { + Log.println("----- Attribute stimmen nicht überein:"+path+getPathString(n1)); + return false; + } + } + if(size1==0) + { + return true; + } + + for(int counter=0;counter<size1;counter++) + { + boolean found = false; + Node comp_n1 = nl1.item(counter); + + //if(comp_n1==null) return false; + + Node comp_n2 = null; + size2 = nl2.getLength(); + for(int counter2=0;counter2<size2;counter2++) + { + comp_n2 = nl2.item(counter2); + + /*equal = compareNodeExact(comp_n1,comp_n2,level+1); + if(equal) return false;*/ + //Log.println("COMP_N1:"+comp_n1); + //Log.println("COMP_N2:"+comp_n2); + equal = compareNodes(comp_n1,comp_n2,level+1,path+getPathString(comp_n1)+"/",false); + if(equal) + { + n2.removeChild(comp_n2); + counter2=size2; + nl2 = n2.getChildNodes(); + size2 = nl2.getLength(); + } + + } + + if(!equal) + { + Log.println("----- Keine Übereinstimmung gefunden:"+path+getPathString(comp_n1)); + return false; + } + } + return true; + } + + private boolean compareNodeExact(Node n1,Node n2,int level,String path) + { + if(n1.getNodeType() == Node.TEXT_NODE) + { + Text textnode = (Text)n1; + /*Log.println("----- *****"+textnode.getNodeName()); + Log.println("----- *****"+textnode.getParentNode().getNodeName()); + Log.println("----- *****"+textnode.getNodeValue());*/ + } + + //Log.println("----- Checking:"+path); + String n1_name = n1.getNodeName(); + String n2_name = n2.getNodeName(); + /*Log.println("----- !!!!!"+n1.getNodeName()); + Log.println("----- !!!!!"+n1.getNodeValue()); + Log.println("----- !!!!!"+n1.getLocalName()); + Log.println("----- !!!!!"+n1.getPrefix()); + Log.println("----- !!!!!"+n1.getNextSibling()); + Log.println("----- !!!!!"+n1.getPreviousSibling());*/ + + //Log.println("----- Compare Node "+level+":"+n1_name+" "+n2_name); + if(!((n1_name==null && n2_name==null) || + (n1_name!=null && n2_name!=null && n1_name.equals(n2_name)))) + { + Log.println("----- Name stimmt nicht überein:"+path); + return false; + } + + //Log.println("----- Compare Node "+level+":"+n1.getNodeType()+" "+n2.getNodeType()); + if(n1.getNodeType() != n2.getNodeType()) + { + Log.println("----- Knotentyp stimmt nicht überein:"+path); + return false; + } + + String n1_ns = n1.getPrefix(); + String n2_ns = n2.getPrefix(); + //Log.println("----- Compare Node "+level+":"+n1_ns+" "+n2_ns); + if(!((n1_ns==null && n2_ns==null) || + (n1_ns!=null && n2_ns!=null && n1_ns.equals(n2_ns)))) + { + Log.println("----- NameSpace stimmt nicht überein:"+path); + return false; + } + + String n1_value = n1.getNodeValue(); + String n2_value = n2.getNodeValue(); + + boolean special = false; + special = specialValues(n1_value,n2_value,path); + if(special) return true; + + //Log.println("----- Compare Node "+level+":"+n1_value+" "+n2_value); + if(!((n1_value==null && n2_value==null) || + (n1_value!=null && n2_value!=null && n1_value.equals(n2_value)))) + { + Log.println("----- Wert stimmt nicht überein:"+path); + Log.println("----- Value1:\n"+n1_value); + Log.println("----- Value2:\n"+n2_value); + return false; + } + + + return true; + } + + private boolean compareNodeAttriubtesWithoutSize(Node n1, Node n2, int level,String path) + { + return true; + } + + private boolean compareNodeAttriubtes(Node n1, Node n2, int level,String path) + { + //Log.println("----- Compare NodeAttributes "+level+":"+n1.getNodeName()+" "+n2.getNodeName()); + Element n1elem = (Element)n1; + Element n2elem = (Element)n2; + + NamedNodeMap nnm1 = n1.getAttributes(); + NamedNodeMap nnm2 = n2.getAttributes(); + + int size1 = 0; + int size2 = 0; + + boolean specialattrs = specialAttributesSize(path); + + if(!specialattrs) + { + + if(nnm1==null && nnm2==null) return true; + if(nnm1==null || nnm2==null) + { + Log.println("----- Anzahl der Attribute nicht gleich:"+path+":"+getPathString(n1)); + return false; + } + size1 = nnm1.getLength(); + size2 = nnm2.getLength(); + + if(size1 != size2) + { + Log.println("----- Anzahl der Attribute nicht gleich:"+path+":"+getPathString(n1)); + return false; + } + + } + else + { + return compareNodeAttriubtesWithoutSize(n1,n2,level,path); + } + + for(int counter=0;counter<size1;counter++) + { + Node attribute_node1 = nnm1.item(counter); + Node attribute_node2 = nnm2.item(counter); + + String attr1_name = attribute_node1.getNodeName(); + String attr2_name = attribute_node2.getNodeName(); + + String value1 = n1elem.getAttribute(attr1_name); + String value2 = n2elem.getAttribute(attr2_name); + + boolean special = false; + + special = specialAttributes(path,attr1_name,value1,attr2_name,value2); + if(special) + { + return special; + } + + if(!value1.equals(value2)) + { + Log.println("----- Keine Übereinstimmung gefunden:"+path+getPathString(n1)); + return false; + } + } + + return true; + } + + private boolean checkNode(Node base,String name) + { + if(base.getNodeName().equals(name)) + { + return true; + } + + NodeList children = base.getChildNodes(); + int size = children.getLength(); + for(int counter=0;counter<size;counter++) + { + boolean found = checkNode(children.item(counter),name); + if(found) return true; + } + return false; + } + + private void display_one(Node base) + { + int att_size=0; + if(base.getAttributes()!=null) + { + att_size=base.getAttributes().getLength(); + } + if(base.getNodeName().equals("#text")) + Log.println(base.getNodeName()+base.getChildNodes().getLength()+":"+att_size+" ("+base.getNodeValue()+")"); + else + Log.println(base.getNodeName()+base.getChildNodes().getLength()+":"+att_size); + } + + private void display(Node base) + { + display(base,1); + } + + private void display(Node base,int level) + { + String spacer = ""; + for(int counter=0;counter<level;counter++) + { + spacer+=" "; + } + + int att_size=0; + if(base.getAttributes()!=null) + { + att_size=base.getAttributes().getLength(); + } + if(base.getNodeName().equals("#text")) + Log.println(spacer+base.getNodeName()+base.getChildNodes().getLength()+":"+att_size+" ("+base.getNodeValue()+")"); + else + Log.println(spacer+base.getNodeName()+base.getChildNodes().getLength()+":"+att_size); + + NodeList children = base.getChildNodes(); + int size = children.getLength(); + for(int counter=0;counter<size;counter++) + { + display(children.item(counter),level+1); + } + } + + private void filterTree(Node base) + { + ArrayList removeList = new ArrayList(); + + NodeList children = base.getChildNodes(); + int size = children.getLength(); + for(int counter=0;counter<size;counter++) + { + Node child1 = children.item(counter); + if(child1.getNodeType() == Node.TEXT_NODE && child1.getNodeValue().trim().equals("")) + { + removeList.add(child1); + } + } + + size = removeList.size(); + for(int counter=0;counter<size;counter++) + { + base.removeChild((Node)removeList.get(counter)); + } + + children = base.getChildNodes(); + size = children.getLength(); + for(int counter=0;counter<size;counter++) + { + filterTree(children.item(counter)); + } + + } + + private String getPathString(Node n) + { + if(n.getNodeType()==Node.TEXT_NODE) + { + return n.getParentNode().getNodeName()+"(text)"; + } + else + { + return n.getNodeName(); + } + + } + + public boolean specialAttributes(String path,String attr1_name,String value1,String attr2_name,String value2) + { + //if(value1.startsWith("reference-") && value2.startsWith("reference-")) return true; + //if(value1.startsWith("signature-") && value2.startsWith("signature-")) return true; + + return false; + } + + public boolean specialAttributesSize(String path) + { + //if(path.endsWith("/xsl:template/(a)")) return true; + return false; + } + + public boolean specialValues(String value1,String value2,String path) + { + + //Log.println(path); + /*if(ignoreSignatureValue) + { + if(path.endsWith("/dsig:SignatureValue(text)/")) + { + return true; + } + } + else + { + if(path.endsWith("/dsig:SignatureValue(text)/")) + { + String stripped_1 = strip(value1); + String stripped_2 = strip(value2); + return stripped_1.equals(stripped_2); + } + }*/ + + return false; + } + + private String strip(String input) + { + String output = replaceStringAll(input," ",""); + output = replaceStringAll(output,"\n",""); + output = replaceStringAll(output,"\r",""); + return output; + } + + private static String replaceStringAll( + String input, + String oldPart, + String newPart) + { + + String erg = null; + + int pos = input.indexOf(oldPart); + if(pos==-1) return input; + + while(true) + { + + //First Part + pos = input.indexOf(oldPart); + if(pos==-1) break; + erg = input.substring(0, pos); + + //Insert new Part + erg += newPart; + + //insert REST + erg + += input.substring( + input.indexOf(oldPart) + oldPart.length(), + input.length()); + + input = erg; + } + return erg; + } + +} |