public static void VerifyTest(string actResult, string expResult)
{
XmlDiff.XmlDiff diff = new XmlDiff.XmlDiff();
diff.Option = XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.IgnoreAttributeOrder;
XmlTextReader xrActual = new XmlTextReader(new StringReader(actResult));
XmlTextReader xrExpected = new XmlTextReader(new StringReader(expResult));
bool bResult = false;
try
{
bResult = diff.Compare(xrActual, xrExpected);
}
catch (Exception e)
{
bResult = false;
s_output.WriteLine("Exception thrown in XmlDiff compare!");
s_output.WriteLine(e.ToString());
}
finally
{
if (xrActual != null) xrActual.Dispose();
if (xrExpected != null) xrExpected.Dispose();
}
s_output.WriteLine("Expected : " + expResult);
s_output.WriteLine("Actual : " + actResult);
if (bResult)
return;
else
Assert.True(false);
}
public BridgeHelpers()
{
_diff = new XmlDiff();
_rsx = new XmlReaderSettings();
_rsx.DtdProcessing = DtdProcessing.Ignore;
_rsxNoWs = new XmlReaderSettings();
_rsxNoWs.DtdProcessing = DtdProcessing.Ignore;
_rsxNoWs.IgnoreWhitespace = true;
Init();
}
public static bool CompareXml(Stream expectedStream, Stream actualStream, string xmldiffoptionvalue, DelayedWriteLogger logger)
{
bool bResult = false;
// Default Diff options used by XSLT V2 driver.
int defaultXmlDiffOptions = (int)(XmlDiffOption.InfosetComparison | XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.IgnoreAttributeOrder);
XmlDiff diff = new XmlDiff();
if (xmldiffoptionvalue == null || xmldiffoptionvalue.Equals(string.Empty))
diff.Option = (XmlDiffOption)defaultXmlDiffOptions;
else
{
if (logger != null) logger.LogMessage("Custom XmlDiffOptions used. Value passed is " + xmldiffoptionvalue);
diff.Option = (XmlDiffOption)Int32.Parse(xmldiffoptionvalue);
}
XmlParserContext context = new XmlParserContext(new NameTable(), null, "", XmlSpace.None);
try
{
bResult =
diff.Compare(new XmlTextReader(actualStream, XmlNodeType.Element, context),
new XmlTextReader(expectedStream, XmlNodeType.Element, context));
}
catch (Exception e)
{
bResult = false;
if (logger != null)
{
logger.LogMessage("Exception thrown in XmlDiff compare!");
logger.LogXml(e.ToString());
throw;
}
}
if (bResult)
return true;
if (logger != null)
{
logger.LogMessage("Mismatch in XmlDiff");
logger.LogMessage("Actual result: ");
}
return false;
}
public void VerifyResult(string actualFile, string baselineFile)
{
XmlDiff.XmlDiff diff = new XmlDiff.XmlDiff();
diff.Option = XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.IgnoreAttributeOrder;
XmlParserContext context = new XmlParserContext(new NameTable(), null, "", XmlSpace.None);
using (FileStream fsActual = new FileStream(actualFile, FileMode.Open, FileAccess.Read))
{
using (FileStream fsExpected = new FileStream(baselineFile, FileMode.Open, FileAccess.Read))
{
XmlTextReader xrActual = new XmlTextReader(fsActual, XmlNodeType.Element, context);
XmlTextReader xrExpected = new XmlTextReader(fsExpected, XmlNodeType.Element, context);
bool bResult = false;
try
{
bResult = diff.Compare(xrActual, xrExpected);
}
catch (Exception e)
{
bResult = false;
s_output.WriteLine("Exception thrown in XmlDiff compare!");
s_output.WriteLine(e.ToString());
}
s_output.WriteLine("Actual result: ");
this.WriteFile(actualFile);
if (bResult)
return;
else
{
s_output.WriteLine("Mismatch in XmlDiff");
Assert.True(false);
}
}
}
}
//VerifyResult which compares 2 arguments using XmlDiff.
public void VerifyResult(string baseline, string outputFile)
{
bool bResult = false;
FileStream fsExpected;
baseline = FullFilePath(baseline);
XmlDiff.XmlDiff diff = new XmlDiff.XmlDiff();
diff.Option = XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.IgnoreAttributeOrder | XmlDiffOption.InfosetComparison | XmlDiffOption.IgnoreWhitespace;
XmlParserContext context = new XmlParserContext(new NameTable(), null, "", XmlSpace.None);
fsExpected = new FileStream(baseline, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream fsActual = new FileStream(outputFile, FileMode.Open, FileAccess.Read, FileShare.Read);
_output.WriteLine("Verifying o/p with baseline result {0}...", baseline);
try
{
bResult = diff.Compare(new XmlTextReader(fsActual, XmlNodeType.Element, context), new XmlTextReader(fsExpected, XmlNodeType.Element, context));
}
catch (Exception e)
{
// TO DO: Write exception msgs in ignore tags
_output.WriteLine(e.ToString());
}
finally
{
fsExpected.Dispose();
fsActual.Dispose();
}
if (!bResult)
{
// Write out the actual and expected o/p
_output.WriteLine("Expected o/p: ");
using (StreamReader sr = new StreamReader(new FileStream(baseline, FileMode.Open, FileAccess.Read)))
{
string baseLine = sr.ReadToEnd();
_output.WriteLine(baseLine);
}
_output.WriteLine("Actual o/p: ");
using (StreamReader sr = new StreamReader(new FileStream(outputFile, FileMode.Open, FileAccess.Read)))
{
string output = sr.ReadToEnd();
_output.WriteLine(output);
}
using (StreamWriter sw = new StreamWriter(new FileStream("diff.xml", FileMode.Open, FileAccess.Read)))
{
sw.WriteLine("<?xml-stylesheet href='diff.xsl' type='text/xsl'?>");
sw.WriteLine(diff.ToXml());
}
}
if (bResult)
return;
else
{
_output.WriteLine("**** Baseline mis-matched ****");
Assert.True(false);
}
}
// --------------------------------------------------------------------------------------------------------------
// LoadXSL_Resolver_Evidence
// -------------------------------------------------------------------------------------------------------------
/*public int LoadXSL_Resolver_Evidence(String _strXslFile, XmlResolver xr, Evidence e)
{
_strXslFile = FullFilePath(_strXslFile);
xslt = new XslCompiledTransform();
switch (_nInputXsl)
{
case XslInputType.Reader:
switch (_readerType)
{
case ReaderType.XmlTextReader:
XmlReader trTemp = XmlReader.Create(_strXslFile);
try
{
_output.WriteLine("Loading style sheet as XmlTextReader " + _strXslFile);
//xslt.Load(trTemp, xr, e); //Evidence is not supported on V2 XSLT Load
xslt.Load(trTemp, XsltSettings.TrustedXslt, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (trTemp != null)
trTemp.Dispose();
}
break;
case ReaderType.XmlNodeReader:
XmlDocument docTemp = new XmlDocument();
docTemp.Load(_strXslFile);
XmlNodeReader nrTemp = new XmlNodeReader(docTemp);
try
{
_output.WriteLine("Loading style sheet as XmlNodeReader " + _strXslFile);
//xslt.Load(nrTemp, xr, e); Evidence is not supported in V2 XSLT Load
xslt.Load(nrTemp, XsltSettings.TrustedXslt, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (nrTemp != null)
nrTemp.Dispose();
}
break;
case ReaderType.XmlValidatingReader:
default:
XmlReaderSettings xrs = new XmlReaderSettings();
#pragma warning disable 0618
xrs.ProhibitDtd = false;
#pragma warning restore 0618
XmlReader vrTemp = null;
try
{
vrTemp = XmlReader.Create(_strXslFile, xrs);
_output.WriteLine("Loading style sheet as XmlValidatingReader " + _strXslFile);
//xslt.Load(vrTemp, xr, e); Evidence is not supported in V2 XSLT Load
xslt.Load(vrTemp, XsltSettings.TrustedXslt, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (vrTemp != null)
vrTemp.Dispose();
}
break;
}
break;
case XslInputType.Navigator:
XmlReader xrLoad = XmlReader.Create(_strXslFile);
XPathDocument xdTemp = new XPathDocument(xrLoad, XmlSpace.Preserve);
xrLoad.Dispose();
_output.WriteLine("Loading style sheet as Navigator " + _strXslFile);
xslt.Load(xdTemp.CreateNavigator(), XsltSettings.TrustedXslt, xr);
break;
}
return 1;
}*/
//VerifyResult
public void VerifyResult(string expectedValue)
{
XmlDiff.XmlDiff xmldiff = new XmlDiff.XmlDiff();
xmldiff.Option = XmlDiffOption.InfosetComparison | XmlDiffOption.IgnoreEmptyElement;
StreamReader sr = new StreamReader(new FileStream("out.xml", FileMode.Open, FileAccess.Read));
string actualValue = sr.ReadToEnd();
sr.Dispose();
//Output the expected and actual values
_output.WriteLine("Expected : " + expectedValue);
_output.WriteLine("Actual : " + actualValue);
//Load into XmlTextReaders
XmlTextReader tr1 = new XmlTextReader("out.xml");
XmlTextReader tr2 = new XmlTextReader(new StringReader(expectedValue));
bool bResult = xmldiff.Compare(tr1, tr2);
//Close the readers
tr1.Dispose();
tr2.Dispose();
if (bResult)
return;
else
Assert.True(false);
}
public SaveWithWriter()
{
_diff = new XmlDiff();
}
public XStreamingElementAPI()
{
_diff = new XmlDiff();
}
public void OS11(object param0, object param1)
{
Init(param0.ToString(), param1.ToString());
_xsl.Load(_xslFile);
//Transform to Stream
Stream stm1 = new FileStream("out1.xml", FileMode.Create, FileAccess.ReadWrite);
_output.WriteLine("Transforming to Stream1 - 'out1.xml'");
_xsl.Transform(_xmlFile, null, stm1);
//Create an XmlWriter using OutputSettings
Stream stm2 = new FileStream("out2.xml", FileMode.Create, FileAccess.ReadWrite);
XmlWriterSettings os = _xsl.OutputSettings;
XmlWriter xw = XmlWriter.Create(stm2, os);
//Transform to XmlWriter
_output.WriteLine("Transforming to XmlWriter over Stream2 with XSLT OutputSettings - 'out2.xml'");
_xsl.Transform(_xmlFile, null, xw);
//Close the streams
stm1.Dispose();
stm2.Dispose();
//XmlDiff the 2 Outputs.
XmlDiff.XmlDiff diff = new XmlDiff.XmlDiff();
XmlReader xr1 = XmlReader.Create("out1.xml");
XmlReader xr2 = XmlReader.Create("out2.xml");
//XmlDiff
_output.WriteLine("Comparing the Stream Output and XmlWriter Output");
Assert.True(diff.Compare(xr1, xr2));
//Delete the temp files
xr1.Dispose();
xr2.Dispose();
File.Delete("out1.xml");
File.Delete("out2.xml");
return;
}
//[Variation(Desc = "Manually declared prefix-namespace pair is not reflected in the XElement serialization")]
public void ManuallyDeclaredPrefixNamespacePairIsNotReflectedInTheXElementSerialization()
{
var element = XElement.Parse("<A/>");
element.Add(new XAttribute(XNamespace.Xmlns + "p", "ns"));
element.Add(new XElement("{ns}B", null));
MemoryStream sourceStream = new MemoryStream();
element.Save(sourceStream);
sourceStream.Position = 0;
// creating the following element with expected output so we can compare
XElement target = XElement.Parse("<A xmlns:p=\"ns\"><p:B /></A>");
MemoryStream targetStream = new MemoryStream();
target.Save(targetStream);
targetStream.Position = 0;
XmlDiff diff = new XmlDiff();
if (!diff.Compare(sourceStream, targetStream))
throw new TestException(TestResult.Failed, "");
}
// --------------------------------------------------------------------------------------------------------------
// LoadXSL_Resolver_Evidence
// -------------------------------------------------------------------------------------------------------------
/*public int LoadXSL_Resolver_Evidence(String _strXslFile, XmlResolver xr, Evidence e)
{
_strXslFile = FullFilePath(_strXslFile);
#pragma warning disable 0618
xslt = new XslTransform();
#pragma warning restore 0618
switch (_nInput)
{
case InputType.Reader:
switch (_readerType)
{
case ReaderType.XmlTextReader:
XmlTextReader trTemp = new XmlTextReader(_strXslFile);
try
{
_output.WriteLine("Loading style sheet as XmlTextReader {0}", _strXslFile);
xslt.Load(trTemp, xr, e);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (trTemp != null)
trTemp.Dispose();
}
break;
case ReaderType.XmlNodeReader:
XmlDocument docTemp = new XmlDocument();
docTemp.Load(_strXslFile);
XmlNodeReader nrTemp = new XmlNodeReader(docTemp);
try
{
_output.WriteLine("Loading style sheet as XmlNodeReader {0}", _strXslFile);
xslt.Load(nrTemp, xr, e);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (nrTemp != null)
nrTemp.Dispose();
}
break;
case ReaderType.XmlValidatingReader:
default:
#pragma warning disable 0618
XmlValidatingReader vrTemp = new XmlValidatingReader(new XmlTextReader(_strXslFile));
#pragma warning restore 0618
vrTemp.ValidationType = ValidationType.None;
vrTemp.EntityHandling = EntityHandling.ExpandEntities;
try
{
_output.WriteLine("Loading style sheet as XmlValidatingReader {0}", _strXslFile);
xslt.Load(vrTemp, xr, e);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (vrTemp != null)
vrTemp.Dispose();
}
break;
}
break;
case InputType.Navigator:
#pragma warning disable 0618
XmlValidatingReader xrLoad = new XmlValidatingReader(new XmlTextReader(_strXslFile));
#pragma warning restore 0618
XPathDocument xdTemp = new XPathDocument(xrLoad, XmlSpace.Preserve);
xrLoad.Dispose();
_output.WriteLine("Loading style sheet as Navigator {0}", _strXslFile);
xslt.Load(xdTemp.CreateNavigator(), xr, e);
break;
}
return 1;
}*/
//VerifyResult
public void VerifyResult(string expectedValue)
{
lock(s_outFileMemoryLock)
{
XmlDiff.XmlDiff xmldiff = new XmlDiff.XmlDiff();
xmldiff.Option = XmlDiffOption.InfosetComparison | XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.NormalizeNewline;
string actualValue = File.ReadAllText(_strOutFile);
//Output the expected and actual values
_output.WriteLine("Expected : " + expectedValue);
_output.WriteLine("Actual : " + actualValue);
bool result;
//Load into XmlTextReaders
using (XmlTextReader tr1 = new XmlTextReader(_strOutFile))
using (XmlTextReader tr2 = new XmlTextReader(new StringReader(expectedValue)))
{
result = xmldiff.Compare(tr1, tr2);
}
Assert.True(result);
}
}
public bool CompareReader(XmlReader xrExpected, XmlDiffOption option)
{
bool bReturn = false;
XmlReader xrActual = GetReader();
XmlDiff diff = new XmlDiff();
diff.Option = option;
try
{
bReturn = diff.Compare(xrExpected, xrActual);
}
catch (Exception e)
{
CError.WriteLine(e);
}
finally
{
xrActual.Dispose();
xrExpected.Dispose();
}
if (!bReturn)
{
CError.WriteLine("Mismatch in XmlDiff");
CError.WriteLine("Actual o/p:");
CError.WriteLine(this.GetString());
}
return bReturn;
}
public TCEOFHandling()
{
_diff = new XmlDiff();
}
public LoadFromReader()
{
_diff = new XmlDiff();
}
