private XPathNavigator GetNavigator(XmlInput forXmlInput)
{
XPathDocument xpathDocument =
new XPathDocument(forXmlInput.CreateXmlReader());
return(xpathDocument.CreateNavigator());
}
public XmlDiff(XmlInput control, XmlInput test,
DiffConfiguration diffConfiguration) {
_diffConfiguration = diffConfiguration;
_controlReader = CreateXmlReader(control);
if (control.Equals(test)) {
_testReader = _controlReader;
} else {
_testReader = CreateXmlReader(test);
}
}
public string EvaluateXPath(XmlInput forXmlInput)
{
XPathNavigator xpathNavigator = GetNavigator(forXmlInput);
XPathExpression xPathExpression = xpathNavigator.Compile(_xPathExpression);
if (xPathExpression.ReturnType == XPathResultType.NodeSet) {
return EvaluateXPath(xpathNavigator);
} else {
return xpathNavigator.Evaluate(xPathExpression).ToString();
}
}
public XmlDiff(XmlInput control, XmlInput test,
DiffConfiguration diffConfiguration)
{
_diffConfiguration = diffConfiguration;
_controlReader = CreateXmlReader(control);
if (control.Equals(test))
{
_testReader = _controlReader;
}
else
{
_testReader = CreateXmlReader(test);
}
}
public string EvaluateXPath(XmlInput forXmlInput)
{
XPathNavigator xpathNavigator = GetNavigator(forXmlInput);
XPathExpression xPathExpression = xpathNavigator.Compile(_xPathExpression);
if (xPathExpression.ReturnType == XPathResultType.NodeSet)
{
return(EvaluateXPath(xpathNavigator));
}
else
{
return(xpathNavigator.Evaluate(xPathExpression).ToString());
}
}
public void StreamInputTranslatesToXmlReader()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream, Encoding.Default);
writer.WriteLine(INPUT);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
XmlInput input = new XmlInput(stream);
string actual = ReadOuterXml(input.CreateXmlReader());
try {
Assert.AreEqual(_expected, actual);
} finally {
writer.Close();
}
}
private XmlReader CreateXmlReader(XmlInput forInput)
{
XmlReader xmlReader = forInput.CreateXmlReader();
if (xmlReader is XmlTextReader)
{
((XmlTextReader)xmlReader).WhitespaceHandling = _diffConfiguration.WhitespaceHandling;
}
if (_diffConfiguration.UseValidatingParser)
{
XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
return(validatingReader);
}
return(xmlReader);
}
public Xslt(XmlInput xsltInput, XmlResolver xsltResolver, Evidence evidence)
{
_xsltInput = xsltInput;
_xsltResolver = xsltResolver;
_evidence = evidence;
}
public XmlOutput Transform(XmlInput someXml)
{
return(Transform(someXml, null));
}
public bool XPathExists(XmlInput forInput)
{
XPathNodeIterator iterator = GetNodeIterator(forInput);
return (iterator.Count > 0);
}
public void EqualsSelf()
{
XmlInput input = new XmlInput(INPUT);
Assert.AreEqual(input, input);
}
public static void XslTransformResults(XmlInput xslTransform, XmlInput xmlToTransform, XmlInput expectedResult)
{
Xslt xslt = new Xslt(xslTransform);
XmlOutput output = xslt.Transform(xmlToTransform);
XmlEquals(expectedResult, output.AsXml());
}
public Xslt(XmlInput xsltInput)
: this(xsltInput, null, null)
{
}
public Xslt(XmlInput xsltInput, XmlResolver xsltResolver, Evidence evidence)
{
_xsltInput = xsltInput;
_xsltResolver = xsltResolver;
_evidence = evidence;
}
public void TextReaderInputTranslatesToXmlReader()
{
XmlInput input = new XmlInput(new StringReader(INPUT));
string actual = ReadOuterXml(input.CreateXmlReader());
Assert.AreEqual(_expected, actual);
}
public void NotEqualsNull()
{
XmlInput input = new XmlInput(INPUT);
Assert.AreEqual(false, input.Equals(null));
}
public void NotEqualsADifferentClass()
{
XmlInput input = new XmlInput(INPUT);
Assert.AreEqual(false, input.Equals(INPUT));
}
public void HashCodeEqualsHashCodeOfInput()
{
XmlInput input = new XmlInput(INPUT);
Assert.AreEqual(INPUT.GetHashCode(), input.GetHashCode());
}
private XPathNodeIterator GetNodeIterator(XmlInput forXmlInput)
{
XPathNavigator xpathNavigator = GetNavigator(forXmlInput);
return(xpathNavigator.Select(_xPathExpression));
}
public XmlOutput Transform(XmlInput someXml)
{
return Transform(someXml, null);
}
public Validator(XmlInput input) :
this(input.CreateXmlReader())
{
}
public XmlDiff(XmlInput control, XmlInput test)
: this(control, test, new DiffConfiguration())
{
}
public static void XmlEquals(XmlInput controlInput, XmlInput testInput)
{
XmlEquals(new XmlDiff(controlInput, testInput));
}
private XPathNodeIterator GetNodeIterator(XmlInput forXmlInput)
{
XPathNavigator xpathNavigator = GetNavigator(forXmlInput);
return xpathNavigator.Select(_xPathExpression);
}
public XmlOutput Transform(XmlInput someXml, XsltArgumentList xsltArgs)
{
return Transform(someXml.CreateXmlReader(), null, xsltArgs);
}
public void EqualsCopyOfSelf()
{
XmlInput input = new XmlInput(INPUT);
Assert.AreEqual(new XmlInput(INPUT), input);
}
private XPathNavigator GetNavigator(XmlInput forXmlInput)
{
XPathDocument xpathDocument =
new XPathDocument(forXmlInput.CreateXmlReader());
return xpathDocument.CreateNavigator();
}
public void AssertXslTransformResultsCatchesFalsePositive()
{
StreamReader xsl = ValidatorTests.GetTestReader("animal.xsl");
XmlInput xslt = new XmlInput(xsl);
StreamReader xml = ValidatorTests.GetTestReader("testAnimal.xml");
XmlInput xmlToTransform = new XmlInput(xml);
XmlInput expectedXml = new XmlInput("<cat/>");
bool exceptionExpected = true;
try {
XmlAssert.XslTransformResults(xslt, xmlToTransform, expectedXml);
exceptionExpected = false;
Assert.Fail("Expected dog not cat!");
} catch (AssertionException e) {
AvoidUnusedVariableCompilerWarning(e);
if (exceptionExpected) {
throw e;
}
}
}
public void AssertXslTransformResultsWorksWithXmlInput()
{
StreamReader xsl = ValidatorTests.GetTestReader("animal.xsl");
XmlInput xslt = new XmlInput(xsl);
StreamReader xml = ValidatorTests.GetTestReader("testAnimal.xml");
XmlInput xmlToTransform = new XmlInput(xml);
XmlInput expectedXml = new XmlInput("<dog/>");
XmlAssert.XslTransformResults(xslt, xmlToTransform, expectedXml);
}
public static void XmlIdentical(XmlInput controlInput, XmlInput testInput)
{
XmlIdentical(new XmlDiff(controlInput, testInput));
}
public Validator(XmlInput input)
: this(input.CreateXmlReader())
{
}
public static void XmlValid(XmlInput xmlInput)
{
Validator validator = new Validator(xmlInput);
XmlValid(validator);
}
public XmlOutput Transform(XmlInput someXml, XsltArgumentList xsltArgs)
{
return(Transform(someXml.CreateXmlReader(), null, xsltArgs));
}
public static void XPathEvaluatesTo(string anXPathExpression, XmlInput inXml,
string expectedValue)
{
XPath xpath = new XPath(anXPathExpression);
Assert.AreEqual(expectedValue, xpath.EvaluateXPath(inXml));
}
public Xslt(XmlInput xsltInput)
: this(xsltInput, null, null)
{
}
public XmlDiff(XmlInput control, XmlInput test)
: this(control, test, new DiffConfiguration()) {
}
public bool XPathExists(XmlInput forInput)
{
XPathNodeIterator iterator = GetNodeIterator(forInput);
return(iterator.Count > 0);
}
public static void XslTransformResults(string xslTransform, string xmlToTransform, string expectedResult)
{
XmlInput xsl = new XmlInput(xslTransform);
XmlInput xml2 = new XmlInput(xmlToTransform);
XmlInput xmlEx = new XmlInput(expectedResult);
XslTransformResults(xsl, xml2, xmlEx);
}
public static void XPathExists(string anXPathExpression, XmlInput inXml)
{
XPath xpath = new XPath(anXPathExpression);
Assert.AreEqual(true, xpath.XPathExists(inXml));
}
private XmlReader CreateXmlReader(XmlInput forInput) {
XmlReader xmlReader = forInput.CreateXmlReader();
if (xmlReader is XmlTextReader) {
((XmlTextReader) xmlReader ).WhitespaceHandling = _diffConfiguration.WhitespaceHandling;
}
if (_diffConfiguration.UseValidatingParser) {
XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
return validatingReader;
}
return xmlReader;
}
