org.eclipse.epf.library.tests/src/org/eclipse/epf/library/tester/OutputDiffAnalyzor.java - epf/org.eclipse.epf.tests - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 2006 IBM Corporation and others.
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v1.0
 // which accompanies this distribution, and is available at
 // http://www.eclipse.org/legal/epl-v10.html
 //
 // Contributors:
 // IBM Corporation - initial implementation
 //------------------------------------------------------------------------------
 package org.eclipse.epf.library.tester;

 import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.Stack;

 import org.eclipse.epf.common.utils.XMLUtil;
 import org.eclipse.epf.library.tester.iface.TestTracer;
 import org.eclipse.epf.uma.MethodElement;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 /**
  * Class to analyze the differneces between two library tester outputs
  *
  * @author Weiping Lu
  * @since 1.0
  *
  */
 public class OutputDiffAnalyzor {

 	private boolean localDebug = false;
 	private TestTracer tracer;
 	private boolean needToAnalyze = true;
 	private File f1;
 	private File f2;
 	private Document d1;
 	private Document d2;
 	private int diffCount = 0;
 	private int elemComparedCount = 0;

 	private static boolean excludeGuidFromName = true;
 	//May want to use feature classes directly instead of names later
 	private static String[] excludedFeatures = {
 		"guid",
 		"changeDate"
 	};

 	private static Set excludedFeatureSet = new HashSet();

 	static {
 		for (int i=0; i<excludedFeatures.length; i++) {
 			excludedFeatureSet.add(excludedFeatures[i]);
 		}
 	}

 	public OutputDiffAnalyzor(TestTracer t, Document d1, Document d2, File f1, File f2) {
 		tracer = t;
 		this.f1 = f1;
 		this.f2 = f2;
 		this.d1 = d1 == null ? getDocument(f1) : d1;
 		this.d2 = d2 == null ? getDocument(f2) : d2;
 	}

 	private Document getDocument(File file) {
 		if (file.exists()) {
 			try {
 				return XMLUtil.loadXml(file);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 		return null;
 	}

 	private void trace(String line) {
 		tracer.trace(line);
 	}

 	private void analyze() {
 		trace("OutputDiffAnalyzor.analyze ->");
 		trace("f1: " + f1.getAbsolutePath());
 		trace("f2: " + f2.getAbsolutePath());
 		trace("");
 		analyze_();
 		trace("OutputDiffAnalyzor.analyze <-");
 	}

 	private void analyze_() {
 		if (! needToAnalyze) {
 			trace("no need to analyse");
 			return;
 		}
 		compareRoot(d1.getDocumentElement(), d2.getDocumentElement());
 		needToAnalyze = false;
 	}

 //	Top entry for method element comparison
 	public void compareRoot(Element root1,  Element root2) {
 		diffCount = 0;
 		elemComparedCount = 1;
 		trace("");
 		trace("compareRoot -> ");

 		List elementList1 = collectElements(root1.getChildNodes());
 		List elementList2 = collectElements(root2.getChildNodes());
 		int sz1 = elementList1.size();
 		int sz2 = elementList2.size();

 		if (sz1 != sz2) {
 			String msg = "root child elements: sz1 != sz2 -> " + Integer.toString(sz1) + " != " + Integer.toString(sz2);
 			logDiff(msg, root1, root2);
 		}

 		int sz = sz1 < sz2 ? sz1 : sz2;
 		for (int i=0; i<sz; i++) {
 			compare((Element) elementList1.get(i), (Element) elementList2.get(i));
 		}

 		trace("compareRoot <- diffs: " + diffCount + ", elements: " + elemComparedCount + "\n");
 	}

 	private List collectElements(NodeList nodeList) {
 		List elements = new ArrayList();
 		for (int i=0; i<nodeList.getLength(); i++) {
 			Node node = nodeList.item(i);
 			if (node instanceof Element) {
 				elements.add(node);
 			}
 		}
 		return elements;
 	}

 	private void compare(Element node1,  Element node2) {
 		trace("compare -> ");
 		compareInner(node1, node2);
 		trace("compare <- ");
 	}

 	private void compareInner(Element node1,  Element node2) {
 		elemComparedCount++;
 		if (localDebug) {
 			trace("compareInner, node1: " + outputString(node1));
 			trace("compareInner, node2: " + outputString(node1));
 			trace("");
 		}

 		attributeEquals(node1, node2);

 		List elementList1 = collectElements(node1.getChildNodes());
 		List elementList2 = collectElements(node2.getChildNodes());
 		int sz1 = elementList1.size();
 		int sz2 = elementList2.size();

 		if (sz1 != sz2) {
 			String msg = "Child elements: sz1 != sz2 -> " + Integer.toString(sz1) + " != " + Integer.toString(sz2);
 			logDiff(msg, node1, node2);
 		}

 		int sz = sz1 < sz2 ? sz1 : sz2;
 		for (int i=0; i<sz; i++) {
 			compareInner((Element) elementList1.get(i), (Element) elementList2.get(i));
 		}
 	}

 	private boolean attributeEquals(Element node1, Element node2) {
 		boolean ret = true;

 		NamedNodeMap atts1 = node1.getAttributes();
 		NamedNodeMap atts2 = node2.getAttributes();
 		int sz1 = atts1.getLength();
 		int sz2 = atts2.getLength();
 		if (sz1 != sz2) {
 			logDiff("Attributes: sz1 != sz2", node1, node2);
 			ret = false;
 		}
 		int sz = sz1 < sz2 ? sz1 : sz2;
 		for (int i=0; i<sz; i++) {
 			String attName = atts1.item(i).getNodeName();
 			if (excludedFeatureSet.contains(attName)) {
 				continue;
 			}
 			String val1 = node1.getAttribute(attName);
 			String val2 = node2.getAttribute(attName);
 			if (attName.equals("name") && excludeGuidFromName) {
 				int ix = val1.indexOf(",");
 				if (ix > 0) {
 					val1 = val1.substring(0, ix);
 				}
 				ix = val2.indexOf(",");
 				if (ix > 0) {
 					val2 = val2.substring(0, ix);
 				}
 			}
 			if (! valueEquals(val1, val2)) {
 				String msg = attName + " values not the same!";
 				logDiff(msg, node1, node2, val1, val2);
 			}
 		}

 		return ret;
 	}

 	private boolean valueEquals(Object val1, Object val2) {
 		if (val1 == null) {
 			val1 = "";
 		}

 		if (val2 == null) {
 			val2 = "";
 		}

 		if (val1 instanceof String) {
 			String str1 = (String) val1;
 			String str2 = (String) val2;
 			return str1.equals(str2);
 		}

 		return false;
 	}


 	private void logDiff(String msg, Element node1, Element node2, Object val1, Object val2) {
 		log(msg, node1, node2, true);
 		String prompt = getDiffPrompt();
 		trace(prompt + "val1: " + val1);
 		trace(prompt + "val2: " + val2);
 		trace("");
 	}

 	private int incDiffCount() {
 		return ++diffCount;
 	}

 	private String getDiffPrompt() {
 		return "D_" + diffCount + "> ";
 	}

 	private void logDiff(String msg, Element node1, Element node2) {
 		log(msg, node1, node2, true);
 		trace("");
 	}

 	private void log(String msg, Element node1, Element node2, boolean diff) {
 		if (diff) {
 			incDiffCount();
 		}
 		String prompt = diff ? getDiffPrompt() : "Warning> ";
 		//trace(prompt + "path: " + pathString(node1));
 		trace(prompt + "msg: " + msg);
 		trace(prompt + "node1: " + outputString(node1));
 		trace(prompt + "node2: " + outputString(node2));
 	}

 	private String pathString(Element node) {
 		Stack paths = new Stack();
 		Node currNode = node;
 		while (currNode != null && currNode instanceof Element) {
 			String name = ((Element) currNode).getAttribute("name");
 			paths.push(name);
 			currNode = currNode.getParentNode();
 		}
 		String ret = "";
 		while(! paths.isEmpty()) {
 			ret += "/" + paths.pop();
 		}
 		return ret;
 	}

 	public boolean compare() {
 		analyze();
 		return true;
 	}

 	private String outputString(Element node) {
 		if (node == null) {
 			return null;
 		}
 		String type = node.getAttribute("type");
 		return type + ": " + pathString(node);
 	}

 	public int getDiffCount() {
 		return diffCount;
 	}

 	public int getElemComparedCount() {
 		return elemComparedCount;
 	}


 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 2006 IBM Corporation and others.
	// All rights reserved. This program and the accompanying materials
	// are made available under the terms of the Eclipse Public License v1.0
	// which accompanies this distribution, and is available at
	// http://www.eclipse.org/legal/epl-v10.html
	//
	// Contributors:
	// IBM Corporation - initial implementation
	//------------------------------------------------------------------------------
	package org.eclipse.epf.library.tester;

	import java.io.File;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.Stack;

	import org.eclipse.epf.common.utils.XMLUtil;
	import org.eclipse.epf.library.tester.iface.TestTracer;
	import org.eclipse.epf.uma.MethodElement;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.NamedNodeMap;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	/**
	* Class to analyze the differneces between two library tester outputs
	*
	* @author Weiping Lu
	* @since 1.0
	*
	*/
	public class OutputDiffAnalyzor {

	private boolean localDebug = false;
	private TestTracer tracer;
	private boolean needToAnalyze = true;
	private File f1;
	private File f2;
	private Document d1;
	private Document d2;
	private int diffCount = 0;
	private int elemComparedCount = 0;

	private static boolean excludeGuidFromName = true;
	//May want to use feature classes directly instead of names later
	private static String[] excludedFeatures = {
	"guid",
	"changeDate"
	};

	private static Set excludedFeatureSet = new HashSet();

	static {
	for (int i=0; i<excludedFeatures.length; i++) {
	excludedFeatureSet.add(excludedFeatures[i]);
	}
	}

	public OutputDiffAnalyzor(TestTracer t, Document d1, Document d2, File f1, File f2) {
	tracer = t;
	this.f1 = f1;
	this.f2 = f2;
	this.d1 = d1 == null ? getDocument(f1) : d1;
	this.d2 = d2 == null ? getDocument(f2) : d2;
	}

	private Document getDocument(File file) {
	if (file.exists()) {
	try {
	return XMLUtil.loadXml(file);
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	return null;
	}

	private void trace(String line) {
	tracer.trace(line);
	}

	private void analyze() {
	trace("OutputDiffAnalyzor.analyze ->");
	trace("f1: " + f1.getAbsolutePath());
	trace("f2: " + f2.getAbsolutePath());
	trace("");
	analyze_();
	trace("OutputDiffAnalyzor.analyze <-");
	}

	private void analyze_() {
	if (! needToAnalyze) {
	trace("no need to analyse");
	return;
	}
	compareRoot(d1.getDocumentElement(), d2.getDocumentElement());
	needToAnalyze = false;
	}

	// Top entry for method element comparison
	public void compareRoot(Element root1, Element root2) {
	diffCount = 0;
	elemComparedCount = 1;
	trace("");
	trace("compareRoot -> ");

	List elementList1 = collectElements(root1.getChildNodes());
	List elementList2 = collectElements(root2.getChildNodes());
	int sz1 = elementList1.size();
	int sz2 = elementList2.size();

	if (sz1 != sz2) {
	String msg = "root child elements: sz1 != sz2 -> " + Integer.toString(sz1) + " != " + Integer.toString(sz2);
	logDiff(msg, root1, root2);
	}

	int sz = sz1 < sz2 ? sz1 : sz2;
	for (int i=0; i<sz; i++) {
	compare((Element) elementList1.get(i), (Element) elementList2.get(i));
	}

	trace("compareRoot <- diffs: " + diffCount + ", elements: " + elemComparedCount + "\n");
	}

	private List collectElements(NodeList nodeList) {
	List elements = new ArrayList();
	for (int i=0; i<nodeList.getLength(); i++) {
	Node node = nodeList.item(i);
	if (node instanceof Element) {
	elements.add(node);
	}
	}
	return elements;
	}

	private void compare(Element node1, Element node2) {
	trace("compare -> ");
	compareInner(node1, node2);
	trace("compare <- ");
	}

	private void compareInner(Element node1, Element node2) {
	elemComparedCount++;
	if (localDebug) {
	trace("compareInner, node1: " + outputString(node1));
	trace("compareInner, node2: " + outputString(node1));
	trace("");
	}

	attributeEquals(node1, node2);

	List elementList1 = collectElements(node1.getChildNodes());
	List elementList2 = collectElements(node2.getChildNodes());
	int sz1 = elementList1.size();
	int sz2 = elementList2.size();

	if (sz1 != sz2) {
	String msg = "Child elements: sz1 != sz2 -> " + Integer.toString(sz1) + " != " + Integer.toString(sz2);
	logDiff(msg, node1, node2);
	}

	int sz = sz1 < sz2 ? sz1 : sz2;
	for (int i=0; i<sz; i++) {
	compareInner((Element) elementList1.get(i), (Element) elementList2.get(i));
	}
	}

	private boolean attributeEquals(Element node1, Element node2) {
	boolean ret = true;

	NamedNodeMap atts1 = node1.getAttributes();
	NamedNodeMap atts2 = node2.getAttributes();
	int sz1 = atts1.getLength();
	int sz2 = atts2.getLength();
	if (sz1 != sz2) {
	logDiff("Attributes: sz1 != sz2", node1, node2);
	ret = false;
	}
	int sz = sz1 < sz2 ? sz1 : sz2;
	for (int i=0; i<sz; i++) {
	String attName = atts1.item(i).getNodeName();
	if (excludedFeatureSet.contains(attName)) {
	continue;
	}
	String val1 = node1.getAttribute(attName);
	String val2 = node2.getAttribute(attName);
	if (attName.equals("name") && excludeGuidFromName) {
	int ix = val1.indexOf(",");
	if (ix > 0) {
	val1 = val1.substring(0, ix);
	}
	ix = val2.indexOf(",");
	if (ix > 0) {
	val2 = val2.substring(0, ix);
	}
	}
	if (! valueEquals(val1, val2)) {
	String msg = attName + " values not the same!";
	logDiff(msg, node1, node2, val1, val2);
	}
	}

	return ret;
	}

	private boolean valueEquals(Object val1, Object val2) {
	if (val1 == null) {
	val1 = "";
	}

	if (val2 == null) {
	val2 = "";
	}

	if (val1 instanceof String) {
	String str1 = (String) val1;
	String str2 = (String) val2;
	return str1.equals(str2);
	}

	return false;
	}


	private void logDiff(String msg, Element node1, Element node2, Object val1, Object val2) {
	log(msg, node1, node2, true);
	String prompt = getDiffPrompt();
	trace(prompt + "val1: " + val1);
	trace(prompt + "val2: " + val2);
	trace("");
	}

	private int incDiffCount() {
	return ++diffCount;
	}

	private String getDiffPrompt() {
	return "D_" + diffCount + "> ";
	}

	private void logDiff(String msg, Element node1, Element node2) {
	log(msg, node1, node2, true);
	trace("");
	}

	private void log(String msg, Element node1, Element node2, boolean diff) {
	if (diff) {
	incDiffCount();
	}
	String prompt = diff ? getDiffPrompt() : "Warning> ";
	//trace(prompt + "path: " + pathString(node1));
	trace(prompt + "msg: " + msg);
	trace(prompt + "node1: " + outputString(node1));
	trace(prompt + "node2: " + outputString(node2));
	}

	private String pathString(Element node) {
	Stack paths = new Stack();
	Node currNode = node;
	while (currNode != null && currNode instanceof Element) {
	String name = ((Element) currNode).getAttribute("name");
	paths.push(name);
	currNode = currNode.getParentNode();
	}
	String ret = "";
	while(! paths.isEmpty()) {
	ret += "/" + paths.pop();
	}
	return ret;
	}

	public boolean compare() {
	analyze();
	return true;
	}

	private String outputString(Element node) {
	if (node == null) {
	return null;
	}
	String type = node.getAttribute("type");
	return type + ": " + pathString(node);
	}

	public int getDiffCount() {
	return diffCount;
	}

	public int getElemComparedCount() {
	return elemComparedCount;
	}


	}