//------------------------------------------------------------------------------
// 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;
}
}