Menu
▾
▴
SF.net SVN: xmlunit:[413] trunk/xmlunit/src
|
From: <bo...@us...> - 2010-07-12 15:18:21
|
Revision: 413
http://xmlunit.svn.sourceforge.net/xmlunit/?rev=413&view=rev
Author: bodewig
Date: 2010-07-12 15:18:14 +0000 (Mon, 12 Jul 2010)
Log Message:
-----------
implement element and attribute level comparisions, move tests to the compareNodes level, make .NET tests even closer to the Java ones
Modified Paths:
--------------
trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DOMDifferenceEngine.java.xml
trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DifferenceEvaluators.java
trunk/xmlunit/src/main/net-core/diff/DOMDifferenceEngine.xml
trunk/xmlunit/src/main/net-core/diff/DifferenceEvaluators.cs
trunk/xmlunit/src/tests/java-core/net/sf/xmlunit/diff/DOMDifferenceEngineTest.java
trunk/xmlunit/src/tests/net-core/diff/DOMDifferenceEngineTest.cs
Modified: trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DOMDifferenceEngine.java.xml
===================================================================
--- trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DOMDifferenceEngine.java.xml 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DOMDifferenceEngine.java.xml 2010-07-12 15:18:14 UTC (rev 413)
@@ -19,10 +19,12 @@
<import reference="javax.xml.transform.Source"/>
<import reference="net.sf.xmlunit.util.Convert"/>
+ <import reference="org.w3c.dom.Attr"/>
<import reference="org.w3c.dom.CharacterData"/>
<import reference="org.w3c.dom.Document"/>
<import reference="org.w3c.dom.DocumentType"/>
<import reference="org.w3c.dom.Element"/>
+ <import reference="org.w3c.dom.NamedNodeMap"/>
<import reference="org.w3c.dom.Node"/>
<import reference="org.w3c.dom.NodeList"/>
<import reference="org.w3c.dom.ProcessingInstruction"/>
@@ -74,7 +76,8 @@
*
* <p>package private to support tests.</p>
*/
- ComparisonResult nodeTypeSpecificComparison(Node control, Node test) {
+ private ComparisonResult nodeTypeSpecificComparison(Node control,
+ Node test) {
switch (control.getNodeType()) {
case Node.CDATA_SECTION_NODE:
case Node.COMMENT_NODE:
@@ -109,6 +112,12 @@
(DocumentType) test);
}
break;
+ case Node.ATTRIBUTE_NODE:
+ if (test instanceof Attr) {
+ return compareAttributes((Attr) control,
+ (Attr) test);
+ }
+ break;
}
return ComparisonResult.EQUAL;
}
@@ -135,7 +144,7 @@
<literal><![CDATA[
if (controlDt != null && testDt != null) {
]]></literal>
- <compareMethodExpr method="nodeTypeSpecificComparison"
+ <compareMethodExpr method="compareNodes"
controlExpr="controlDt"
testExpr="testDt"/>
<literal><![CDATA[
@@ -161,12 +170,61 @@
test, null, test.getSystemId()));
}
- ComparisonResult compareElements(Element control,
- Element test) {
- return ComparisonResult.EQUAL;
+ private ComparisonResult compareElements(Element control,
+ Element test) {
+]]></literal>
+ <lastResultDef/>
+ <compare type="ELEMENT_TAG_NAME" property="getTagName()"/>
+ <literal><![CDATA[
+ NamedNodeMap controlAttributes = control.getAttributes();
+ NamedNodeMap testAttributes = test.getAttributes();
+ final int controlAttrLen = controlAttributes.getLength();
+ final int testAttrLen = testAttributes.getLength();
+]]></literal>
+ <compareExpr type="ELEMENT_NUM_ATTRIBUTES"
+ controlExpr="controlAttrLen"
+ testExpr="testAttrLen"/>
+ <literal><![CDATA[
+ for (int i = 0; i < controlAttrLen; i++) {
+ final Attr controlAttr = (Attr) controlAttributes.item(i);
+ final Attr testAttr = findMatchingAttr(testAttributes, controlAttr);
+]]></literal>
+ <compareExpr type="ATTR_NAME_LOOKUP"
+ controlExpr="Boolean.TRUE"
+ testExpr="Boolean.valueOf(testAttr != null)"/>
+ <literal><![CDATA[
+ }
+]]></literal>
+ <literal><![CDATA[
+ for (int i = 0; i < testAttrLen; i++) {
+ final Attr testAttr = (Attr) testAttributes.item(i);
+ final Attr controlAttr = findMatchingAttr(controlAttributes,
+ testAttr);
+]]></literal>
+ <compareExpr type="ATTR_NAME_LOOKUP"
+ controlExpr="Boolean.valueOf(controlAttr != null)"
+ testExpr="Boolean.TRUE"/>
+ <literal><![CDATA[
+ }
+]]></literal>
+ <literal><![CDATA[
+ for (int i = 0; i < controlAttrLen; i++) {
+ final Attr controlAttr = (Attr) controlAttributes.item(i);
+ final Attr testAttr = findMatchingAttr(testAttributes, controlAttr);
+ if (testAttr != null) {
+]]></literal>
+ <compareMethodExpr method="compareNodes"
+ controlExpr="controlAttr"
+ testExpr="testAttr"/>
+ <literal><![CDATA[
+ }
+ }
+]]></literal>
+ <literal><![CDATA[
+ return lastResult;
}
- ComparisonResult
+ private ComparisonResult
compareProcessingInstructions(ProcessingInstruction control,
ProcessingInstruction test) {
]]></literal>
@@ -178,8 +236,28 @@
test, null, test.getData()));
}
- ComparisonResult compareNodeLists(NodeList control, NodeList test) {
+ private ComparisonResult compareNodeLists(NodeList control, NodeList test) {
return ComparisonResult.EQUAL;
}
+
+ private ComparisonResult compareAttributes(Attr control, Attr test) {
]]></literal>
+ <lastResultDef/>
+ <compare type="ATTR_VALUE_EXPLICITLY_SPECIFIED" property="getSpecified()"/>
+ <literal><![CDATA[
+ return compare(new Comparison(ComparisonType.ATTR_VALUE,
+ control, null, control.getValue(),
+ test, null, test.getValue()));
+ }
+
+ private static Attr findMatchingAttr(NamedNodeMap map, Attr attrToMatch) {
+ if (attrToMatch.getNamespaceURI() == null) {
+ return (Attr) map.getNamedItem(attrToMatch.getName());
+ } else {
+ return (Attr) map.getNamedItemNS(attrToMatch.getNamespaceURI(),
+ attrToMatch.getLocalName());
+ }
+ }
+
+]]></literal>
</class>
\ No newline at end of file
Modified: trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DifferenceEvaluators.java
===================================================================
--- trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DifferenceEvaluators.java 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/main/java-core/net/sf/xmlunit/diff/DifferenceEvaluators.java 2010-07-12 15:18:14 UTC (rev 413)
@@ -25,6 +25,17 @@
private static final Short TEXT = Node.CDATA_SECTION_NODE;
/**
+ * Difference evaluator that just echos the result passed in.
+ */
+ public static final DifferenceEvaluator Accept =
+ new DifferenceEvaluator() {
+ public ComparisonResult evaluate(Comparison comparison,
+ ComparisonResult outcome) {
+ return outcome;
+ }
+ };
+
+ /**
* The "standard" difference evaluator which decides which
* differences make two XML documents really different and which
* still leave them similar.
Modified: trunk/xmlunit/src/main/net-core/diff/DOMDifferenceEngine.xml
===================================================================
--- trunk/xmlunit/src/main/net-core/diff/DOMDifferenceEngine.xml 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/main/net-core/diff/DOMDifferenceEngine.xml 2010-07-12 15:18:14 UTC (rev 413)
@@ -66,8 +66,8 @@
/// Dispatches to the node type specific comparison if one is
/// defined for the given combination of nodes.
/// </summary>
- internal ComparisonResult NodeTypeSpecificComparison(XmlNode control,
- XmlNode test) {
+ private ComparisonResult NodeTypeSpecificComparison(XmlNode control,
+ XmlNode test) {
switch (control.NodeType) {
case XmlNodeType.CDATA:
case XmlNodeType.Comment:
@@ -84,12 +84,10 @@
}
break;
case XmlNodeType.Element:
-#if false
- if (test instanceof Element) {
- return compareElements((Element) control,
- (Element) test);
+ if (test is XmlElement) {
+ return CompareElements((XmlElement) control,
+ (XmlElement) test);
}
-#endif
break;
case XmlNodeType.ProcessingInstruction:
if (test is XmlProcessingInstruction) {
@@ -104,6 +102,12 @@
(XmlDocumentType) test);
}
break;
+ case XmlNodeType.Attribute:
+ if (test is XmlAttribute) {
+ return CompareAttributes((XmlAttribute) control,
+ (XmlAttribute) test);
+ }
+ break;
}
return ComparisonResult.EQUAL;
}
@@ -130,7 +134,7 @@
<literal><![CDATA[
if (controlDt != null && testDt != null) {
]]></literal>
- <compareMethodExpr method="NodeTypeSpecificComparison"
+ <compareMethodExpr method="CompareNodes"
controlExpr="controlDt"
testExpr="testDt"/>
<literal><![CDATA[
@@ -160,6 +164,62 @@
test, null, test.SystemId));
}
+ private ComparisonResult CompareElements(XmlElement control,
+ XmlElement test) {
+]]></literal>
+ <lastResultDef/>
+ <compare type="ELEMENT_TAG_NAME" property="Name"/>
+ <literal><![CDATA[
+ XmlAttributeCollection controlAttributes = control.Attributes;
+ XmlAttributeCollection testAttributes = test.Attributes;
+ int controlAttrLen = controlAttributes.Count;
+ int testAttrLen = testAttributes.Count;
+]]></literal>
+ <compareExpr type="ELEMENT_NUM_ATTRIBUTES"
+ controlExpr="controlAttrLen"
+ testExpr="testAttrLen"/>
+ <literal><![CDATA[
+ for (int i = 0; i < controlAttrLen; i++) {
+ XmlAttribute controlAttr = controlAttributes[i];
+ XmlAttribute testAttr = FindMatchingAttr(testAttributes,
+ controlAttr);
+]]></literal>
+ <compareExpr type="ATTR_NAME_LOOKUP"
+ controlExpr="true"
+ testExpr="testAttr != null"/>
+ <literal><![CDATA[
+ }
+]]></literal>
+ <literal><![CDATA[
+ for (int i = 0; i < testAttrLen; i++) {
+ XmlAttribute testAttr = testAttributes[i];
+ XmlAttribute controlAttr = FindMatchingAttr(controlAttributes,
+ testAttr);
+]]></literal>
+ <compareExpr type="ATTR_NAME_LOOKUP"
+ controlExpr="controlAttr != null"
+ testExpr="true"/>
+ <literal><![CDATA[
+ }
+]]></literal>
+ <literal><![CDATA[
+ for (int i = 0; i < controlAttrLen; i++) {
+ XmlAttribute controlAttr = controlAttributes[i];
+ XmlAttribute testAttr = FindMatchingAttr(testAttributes,
+ controlAttr);
+ if (testAttr != null) {
+]]></literal>
+ <compareMethodExpr method="CompareNodes"
+ controlExpr="controlAttr"
+ testExpr="testAttr"/>
+ <literal><![CDATA[
+ }
+ }
+]]></literal>
+ <literal><![CDATA[
+ return lastResult;
+ }
+
private ComparisonResult
CompareProcessingInstructions(XmlProcessingInstruction control,
XmlProcessingInstruction test) {
@@ -172,10 +232,31 @@
test, null, test.Data));
}
- ComparisonResult CompareNodeLists(XmlNodeList control,
- XmlNodeList test) {
+ private ComparisonResult CompareNodeLists(XmlNodeList control,
+ XmlNodeList test) {
return ComparisonResult.EQUAL;
}
+ private ComparisonResult CompareAttributes(XmlAttribute control,
+ XmlAttribute test) {
]]></literal>
+ <lastResultDef/>
+ <compare type="ATTR_VALUE_EXPLICITLY_SPECIFIED" property="Specified"/>
+ <literal><![CDATA[
+ return Compare(new Comparison(ComparisonType.ATTR_VALUE,
+ control, null, control.Value,
+ test, null, test.Value));
+ }
+
+ private static XmlAttribute FindMatchingAttr(XmlAttributeCollection map,
+ XmlAttribute attrToMatch) {
+ if (attrToMatch.NamespaceURI == null) {
+ return map.GetNamedItem(attrToMatch.Name) as XmlAttribute;
+ } else {
+ return map.GetNamedItem(attrToMatch.LocalName,
+ attrToMatch.NamespaceURI)
+ as XmlAttribute;
+ }
+ }
+]]></literal>
</class>
\ No newline at end of file
Modified: trunk/xmlunit/src/main/net-core/diff/DifferenceEvaluators.cs
===================================================================
--- trunk/xmlunit/src/main/net-core/diff/DifferenceEvaluators.cs 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/main/net-core/diff/DifferenceEvaluators.cs 2010-07-12 15:18:14 UTC (rev 413)
@@ -23,6 +23,14 @@
private DifferenceEvaluators() { }
/// <summary>
+ /// Difference evaluator that just echos the result passed in.
+ /// </summary>
+ public static ComparisonResult Accept(Comparison comparison,
+ ComparisonResult outcome) {
+ return outcome;
+ }
+
+ /// <summary>
/// The "standard" difference evaluator which decides which
/// differences make two XML documents really different and which
/// still leave them similar.
Modified: trunk/xmlunit/src/tests/java-core/net/sf/xmlunit/diff/DOMDifferenceEngineTest.java
===================================================================
--- trunk/xmlunit/src/tests/java-core/net/sf/xmlunit/diff/DOMDifferenceEngineTest.java 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/tests/java-core/net/sf/xmlunit/diff/DOMDifferenceEngineTest.java 2010-07-12 15:18:14 UTC (rev 413)
@@ -21,7 +21,9 @@
import net.sf.xmlunit.util.Convert;
import org.junit.Before;
import org.junit.Test;
+import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
+import org.w3c.dom.CharacterData;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
@@ -51,7 +53,8 @@
}
public void comparisonPerformed(Comparison comparison,
ComparisonResult outcome) {
- assertTrue(invoked < expectedInvocations);
+ assertTrue(invoked + " should be less than " + expectedInvocations,
+ invoked < expectedInvocations);
invoked++;
assertEquals(type, comparison.getType());
assertEquals(ComparisonResult.CRITICAL, outcome);
@@ -143,7 +146,25 @@
DOMDifferenceEngine d = new DOMDifferenceEngine();
DiffExpecter ex = new DiffExpecter(ComparisonType.TEXT_VALUE, 9);
d.addDifferenceListener(ex);
- d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ d.setDifferenceEvaluator(new DifferenceEvaluator() {
+ public ComparisonResult evaluate(Comparison comparison,
+ ComparisonResult outcome) {
+ if (comparison.getType() == ComparisonType.NODE_TYPE) {
+ if (outcome == ComparisonResult.EQUAL
+ || (
+ comparison.getControlNodeDetails()
+ .getNode() instanceof CharacterData
+ &&
+ comparison.getTestNodeDetails()
+ .getNode() instanceof CharacterData
+ )) {
+ return ComparisonResult.EQUAL;
+ }
+ }
+ return DifferenceEvaluators.DefaultStopWhenDifferent
+ .evaluate(comparison, outcome);
+ }
+ });
Comment fooComment = doc.createComment("foo");
Comment barComment = doc.createComment("bar");
@@ -153,45 +174,42 @@
CDATASection barCDATASection = doc.createCDATASection("bar");
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooComment, fooComment));
+ d.compareNodes(fooComment, fooComment));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooComment, barComment));
+ d.compareNodes(fooComment, barComment));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooText, fooText));
+ d.compareNodes(fooText, fooText));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooText, barText));
+ d.compareNodes(fooText, barText));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooCDATASection, fooCDATASection));
+ d.compareNodes(fooCDATASection, fooCDATASection));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooCDATASection, barCDATASection));
+ d.compareNodes(fooCDATASection, barCDATASection));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooComment, fooText));
+ d.compareNodes(fooComment, fooText));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooComment, barText));
+ d.compareNodes(fooComment, barText));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooComment, fooCDATASection));
+ d.compareNodes(fooComment, fooCDATASection));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooComment, barCDATASection));
+ d.compareNodes(fooComment, barCDATASection));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooText, fooComment));
+ d.compareNodes(fooText, fooComment));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooText, barComment));
+ d.compareNodes(fooText, barComment));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooText, fooCDATASection));
+ d.compareNodes(fooText, fooCDATASection));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooText, barCDATASection));
+ d.compareNodes(fooText, barCDATASection));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooCDATASection, fooText));
+ d.compareNodes(fooCDATASection, fooText));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooCDATASection, barText));
+ d.compareNodes(fooCDATASection, barText));
assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooCDATASection, fooComment));
+ d.compareNodes(fooCDATASection, fooComment));
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(fooCDATASection, barComment));
- assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(fooText,
- doc.createElement("bar")));
+ d.compareNodes(fooCDATASection, barComment));
assertEquals(9, ex.invoked);
}
@@ -203,13 +221,8 @@
ProcessingInstruction foo1 = doc.createProcessingInstruction("foo", "1");
ProcessingInstruction bar1 = doc.createProcessingInstruction("bar", "1");
- assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(foo1, foo1));
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(foo1, bar1));
- assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(foo1,
- doc.createElement("bar")));
+ assertEquals(ComparisonResult.EQUAL, d.compareNodes(foo1, foo1));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(foo1, bar1));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -217,10 +230,8 @@
d.addDifferenceListener(ex);
d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
ProcessingInstruction foo2 = doc.createProcessingInstruction("foo", "2");
- assertEquals(ComparisonResult.EQUAL,
- d.nodeTypeSpecificComparison(foo1, foo1));
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(foo1, foo2));
+ assertEquals(ComparisonResult.EQUAL, d.compareNodes(foo1, foo1));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(foo1, foo2));
assertEquals(1, ex.invoked);
}
@@ -232,11 +243,18 @@
public ComparisonResult evaluate(Comparison comparison,
ComparisonResult outcome) {
if (comparison.getType()
+ == ComparisonType.CHILD_NODELIST_LENGTH) {
+ assertEquals(ComparisonResult.DIFFERENT, outcome);
+ return ComparisonResult.EQUAL;
+ }
+ if (comparison.getType()
== ComparisonType.HAS_DOCTYPE_DECLARATION) {
assertEquals(ComparisonResult.DIFFERENT, outcome);
return ComparisonResult.CRITICAL;
}
- assertEquals(ComparisonResult.EQUAL, outcome);
+ assertEquals("Expected EQUAL for " + comparison.getType()
+ + " comparison.",
+ ComparisonResult.EQUAL, outcome);
return ComparisonResult.EQUAL;
}
});
@@ -248,8 +266,7 @@
+ "\">"
+ "<Book/>")
.build());
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(d1, d2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(d1, d2));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -264,7 +281,7 @@
+ " encoding=\"UTF-8\"?>"
+ "<Book/>").build());
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(d1, d2));
+ d.compareNodes(d1, d2));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -279,7 +296,7 @@
+ " standalone=\"no\"?>"
+ "<Book/>").build());
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(d1, d2));
+ d.compareNodes(d1, d2));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -305,7 +322,7 @@
+ " encoding=\"UTF-16\"?>"
+ "<Book/>").build());
assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(d1, d2));
+ d.compareNodes(d1, d2));
assertEquals(1, ex.invoked);
}
@@ -346,8 +363,7 @@
d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
DocumentType dt1 = new DocType("name", "pub", "system");
DocumentType dt2 = new DocType("name2", "pub", "system");
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(dt1, dt2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(dt1, dt2));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -355,8 +371,7 @@
d.addDifferenceListener(ex);
d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
dt2 = new DocType("name", "pub2", "system");
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(dt1, dt2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(dt1, dt2));
assertEquals(1, ex.invoked);
d = new DOMDifferenceEngine();
@@ -375,8 +390,81 @@
}
});
dt2 = new DocType("name", "pub", "system2");
- assertEquals(ComparisonResult.CRITICAL,
- d.nodeTypeSpecificComparison(dt1, dt2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(dt1, dt2));
assertEquals(1, ex.invoked);
}
+
+ @Test public void compareElements() {
+ DOMDifferenceEngine d = new DOMDifferenceEngine();
+ DiffExpecter ex = new DiffExpecter(ComparisonType.ELEMENT_TAG_NAME);
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ Element e1 = doc.createElement("foo");
+ Element e2 = doc.createElement("foo");
+ Element e3 = doc.createElement("bar");
+ assertEquals(ComparisonResult.EQUAL, d.compareNodes(e1, e2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(e1, e3));
+ assertEquals(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ ex = new DiffExpecter(ComparisonType.ELEMENT_NUM_ATTRIBUTES);
+ e1.setAttribute("attr1", "value1");
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(e1, e2));
+ assertEquals(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ ex = new DiffExpecter(ComparisonType.ATTR_NAME_LOOKUP);
+ e2.setAttributeNS("urn:xmlunit:test", "attr1", "value1");
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(e1, e2));
+ assertEquals(1, ex.invoked);
+
+
+ d = new DOMDifferenceEngine();
+ d.addDifferenceListener(new ComparisonListener() {
+ public void comparisonPerformed(Comparison comparison,
+ ComparisonResult outcome) {
+ fail("unexpected Comparison of type " + comparison.getType()
+ + " with outcome " + outcome + " and values '"
+ + comparison.getControlNodeDetails().getValue()
+ + "' and '"
+ + comparison.getTestNodeDetails().getValue() + "'");
+ }
+ });
+ e1.setAttributeNS("urn:xmlunit:test", "attr1", "value1");
+ e2.setAttributeNS(null, "attr1", "value1");
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ assertEquals(ComparisonResult.EQUAL, d.compareNodes(e1, e2));
+ }
+
+ @Test public void compareAttributes() {
+ Attr a1 = doc.createAttribute("foo");
+ Attr a2 = doc.createAttribute("foo");
+
+ DOMDifferenceEngine d = new DOMDifferenceEngine();
+ DiffExpecter ex = new DiffExpecter(ComparisonType.ATTR_VALUE_EXPLICITLY_SPECIFIED);
+ /* Can't reset "explicitly set" state for Documents created via API
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.Accept);
+ a2.setValue("");
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(a1, a2));
+ assertEquals(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ */
+ ex = new DiffExpecter(ComparisonType.ATTR_VALUE);
+ d.addDifferenceListener(ex);
+ d.setDifferenceEvaluator(DifferenceEvaluators.DefaultStopWhenDifferent);
+ Attr a3 = doc.createAttribute("foo");
+ a1.setValue("foo");
+ a2.setValue("foo");
+ a3.setValue("bar");
+ assertEquals(ComparisonResult.EQUAL, d.compareNodes(a1, a2));
+ assertEquals(ComparisonResult.CRITICAL, d.compareNodes(a1, a3));
+ assertEquals(1, ex.invoked);
+ }
}
Modified: trunk/xmlunit/src/tests/net-core/diff/DOMDifferenceEngineTest.cs
===================================================================
--- trunk/xmlunit/src/tests/net-core/diff/DOMDifferenceEngineTest.cs 2010-07-06 15:01:27 UTC (rev 412)
+++ trunk/xmlunit/src/tests/net-core/diff/DOMDifferenceEngineTest.cs 2010-07-12 15:18:14 UTC (rev 413)
@@ -27,6 +27,24 @@
}
}
+ private class DiffExpecter {
+ internal int invoked = 0;
+ private readonly int expectedInvocations;
+ private readonly ComparisonType type;
+ internal DiffExpecter(ComparisonType type) : this(type, 1) { }
+ internal DiffExpecter(ComparisonType type, int expected) {
+ this.type = type;
+ this.expectedInvocations = expected;
+ }
+ public void ComparisonPerformed(Comparison comparison,
+ ComparisonResult outcome) {
+ Assert.Greater(expectedInvocations, invoked);
+ invoked++;
+ Assert.AreEqual(type, comparison.Type);
+ Assert.AreEqual(ComparisonResult.CRITICAL, outcome);
+ }
+ }
+
private XmlDocument doc;
[SetUp]
@@ -37,20 +55,14 @@
[Test]
public void CompareNodesOfDifferentType() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.NODE_TYPE, comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex = new DiffExpecter(ComparisonType.NODE_TYPE);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
Assert.AreEqual(ComparisonResult.CRITICAL,
d.CompareNodes(doc.CreateElement("x"),
doc.CreateComment("x")));
- Assert.AreEqual(1, invocations);
+ Assert.AreEqual(1, ex.invoked);
}
[Test]
@@ -70,33 +82,21 @@
[Test]
public void CompareNodesDifferentNS() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.NAMESPACE_URI, comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex = new DiffExpecter(ComparisonType.NAMESPACE_URI);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
Assert.AreEqual(ComparisonResult.CRITICAL,
d.CompareNodes(doc.CreateElement("y", "x"),
doc.CreateElement("y", "z")));
- Assert.AreEqual(1, invocations);
+ Assert.AreEqual(1, ex.invoked);
}
[Test]
public void CompareNodesDifferentPrefix() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.NAMESPACE_PREFIX, comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex = new DiffExpecter(ComparisonType.NAMESPACE_PREFIX);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator = delegate(Comparison comparison,
ComparisonResult outcome) {
if (comparison.Type == ComparisonType.NAMESPACE_PREFIX) {
@@ -109,21 +109,15 @@
Assert.AreEqual(ComparisonResult.CRITICAL,
d.CompareNodes(doc.CreateElement("x:y", "x"),
doc.CreateElement("z:y", "x")));
- Assert.AreEqual(1, invocations);
+ Assert.AreEqual(1, ex.invoked);
}
[Test]
public void CompareNodesDifferentNumberOfChildren() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.Greater(2, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.CHILD_NODELIST_LENGTH,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex =
+ new DiffExpecter(ComparisonType.CHILD_NODELIST_LENGTH, 2);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
XmlElement e1 = doc.CreateElement("x");
@@ -131,28 +125,35 @@
Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(e1, e2));
e1.AppendChild(doc.CreateElement("x"));
Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(e1, e2));
- Assert.AreEqual(1, invocations);
+ Assert.AreEqual(1, ex.invoked);
e2.AppendChild(doc.CreateElement("x"));
Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(e1, e2));
e2.AppendChild(doc.CreateElement("x"));
Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(e1, e2));
- Assert.AreEqual(2, invocations);
+ Assert.AreEqual(2, ex.invoked);
}
[Test]
public void CompareCharacterData() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.Greater(9, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.TEXT_VALUE,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
+ DiffExpecter ex = new DiffExpecter(ComparisonType.TEXT_VALUE, 9);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator = delegate(Comparison comparison,
+ ComparisonResult outcome) {
+ if (comparison.Type == ComparisonType.NODE_TYPE) {
+ if (outcome == ComparisonResult.EQUAL
+ || (
+ comparison.ControlNodeDetails.Node
+ is XmlCharacterData
+ &&
+ comparison.TestNodeDetails.Node is XmlCharacterData
+ )) {
+ return ComparisonResult.EQUAL;
+ }
+ }
+ return DifferenceEvaluators.DefaultStopWhenDifferent(comparison,
+ outcome);
};
- d.DifferenceEvaluator =
- DifferenceEvaluators.DefaultStopWhenDifferent;
XmlComment fooComment = doc.CreateComment("foo");
XmlComment barComment = doc.CreateComment("bar");
@@ -162,73 +163,51 @@
XmlCDataSection barCDataSection = doc.CreateCDataSection("bar");
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooComment,
- fooComment));
+ d.CompareNodes(fooComment, fooComment));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooComment,
- barComment));
+ d.CompareNodes(fooComment, barComment));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooText, fooText));
+ d.CompareNodes(fooText, fooText));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooText, barText));
+ d.CompareNodes(fooText, barText));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- fooCDataSection));
+ d.CompareNodes(fooCDataSection, fooCDataSection));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- barCDataSection));
+ d.CompareNodes(fooCDataSection, barCDataSection));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooComment, fooText));
+ d.CompareNodes(fooComment, fooText));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooComment, barText));
+ d.CompareNodes(fooComment, barText));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooComment,
- fooCDataSection));
+ d.CompareNodes(fooComment, fooCDataSection));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooComment,
- barCDataSection));
+ d.CompareNodes(fooComment, barCDataSection));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooText,
- fooComment));
+ d.CompareNodes(fooText, fooComment));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooText, barComment));
+ d.CompareNodes(fooText, barComment));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooText,
- fooCDataSection));
+ d.CompareNodes(fooText, fooCDataSection));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooText,
- barCDataSection));
+ d.CompareNodes(fooText, barCDataSection));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- fooText));
+ d.CompareNodes(fooCDataSection, fooText));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- barText));
+ d.CompareNodes(fooCDataSection, barText));
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- fooComment));
+ d.CompareNodes(fooCDataSection, fooComment));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(fooCDataSection,
- barComment));
- Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(fooText,
- doc.CreateElement("bar")));
- Assert.AreEqual(9, invocations);
+ d.CompareNodes(fooCDataSection, barComment));
+ Assert.AreEqual(9, ex.invoked);
}
[Test]
public void CompareProcessingInstructions() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.PROCESSING_INSTRUCTION_TARGET,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex =
+ new DiffExpecter(ComparisonType.PROCESSING_INSTRUCTION_TARGET);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
@@ -237,47 +216,30 @@
XmlProcessingInstruction bar1 = doc.CreateProcessingInstruction("bar",
"1");
Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(foo1, foo1));
+ d.CompareNodes(foo1, foo1));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(foo1, bar1));
- Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(foo1,
- doc.CreateElement("bar")));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(foo1, bar1));
+ Assert.AreEqual(1, ex.invoked);
d = new DOMDifferenceEngine();
- invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.PROCESSING_INSTRUCTION_DATA,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.PROCESSING_INSTRUCTION_DATA);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
XmlProcessingInstruction foo2 = doc.CreateProcessingInstruction("foo",
"2");
- Assert.AreEqual(ComparisonResult.EQUAL,
- d.NodeTypeSpecificComparison(foo1, foo1));
+ Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(foo1, foo1));
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(foo1, foo2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(foo1, foo2));
+ Assert.AreEqual(1, ex.invoked);
}
[Test]
public void CompareDocuments() {
DOMDifferenceEngine d = new DOMDifferenceEngine();
- int invocations = 0;
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.HAS_DOCTYPE_DECLARATION,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex =
+ new DiffExpecter(ComparisonType.HAS_DOCTYPE_DECLARATION);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator = delegate(Comparison comparison,
ComparisonResult outcome) {
if (comparison.Type == ComparisonType.HAS_DOCTYPE_DECLARATION) {
@@ -301,23 +263,16 @@
+ "<Book/>")
.Build());
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(d1, d2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(d1, d2));
+ Assert.AreEqual(1, ex.invoked);
#endif
#if false // need a way to figure out the XML_* differences
// .NET doesn't like XML 1.1 anyway
- invocations = 0;
d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.XML_VERSION,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.XML_VERSION);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
@@ -330,21 +285,14 @@
+ " encoding=\"UTF-8\"?>"
+ "<Book/>").Build());
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(d1, d2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(d1, d2));
+ Assert.AreEqual(1, ex.invoked);
#endif
#if false // need a way to figure out the XML_* differences
- invocations = 0;
d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.XML_STANDALONE,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.XML_STANDALONE);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
@@ -357,21 +305,14 @@
+ " standalone=\"no\"?>"
+ "<Book/>").Build());
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(d1, d2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(d1, d2));
+ Assert.AreEqual(1, ex.invoked);
#endif
#if false // need a way to figure out the XML_* differences
- invocations = 0;
d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.XML_ENCODING,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.XML_ENCODING);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator = delegate(Comparison comparison,
ComparisonResult outcome) {
if (comparison.Type == ComparisonType.XML_ENCODING) {
@@ -391,23 +332,16 @@
+ " encoding=\"UTF-16\"?>"
+ "<Book/>").Build());
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(d1, d2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(d1, d2));
+ Assert.AreEqual(1, ex.invoked);
#endif
}
[Test]
public void CompareDocTypes() {
- int invocations = 0;
DOMDifferenceEngine d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.DOCTYPE_NAME,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ DiffExpecter ex = new DiffExpecter(ComparisonType.DOCTYPE_NAME);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
@@ -418,37 +352,23 @@
TestResources.BOOK_DTD,
null);
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(dt1, dt2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(dt1, dt2));
+ Assert.AreEqual(1, ex.invoked);
- invocations = 0;
d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.DOCTYPE_PUBLIC_ID,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.DOCTYPE_PUBLIC_ID);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator =
DifferenceEvaluators.DefaultStopWhenDifferent;
dt2 = doc.CreateDocumentType("name", "pub2",
TestResources.BOOK_DTD, null);
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(dt1, dt2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(dt1, dt2));
+ Assert.AreEqual(1, ex.invoked);
- invocations = 0;
d = new DOMDifferenceEngine();
- d.DifferenceListener += delegate(Comparison comp,
- ComparisonResult r) {
- Assert.AreEqual(0, invocations);
- invocations++;
- Assert.AreEqual(ComparisonType.DOCTYPE_SYSTEM_ID,
- comp.Type);
- Assert.AreEqual(ComparisonResult.CRITICAL, r);
- };
+ ex = new DiffExpecter(ComparisonType.DOCTYPE_SYSTEM_ID);
+ d.DifferenceListener += ex.ComparisonPerformed;
d.DifferenceEvaluator = delegate(Comparison comparison,
ComparisonResult outcome) {
if (comparison.Type == ComparisonType.DOCTYPE_SYSTEM_ID) {
@@ -461,9 +381,86 @@
dt2 = doc.CreateDocumentType("name", "pub",
TestResources.TEST_DTD, null);
Assert.AreEqual(ComparisonResult.CRITICAL,
- d.NodeTypeSpecificComparison(dt1, dt2));
- Assert.AreEqual(1, invocations);
+ d.CompareNodes(dt1, dt2));
+ Assert.AreEqual(1, ex.invoked);
}
+ [Test]
+ public void CompareElements() {
+ DOMDifferenceEngine d = new DOMDifferenceEngine();
+ DiffExpecter ex = new DiffExpecter(ComparisonType.ELEMENT_TAG_NAME);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator =
+ DifferenceEvaluators.DefaultStopWhenDifferent;
+
+ XmlElement e1 = doc.CreateElement("foo");
+ XmlElement e2 = doc.CreateElement("foo");
+ XmlElement e3 = doc.CreateElement("bar");
+ Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(e1, e2));
+ Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(e1, e3));
+ Assert.AreEqual(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ ex = new DiffExpecter(ComparisonType.ELEMENT_NUM_ATTRIBUTES);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator =
+ DifferenceEvaluators.DefaultStopWhenDifferent;
+ e1.SetAttribute("attr1", "value1");
+ Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(e1, e2));
+ Assert.AreEqual(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ ex = new DiffExpecter(ComparisonType.ATTR_NAME_LOOKUP);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator =
+ DifferenceEvaluators.DefaultStopWhenDifferent;
+ e2.SetAttribute("attr1", "urn:xmlunit:test", "value1");
+ Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(e1, e2));
+ Assert.AreEqual(1, ex.invoked);
+
+ d = new DOMDifferenceEngine();
+ d.DifferenceListener += delegate(Comparison comp,
+ ComparisonResult r) {
+ Assert.Fail("unexpected Comparison of type " + comp.Type
+ + " with outcome " + r + " and values '"
+ + comp.ControlNodeDetails.Value
+ + "' and '"
+ + comp.TestNodeDetails.Value + "'");
+ };
+ d.DifferenceEvaluator =
+ DifferenceEvaluators.DefaultStopWhenDifferent;
+ e1.SetAttribute("attr1", "urn:xmlunit:test", "value1");
+ e2.SetAttribute("attr1", null, "value1");
+ Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(e1, e2));
+ }
+
+ [Test]
+ public void CompareAttributes() {
+ XmlAttribute a1 = doc.CreateAttribute("foo");
+ XmlAttribute a2 = doc.CreateAttribute("foo");
+
+ DOMDifferenceEngine d = new DOMDifferenceEngine();
+#if false // Can't reset "explicitly set" state for Documents created via API
+ DiffExpecter ex = new DiffExpecter(ComparisonType.ATTR_VALUE_EXPLICITLY_SPECIFIED);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator = DifferenceEvaluators.Accept;
+ a2.Value = string.Empty;
+ Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(a1, a2));
+ Assert.AreEqual(1, ex.invoked);
+#endif
+
+ d = new DOMDifferenceEngine();
+ DiffExpecter ex = new DiffExpecter(ComparisonType.ATTR_VALUE);
+ d.DifferenceListener += ex.ComparisonPerformed;
+ d.DifferenceEvaluator =
+ DifferenceEvaluators.DefaultStopWhenDifferent;
+ XmlAttribute a3 = doc.CreateAttribute("foo");
+ a1.Value = "foo";
+ a2.Value = "foo";
+ a3.Value = "bar";
+ Assert.AreEqual(ComparisonResult.EQUAL, d.CompareNodes(a1, a2));
+ Assert.AreEqual(ComparisonResult.CRITICAL, d.CompareNodes(a1, a3));
+ Assert.AreEqual(1, ex.invoked);
+ }
}
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
