Menu
▾
▴
SF.net SVN: xmlunit:[285] trunk/xmlunit
|
From: <bo...@us...> - 2008-12-15 13:52:02
|
Revision: 285
http://xmlunit.svn.sourceforge.net/xmlunit/?rev=285&view=rev
Author: bodewig
Date: 2008-12-15 13:51:51 +0000 (Mon, 15 Dec 2008)
Log Message:
-----------
encapsulate reader state a bit
Modified Paths:
--------------
trunk/xmlunit/src/csharp/XmlDiff.cs
trunk/xmlunit/tests/csharp/XmlDiffTests.cs
Modified: trunk/xmlunit/src/csharp/XmlDiff.cs
===================================================================
--- trunk/xmlunit/src/csharp/XmlDiff.cs 2008-12-15 12:29:52 UTC (rev 284)
+++ trunk/xmlunit/src/csharp/XmlDiff.cs 2008-12-15 13:51:51 UTC (rev 285)
@@ -35,13 +35,13 @@
private XmlReader CreateXmlReader(XmlInput forInput) {
XmlReader xmlReader = forInput.CreateXmlReader();
- if (xmlReader is XmlTextReader) {
- ((XmlTextReader) xmlReader ).WhitespaceHandling = _diffConfiguration.WhitespaceHandling;
- }
+ if (xmlReader is XmlTextReader) {
+ ((XmlTextReader) xmlReader ).WhitespaceHandling = _diffConfiguration.WhitespaceHandling;
+ }
if (_diffConfiguration.UseValidatingParser) {
- XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
- return validatingReader;
+ XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
+ return validatingReader;
}
return xmlReader;
@@ -62,82 +62,78 @@
private void Compare(DiffResult result, XmlReader controlReader,
XmlReader testReader) {
- bool controlRead, testRead;
try {
+ ReaderWithState control = new ReaderWithState(controlReader);
+ ReaderWithState test = new ReaderWithState(testReader);
do {
- controlRead = controlReader.Read();
- testRead = testReader.Read();
- Compare(result, controlReader, ref controlRead,
- testReader, ref testRead);
- } while (controlRead && testRead) ;
+ control.Read();
+ test.Read();
+ Compare(result, control, test);
+ } while (control.HasRead && test.HasRead) ;
} catch (FlowControlException e) {
Console.Out.WriteLine(e.Message);
}
}
- private void Compare(DiffResult result,
- XmlReader controlReader, ref bool controlRead,
- XmlReader testReader, ref bool testRead) {
- if (controlRead) {
- if (testRead) {
- CompareNodes(result, controlReader, testReader);
- CheckEmptyOrAtEndElement(result,
- controlReader, ref controlRead,
- testReader, ref testRead);
+ private void Compare(DiffResult result, ReaderWithState control,
+ ReaderWithState test) {
+ if (control.HasRead) {
+ if (test.HasRead) {
+ CompareNodes(result, control, test);
+ CheckEmptyOrAtEndElement(result, control, test);
} else {
DifferenceFound(DifferenceType.CHILD_NODELIST_LENGTH_ID, result);
}
}
}
- private void CompareNodes(DiffResult result, XmlReader controlReader,
- XmlReader testReader) {
- XmlNodeType controlNodeType = controlReader.NodeType;
- XmlNodeType testNodeType = testReader.NodeType;
+ private void CompareNodes(DiffResult result, ReaderWithState control,
+ ReaderWithState test) {
+ XmlNodeType controlNodeType = control.Reader.NodeType;
+ XmlNodeType testNodeType = test.Reader.NodeType;
if (!controlNodeType.Equals(testNodeType)) {
CheckNodeTypes(controlNodeType, testNodeType, result,
- controlReader, testReader);
+ control, test);
} else if (controlNodeType == XmlNodeType.Element) {
- CompareElements(result, controlReader, testReader);
+ CompareElements(result, control, test);
} else if (controlNodeType == XmlNodeType.Text) {
- CompareText(result, controlReader, testReader);
+ CompareText(result, control, test);
}
}
private void CheckNodeTypes(XmlNodeType controlNodeType,
XmlNodeType testNodeType,
DiffResult result,
- XmlReader controlReader,
- XmlReader testReader) {
- XmlReader readerToAdvance = null;
+ ReaderWithState control,
+ ReaderWithState test) {
+ ReaderWithState readerToAdvance = null;
if (controlNodeType.Equals(XmlNodeType.XmlDeclaration)) {
- readerToAdvance = controlReader;
+ readerToAdvance = control;
} else if (testNodeType.Equals(XmlNodeType.XmlDeclaration)) {
- readerToAdvance = testReader;
+ readerToAdvance = test;
}
if (readerToAdvance != null) {
DifferenceFound(DifferenceType.HAS_XML_DECLARATION_PREFIX_ID,
controlNodeType, testNodeType, result);
readerToAdvance.Read();
- CompareNodes(result, controlReader, testReader);
+ CompareNodes(result, control, test);
} else {
DifferenceFound(DifferenceType.NODE_TYPE_ID, controlNodeType,
testNodeType, result);
}
}
- private void CompareElements(DiffResult result, XmlReader controlReader,
- XmlReader testReader) {
- string controlTagName = controlReader.Name;
- string testTagName = testReader.Name;
+ private void CompareElements(DiffResult result, ReaderWithState control,
+ ReaderWithState test) {
+ string controlTagName = control.Reader.Name;
+ string testTagName = test.Reader.Name;
if (!String.Equals(controlTagName, testTagName)) {
DifferenceFound(DifferenceType.ELEMENT_TAG_NAME_ID, result);
} else {
XmlAttribute[] controlAttributes =
- GetNonSpecialAttributes(controlReader);
- XmlAttribute[] testAttributes =
- GetNonSpecialAttributes(testReader);
+ GetNonSpecialAttributes(control);
+ XmlAttribute[] testAttributes = GetNonSpecialAttributes(test);
if (controlAttributes.Length != testAttributes.Length) {
DifferenceFound(DifferenceType.ELEMENT_NUM_ATTRIBUTES_ID, result);
}
@@ -191,10 +187,10 @@
}
}
- private void CompareText(DiffResult result, XmlReader controlReader,
- XmlReader testReader) {
- string controlText = controlReader.Value;
- string testText = testReader.Value;
+ private void CompareText(DiffResult result, ReaderWithState control,
+ ReaderWithState test) {
+ string controlText = control.Reader.Value;
+ string testText = test.Reader.Value;
if (!String.Equals(controlText, testText)) {
DifferenceFound(DifferenceType.TEXT_VALUE_ID, result);
}
@@ -224,34 +220,33 @@
}
private void CheckEmptyOrAtEndElement(DiffResult result,
- XmlReader controlReader,
- ref bool controlRead,
- XmlReader testReader,
- ref bool testRead) {
- if (controlReader.IsEmptyElement) {
- if (!testReader.IsEmptyElement) {
- CheckEndElement(testReader, ref testRead, result);
+ ReaderWithState control,
+ ReaderWithState test) {
+ if (control.Reader.IsEmptyElement) {
+ if (!test.Reader.IsEmptyElement) {
+ CheckEndElement(test, result);
}
} else {
- if (testReader.IsEmptyElement) {
- CheckEndElement(controlReader, ref controlRead, result);
+ if (test.Reader.IsEmptyElement) {
+ CheckEndElement(control, result);
}
}
}
- private XmlAttribute[] GetNonSpecialAttributes(XmlReader r) {
+ private XmlAttribute[] GetNonSpecialAttributes(ReaderWithState r) {
ArrayList l = new ArrayList();
- int length = r.AttributeCount;
+ int length = r.Reader.AttributeCount;
if (length > 0) {
XmlDocument doc = new XmlDocument();
- r.MoveToFirstAttribute();
+ r.Reader.MoveToFirstAttribute();
for (int i = 0; i < length; i++) {
- XmlAttribute a = doc.CreateAttribute(r.Name, r.NamespaceURI);
+ XmlAttribute a = doc.CreateAttribute(r.Reader.Name,
+ r.Reader.NamespaceURI);
if (!IsXMLNSAttribute(a)) {
+ a.Value = r.Reader.Value;
l.Add(a);
}
- a.Value = r.Value;
- r.MoveToNextAttribute();
+ r.Reader.MoveToNextAttribute();
}
}
return (XmlAttribute[]) l.ToArray(typeof(XmlAttribute));
@@ -301,22 +296,35 @@
return ns != null && ns.Length > 0;
}
- private void CheckEndElement(XmlReader reader, ref bool readResult, DiffResult result) {
- readResult = reader.Read();
- if (!readResult || reader.NodeType != XmlNodeType.EndElement) {
+ private void CheckEndElement(ReaderWithState reader, DiffResult result) {
+ bool readResult = reader.Read();
+ if (!readResult
+ || reader.Reader.NodeType != XmlNodeType.EndElement) {
DifferenceFound(DifferenceType.CHILD_NODELIST_LENGTH_ID, result);
- }
+ }
}
+ public string OptionalDescription {
+ get {
+ return _diffConfiguration.Description;
+ }
+ }
+
private class FlowControlException : ApplicationException {
public FlowControlException(Difference cause) : base(cause.ToString()) {
}
}
- public string OptionalDescription {
- get {
- return _diffConfiguration.Description;
+ private class ReaderWithState {
+ internal ReaderWithState(XmlReader reader) {
+ Reader = reader;
+ HasRead = false;
}
+ internal readonly XmlReader Reader;
+ internal bool HasRead;
+ internal bool Read() {
+ return HasRead = Reader.Read();
+ }
}
}
}
Modified: trunk/xmlunit/tests/csharp/XmlDiffTests.cs
===================================================================
--- trunk/xmlunit/tests/csharp/XmlDiffTests.cs 2008-12-15 12:29:52 UTC (rev 284)
+++ trunk/xmlunit/tests/csharp/XmlDiffTests.cs 2008-12-15 13:51:51 UTC (rev 285)
@@ -24,9 +24,12 @@
private void AssertExpectedResult(string input1, string input2, bool expected) {
TextReader reader1 = new StringReader(input1);
TextReader reader2 = new StringReader(input2);
+ System.Console.Error.WriteLine("comparing {0} to {1}", input1,
+ input2);
DiffResult result = PerformDiff(reader1, reader2);
- string msg = "comparing " + input1 + " to " + input2 + ": " + result.Difference;
- Assert.AreEqual(expected, result.Equal);
+ string msg = string.Format("comparing {0} to {1}: {2}", input1,
+ input2, result.Difference);
+ Assert.AreEqual(expected, result.Equal, msg);
}
private void AssertExpectedResult(string[] inputs1, string[] inputs2, bool expected) {
@@ -46,11 +49,27 @@
}
[Test] public void EqualResultForSameEmptyElements() {
- string[] input1 = {"<empty/>" , "<empty></empty>", "<elem><empty/></elem>", "<empty/>" };
- string[] input2 = {"<empty/>" , "<empty></empty>", "<elem><empty></empty></elem>", "<empty></empty>"};
+ string[] input1 = {"<empty/>", "<elem><empty/></elem>"};
+ string[] input2 = {"<empty></empty>", "<elem><empty></empty></elem>"};
+ System.Console.Error.WriteLine("ooooooooooooooooooooooooooooooooooooooooo");
+ try {
AssertExpectedResult(input1, input2, true);
+ } finally {
+ System.Console.Error.WriteLine("ooooooooooooooooooooooooooooooooooooooooo");
+ }
}
+ [Test] public void EqualResultForEmptyElementsWithAttributes() {
+ string[] input1 = {"<empty x='1'/>", "<elem><empty x='1'/></elem>"};
+ string[] input2 = {"<empty x='1'></empty>", "<elem><empty x='1'></empty></elem>"};
+ System.Console.Error.WriteLine("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+ try {
+ AssertExpectedResult(input1, input2, true);
+ } finally {
+ System.Console.Error.WriteLine("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+ }
+ }
+
[Test] public void NotEqualResultForEmptyVsNotEmptyElements() {
string[] input1 = {"<empty/>" , "<empty></empty>", "<empty><empty/></empty>"};
string[] input2 = {"<empty>text</empty>", "<empty>text</empty>", "<empty>text</empty>"};
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
