From dd45e938564249a5e6897bd92dd29808d8990868 Mon Sep 17 00:00:00 2001
From: rudolf <rudolf@d688527b-c9ab-4aba-bd8d-4036d912da1d>
Date: Fri, 24 Oct 2003 08:34:56 +0000
Subject: MOA-ID version 1.1 (initial)

git-svn-id: https://joinup.ec.europa.eu/svn/moa-idspss/trunk@19 d688527b-c9ab-4aba-bd8d-4036d912da1d
---
 .../moa/id/proxy/builder/DOMTreeCompare.java       | 462 +++++++++++++++++++++
 1 file changed, 462 insertions(+)
 create mode 100644 id.server/src/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java

(limited to 'id.server/src/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java')

diff --git a/id.server/src/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java b/id.server/src/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java
new file mode 100644
index 000000000..aec14ce1c
--- /dev/null
+++ b/id.server/src/test/at/gv/egovernment/moa/id/proxy/builder/DOMTreeCompare.java
@@ -0,0 +1,462 @@
+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;
+	}
+	
+}
-- 
cgit v1.2.3