internal static bool CompareXML(XDocument xmlDocument1, XDocument xmlDocument2)
{
XmlDiff diff = new XmlDiff();
diff.IgnoreChildOrder = true;
diff.IgnoreXmlDecl = true;
diff.IgnoreWhitespace = true;
diff.IgnoreComments = true;
diff.IgnorePI = true;
diff.IgnoreDtd = true;
var doc1 = new XmlDocument();
doc1.LoadXml(xmlDocument1.ToString());
var doc2 = new XmlDocument();
doc2.LoadXml(xmlDocument2.ToString());
bool result = diff.Compare(doc1, doc2);
return result;
}
public void TestSerialization()
{
MSBuildCodeMetricsReport report = MSBuildCodeMetricsReport.Create().CreateSummary().Report.CreateDetails().Report;
report.Summary.AddMetric("VisualStudioMetrics", _cyclomaticComplexity).CreateRanges().
AddRange("> 10", 5).
AddRange("<= 10 and > 5", 3).
AddRange("<= 5", 1);
report.Summary.AddMetric("VisualStudioMetrics", _linesOfCode).CreateRanges().
AddRange("> 100", 5).
AddRange("<= 100 and > 50", 3).
AddRange("<= 50", 1);
report.Details.AddMetric("VisualStudioMetrics", _cyclomaticComplexity).CreateMeasures().
AddMeasure("Method1() : void", 100).
AddMeasure("Method2() : void", 50);
report.Details.AddMetric("VisualStudioMetrics", _linesOfCode).CreateMeasures().
AddMeasure("Method1() : void", 1000).
AddMeasure("Method2() : void", 500);
Stream ms = report.SerializeToMemoryStream(true);
XmlDiff diff = new XmlDiff();
Assert.IsTrue(diff.Compare(_expectedReportStream, ms));
}
internal static void Equal(string file1, string file2)
{
var diffFile = @"diff.xml";
XmlTextWriter tw = new XmlTextWriter(new StreamWriter(diffFile));
tw.Formatting = Formatting.Indented;
var diff = new XmlDiff();
diff.Options = XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl;
var result = diff.Compare(file1, file2, false, tw);
tw.Close();
if (!result)
{
//Files were not equal, so construct XmlDiffView.
XmlDiffView dv = new XmlDiffView();
//Load the original file again and the diff file.
XmlTextReader orig = new XmlTextReader(file1);
XmlTextReader diffGram = new XmlTextReader(diffFile);
dv.Load(orig, diffGram);
string tempFile = "test.htm";
StreamWriter sw1 = new StreamWriter(tempFile);
//Wrapping
sw1.Write("<html><body><table>");
sw1.Write("<tr><td><b>");
sw1.Write(file1);
sw1.Write("</b></td><td><b>");
sw1.Write(file2);
sw1.Write("</b></td></tr>");
//This gets the differences but just has the
//rows and columns of an HTML table
dv.GetHtml(sw1);
//Finish wrapping up the generated HTML and
//complete the file by putting legend in the end just like the
//online tool.
sw1.Write("<tr><td><b>Legend:</b> <font style='background-color: yellow'" +
" color='black'>added</font> <font style='background-color: red'" +
"color='black'>removed</font> <font style='background-color: " +
"lightgreen' color='black'>changed</font> " +
"<font style='background-color: red' color='blue'>moved from</font>" +
" <font style='background-color: yellow' color='blue'>moved to" +
"</font> <font style='background-color: white' color='#AAAAAA'>" + "ignored</font></td></tr>");
sw1.Write("</table></body></html>");
//HouseKeeping...close everything we dont want to lock.
sw1.Close();
orig.Close();
diffGram.Close();
Process.Start("test.htm");
}
Assert.True(result);
}
public XElement GenerateDiffGram(XElement element1, XElement element2) {
using (var node1Reader = element1.CreateReader())
using (var node2Reader = element2.CreateReader()) {
var result = new XDocument();
using (var writer = result.CreateWriter()) {
var diff = new XmlDiff(XmlDiffOptions.IgnoreChildOrder | XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl);
diff.Compare(node1Reader, node2Reader, writer);
writer.Flush();
writer.Close();
}
return result.Root;
}
}
public static void DiffXmlStrict(string actual, string expected)
{
XmlDocument expectedDoc;
XmlDocument actualDoc;
try
{
expectedDoc = new XmlDocument();
expectedDoc.LoadXml(expected);
}
catch (XmlException e)
{
throw new Exception("Expected: " + e.Message + "\r\n" + expected);
}
try
{
actualDoc = new XmlDocument();
actualDoc.LoadXml(actual);
}
catch (XmlException e)
{
throw new Exception("Actual: " + e.Message + "\r\n" + actual);
}
using (var stringWriter = new StringWriter())
using (var writer = new XmlTextWriter(stringWriter))
{
writer.Formatting = Formatting.Indented;
var xmldiff = new XmlDiff(XmlDiffOptions.None
//XmlDiffOptions.IgnoreChildOrder |
| XmlDiffOptions.IgnoreNamespaces
//XmlDiffOptions.IgnorePrefixes
);
var identical = xmldiff.Compare(expectedDoc, actualDoc, writer);
if (!identical)
{
var error = string.Format("Expected:\r\n{0}\r\n\r\n" + "Actual:\r\n{1}\r\n\r\nDiff:\r\n{2}",
expected, actual, stringWriter.GetStringBuilder());
throw new Exception(error);
}
}
}
public static bool CompareJson(string expected, string actual)
{
var expectedDoc = JsonConvert.DeserializeXmlNode(expected, "root");
var actualDoc = JsonConvert.DeserializeXmlNode(actual, "root");
var diff = new XmlDiff(XmlDiffOptions.IgnoreWhitespace |
XmlDiffOptions.IgnoreChildOrder);
using (var ms = new MemoryStream())
{
var writer = new XmlTextWriter(ms, Encoding.UTF8);
var result = diff.Compare(expectedDoc, actualDoc, writer);
if (!result)
{
ms.Seek(0, SeekOrigin.Begin);
Console.WriteLine(new StreamReader(ms).ReadToEnd());
}
return result;
}
}
public void Serializable()
{
XmlDiff diff = new XmlDiff();
LayoutBox layoutBox = LayoutBox.LoadFromString(LayoutingResource.LayoutsDefault);
String result = layoutBox.Serialize();
diff.IgnoreChildOrder = true;
diff.IgnoreComments = true;
diff.IgnoreDtd = true;
diff.IgnoreNamespaces = true;
diff.IgnorePI = true;
diff.IgnorePrefixes = true;
diff.IgnoreWhitespace = true;
diff.IgnoreXmlDecl = true;
StringWriter diffgramString = new StringWriter();
XmlTextWriter diffgramXml = new XmlTextWriter(diffgramString);
bool diffBool = diff.Compare(new XmlTextReader(new StringReader(result)), new XmlTextReader(new StringReader(LayoutingResource.LayoutsDefault)), diffgramXml);
//MessageBox.Show(diffgramString.ToString());
Assert.True(diffBool);
}
/// <summary>
/// Compares the two XML files and throws an error if they are different.
/// </summary>
public static void Compare(XmlDocument expected, XmlDocument actual)
{
XmlNamespaceManager ns = new XmlNamespaceManager(expected.NameTable);
ns.AddNamespace("tst", "http://schemas.asidua.com/testing");
var diffReport = new StringBuilder();
// Remove the ignored nodes from both XML documents
foreach (XmlAttribute ignored in expected.SelectNodes("//@tst:IGNORE[.='Content']", ns))
{
string xpath = generateXPath(ignored.OwnerElement);
// Remove the node's content from the expected results
ignored.OwnerElement.InnerText = "";
ignored.OwnerElement.RemoveAttribute(ignored.Name);
// Remove the node's content from the actual results
var node = actual.SelectSingleNode(xpath);
if (node != null) node.InnerText = "";
}
XmlDiff comparer = new XmlDiff();
comparer.Options = XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreNamespaces | XmlDiffOptions.IgnorePrefixes | XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreXmlDecl;
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = true,
};
using (var writer = XmlWriter.Create(diffReport, settings))
{
Assert.IsTrue(
comparer.Compare(expected, actual, writer),
"Expected Results:\n{0}\n\n" +
"Actual Results:\n{1}\n\n" +
"Difference Report:\n{2}",
formatXml(expected), formatXml(actual), diffReport
);
}
}
private void DoCompare(string changed)
{
CleanupTempFiles();
XmlDocument original = this.model.Document;
XmlDocument doc = new XmlDocument();
XmlReaderSettings settings = model.GetReaderSettings();
using (XmlReader reader = XmlReader.Create(changed, settings)) {
doc.Load(reader);
}
string startupPath = Application.StartupPath;
//output diff file.
string diffFile = Path.Combine(Path.GetTempPath(),
Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".xml");
this.tempFiles.AddFile(diffFile, false);
bool isEqual = false;
XmlTextWriter diffWriter = new XmlTextWriter(diffFile, Encoding.UTF8);
diffWriter.Formatting = Formatting.Indented;
using (diffWriter) {
XmlDiff diff = new XmlDiff();
isEqual = diff.Compare(original, doc, diffWriter);
diff.Options = XmlDiffOptions.None;
}
if (isEqual) {
//This means the files were identical for given options.
MessageBox.Show(this, SR.FilesAreIdenticalPrompt, SR.FilesAreIdenticalCaption,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
string tempFile = Path.Combine(Path.GetTempPath(),
Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".htm");
tempFiles.AddFile(tempFile, false);
using (XmlReader diffGram = XmlReader.Create(diffFile, settings)) {
XmlDiffView diffView = new XmlDiffView();
diffView.Load(new XmlNodeReader(original), diffGram);
using (TextWriter htmlWriter = new StreamWriter(tempFile)) {
SideBySideXmlNotepadHeader(this.model.FileName, changed, htmlWriter);
diffView.GetHtml(htmlWriter);
}
}
/*
Uri uri = new Uri(tempFile);
WebBrowserForm browserForm = new WebBrowserForm(uri, "XmlDiff");
browserForm.Show();
*/
}
/// <summary>
/// Compares table columns from two distinct XML schema files. These files are generated by the SerializeDB method.
/// This method is called from the CompareTables method.
/// </summary>
/// <param name="tableName">The string value representing the current SQL table object.</param>
/// <param name="xnlSource">The XmlNodeList, a collection of source XML nodes to compare with the destination XML
/// nodes.</param>
/// <param name="xnlDestination">The XmlNodeList, a collection of destination/target XML nodes to compare with the
/// source XML nodes.</param>
/// <param name="xmlDiffDoc">The XML Diffgram object to update.</param>
/// <param name="xmlDiff">The XmlDiff Object used from the GotDotNet XmlDiff class. Performs the XML node compare.</param>
private static void CompareColumns(string tableName, XmlNodeList xnlSource, XmlNodeList xnlDestination,
XmlDocument xmlDiffDoc, XmlDiff xmlDiff)
{
SQLObjects.ColumnCollection tableColumns = new SQLObjects.ColumnCollection(tableName);
Hashtable htDropAdd = new Hashtable();
// compare source columns to destination columns, looking for changed or missing destination columns
if (xnlSource != null)
{
// if a matching destination table was found with columns
if (xnlDestination != null)
{
tableColumns.SchemaAction = SQLObjects.COLUMN.ColumnAction.Alter;
// identify the source columns that are different
foreach (XmlNode xn in xnlSource)
{
string column_Name = xn.ChildNodes[1].InnerXml;
XmlNode Found = FindNode(xnlDestination, column_Name, "<Column_Name>{0}</Column_Name>");
// look for existing columns
if (Found != null)
{
// if the columns don't compare then
if (!xmlDiff.Compare(xn, Found))
{
SQLObjects.COLUMN col = new SQLObjects.COLUMN();
col.Action = SQLObjects.COLUMN.ColumnAction.Alter;
// add original_rules from the destination column so that if they are not on the source columns we can exec sp_unbindrule on them.
// There is XSLT code to handle sp_bindrule for the source columns where they were not bound to the destination(original) column.
// IF the source and destination rule names are the same, then we should be able to ignore changing the column bound rule
XmlNode xnRule = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "RULE_ORIG_NAME", xn.OwnerDocument.NamespaceURI);
if (Found.SelectSingleNode("Rule_Name") != null)
{
xnRule.InnerXml = Found.SelectSingleNode("Rule_Name").InnerXml;
xn.AppendChild(xnRule);
}
xnRule = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "RULE_ORIG_OWNER", xn.OwnerDocument.NamespaceURI);
if (Found.SelectSingleNode("Rule_Owner") != null)
{
xnRule.InnerXml = Found.SelectSingleNode("Rule_Owner").InnerXml;
xn.AppendChild(xnRule);
}
XmlNode xnDefault = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "DEFAULT_ORIG_NAME", xn.OwnerDocument.NamespaceURI);
if (Found.SelectSingleNode("Default_Name") != null)
{
xnDefault.InnerXml = Found.SelectSingleNode("Default_Name").InnerXml;
xn.AppendChild(xnDefault);
}
xnDefault = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "DEFAULT_ORIG_VALUE", xn.OwnerDocument.NamespaceURI);
if (Found.SelectSingleNode("Default_Value") != null)
{
xnDefault.InnerXml = Found.SelectSingleNode("Default_Value").InnerXml;
xn.AppendChild(xnDefault);
}
XmlNode xnRowGuidCol = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "ORIG_RowGuidCol", xn.OwnerDocument.NamespaceURI);
if (Found.SelectSingleNode("isRowGuidCol") != null)
{
xnRowGuidCol.InnerXml = Found.SelectSingleNode("isRowGuidCol").InnerXml;
xn.AppendChild(xnRowGuidCol);
}
// lookup any altered columns to see if there are Reference dependencies
// may need to use something like this: descendant::*[contains(local-name(),'cKeyCol')]
for (int x = 1; x < 17; x++)
{
if (Found.SelectSingleNode("../TABLE_REFERENCE/cRefCol" + x.ToString()) != null)
{
CheckColumnDependencies(column_Name, tableName, "DropAdd_References", "TABLE_REFERENCE", "Constraint", "cRefCol" + x.ToString(),
false, ref htDropAdd, Found, xn, xmlDiffDoc);
}
}
// lookup any altered columns to see if there are Constraint dependencies
CheckColumnDependencies(column_Name, tableName, "DropAdd_Constraints", "TABLE_CONSTRAINTS", "CONSTRAINT_NAME", "COLUMN_NAME",
false, ref htDropAdd, Found, xn, xmlDiffDoc);
// lookup any altered columns to see if there are index dependencies
CheckColumnDependencies(column_Name, tableName, "DropAdd_Indexes", "TABLE_INDEX", "index_name", "index_keys",
false, ref htDropAdd, Found, xn, xmlDiffDoc);
// add xml node to the table columns collection
SQLObjects.COLUMN c = col.Convert(xn);
tableColumns.Add(c);
}
else
continue;
}
else // the column was not found in the destination table
{
SQLObjects.COLUMN col = new SQLObjects.COLUMN();
col.Action = SQLObjects.COLUMN.ColumnAction.Add;
tableColumns.Add(col.Convert(xn));
}
}
}
else // no destination table so add all the columns
{
foreach (XmlNode xn in xnlSource)
{
string column_Name = xn.ChildNodes[1].InnerXml;
SQLObjects.COLUMN col = new SQLObjects.COLUMN();
col.Action = SQLObjects.COLUMN.ColumnAction.Add;
tableColumns.Add(col.Convert(xn));
}
}
}
// look for desination columns not in the source table, so as to mark the desination columns to drop
if (xnlDestination != null)
{
if (xnlSource != null)
{
tableColumns.SchemaAction = SQLObjects.COLUMN.ColumnAction.Alter;
// identify the destination columns that are missing
foreach (XmlNode xn in xnlDestination)
{
string column_Name = xn.ChildNodes[1].InnerXml;
XmlNode Found = FindNode(xnlSource, column_Name, "<Column_Name>{0}</Column_Name>");
if (Found == null)
{
SQLObjects.COLUMN col = new SQLObjects.COLUMN();
col.Action = SQLObjects.COLUMN.ColumnAction.Drop;
XmlNode xnRule = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "RULE_ORIG_NAME", xn.OwnerDocument.NamespaceURI);
if (xn.SelectSingleNode("Rule_Name") != null)
{
xnRule.InnerXml = xn.SelectSingleNode("Rule_Name").InnerXml;
xn.AppendChild(xnRule);
}
xnRule = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "RULE_ORIG_OWNER", xn.OwnerDocument.NamespaceURI);
if (xn.SelectSingleNode("Rule_Owner") != null)
{
xnRule.InnerXml = xn.SelectSingleNode("Rule_Owner").InnerXml;
xn.AppendChild(xnRule);
}
XmlNode xnDefault = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "DEFAULT_ORIG_NAME", xn.OwnerDocument.NamespaceURI);
if (xn.SelectSingleNode("Default_Name") != null)
{
xnDefault.InnerXml = xn.SelectSingleNode("Default_Name").InnerXml;
xn.AppendChild(xnDefault);
}
xnDefault = xn.OwnerDocument.CreateNode(XmlNodeType.Element, "DEFAULT_ORIG_VALUE", xn.OwnerDocument.NamespaceURI);
if (xn.SelectSingleNode("Default_Value") != null)
{
xnDefault.InnerXml = xn.SelectSingleNode("Default_Value").InnerXml;
xn.AppendChild(xnDefault);
}
// lookup any dropped columns to see if there are Reference dependencies,
// may need to use something like this: descendant::*[contains(local-name(),'cKeyCol')]
for (int x = 1; x < 17; x++)
{
if (xn.SelectSingleNode("../TABLE_REFERENCE/cRefCol" + x.ToString()) != null)
{
CheckColumnDependencies(column_Name, tableName, "DropAdd_References", "TABLE_REFERENCE", "Constraint", "cRefCol" + x.ToString(),
true, ref htDropAdd, null, xn, xmlDiffDoc);
}
}
// lookup any altered columns to see if there are Constraint dependencies
CheckColumnDependencies(column_Name, tableName, "DropAdd_Constraints", "TABLE_CONSTRAINTS", "CONSTRAINT_NAME", "COLUMN_NAME",
true, ref htDropAdd, null, xn, xmlDiffDoc);
// lookup any dropped columns to see if there are index dependencies
CheckColumnDependencies(column_Name, tableName, "DropAdd_Indexes", "TABLE_INDEX", "index_name", "index_keys",
true, ref htDropAdd, null, xn, xmlDiffDoc);
tableColumns.Add(col.Convert(xn));
}
}
}
}
// persist the tableColumns collection as XML if there are any
if (tableColumns.Count > 0)
{
XmlNode xTableColumns = tableColumns.SerializeAsXmlNode(xmlDiffDoc);
foreach (object obj in htDropAdd.Values)
{
xTableColumns.AppendChild((XmlNode)obj);
}
xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xTableColumns);
}
}
/// <summary>
/// Compare the xml data files
/// </summary>
/// <param name="sourceXmlFile">baseline file</param>
/// <param name="changedXmlFile">actual file</param>
/// <param name="fragment">xml data fragment</param>
/// <param name="options">comparison options</param>
/// <returns>data is identical</returns>
private bool GenerateDiffGram(
string sourceXmlFile,
string changedXmlFile,
bool fragment,
XmlDiffOptions options)
{
// set class scope variables
// MemoryStream diffgram
bool identicalData;
this.diffgram = new MemoryStream();
XmlTextWriter diffgramWriter = new XmlTextWriter(
new StreamWriter(this.diffgram));
Trace.WriteLine("Comparing " + sourceXmlFile +
" & " + changedXmlFile);
XmlDiffOptions xmlDiffOptions = (XmlDiffOptions)options;
XmlDiff xmlDiff = new XmlDiff(xmlDiffOptions);
try
{
identicalData = xmlDiff.Compare(
sourceXmlFile,
changedXmlFile,
fragment,
diffgramWriter);
}
catch (XmlException format)
{
Trace.WriteLine(format.Message);
throw;
}
Trace.WriteLine("Files compared " +
(identicalData ? "identical." : "different."));
return identicalData;
}
/// <summary>
/// Compares SQL table schemas from two distinct XML schema files. These files are generated by the SerializeDB method.
/// </summary>
/// <param name="_serverDB"></param>
/// <param name="xmlSourceDoc">The XmlDataDocument, the source XML to compare with the destination XML.</param>
/// <param name="xmlDestinationDoc">The XmlDataDocument, the destination/target XML to compare with the source XML.</param>
/// <param name="xmlDiffDoc">The XML Diffgram document to update.</param>
/// <param name="xmlDiff">The XmlDiff Object used from the GotDotNet XmlDiff class. Performs the XML node compare.</param>
/// <param name="TableName">specifies a specific SQL table to compare</param>
public static void CompareTables(string _serverDB, XmlDocument xmlSourceDoc, XmlDocument xmlDestinationDoc,
XmlDocument xmlDiffDoc, XmlDiff xmlDiff, string TableName)
{
// NOTE: we are ignoring the destination tables that don't exist in the source DB
XPathNavigator navSource = xmlSourceDoc.CreateNavigator();
XPathNavigator navDest = xmlDestinationDoc.CreateNavigator();
// iterate thru the source tables
// we are going to ignore destination tables which are not in the source DB
// as they could be custom tables added by some outside tool or person
XmlNodeList xNodeList = xmlSourceDoc.SelectNodes("/DataBase_Schema/TABLE");
foreach (XmlNode xnChild_Source in xNodeList)
{
XmlNode xmlTableNode = null;
string tableName = xnChild_Source.ChildNodes[0].InnerXml;
if (TableName != null && !tableName.ToLower().Equals(TableName.ToLower()))
{
continue; // if in single table mode then loop until correct table is found
}
string xpath = "descendant::TABLE[TABLE_NAME='" + tableName + "']/COLUMN";
logger.Debug("\n{1}: Comparing columns for {0}.", tableName, _serverDB);
XPathExpression exprSource = navSource.Compile(xpath);
XPathExpression exprDest = navDest.Compile(xpath);
// get xmlnodes for columns in source
XmlNodeList xnlSource = xmlSourceDoc.SelectNodes(exprSource.Expression);
// get xmlnode for table in destination
XmlNode xmlDestTable = xmlDestinationDoc.SelectSingleNode("/DataBase_Schema/TABLE[TABLE_NAME='" + tableName + "']");
if (xmlDestTable != null)
{
// if table doesn't compare then walk thru each column else
if (!xmlDiff.Compare(xnChild_Source, xmlDestTable))
{
// get xmlnodes for columns in destination
XmlNodeList xnlDestination = xmlDestinationDoc.SelectNodes(exprDest.Expression);
// Compare table columns and updates the DiffGram XML doc
// TODO: use async threads to launch CompareColumns so that multiples can run at the same time
CompareColumns(tableName, xnlSource, xnlDestination, xmlDiffDoc, xmlDiff);
// add the missing source table related child nodes
xmlTableNode = xmlDiffDoc.SelectSingleNode("/DataBase_Schema/TABLE[TABLE_NAME='" + tableName + "']");
if (xmlTableNode != null)
{
// assume same owner as source table, may need to change this in the future
xmlTableNode.SelectSingleNode("TABLE_OWNER").InnerXml = xnChild_Source.SelectSingleNode("TABLE_OWNER").InnerXml;
// assume same FileGroup as source table, may need to change this in the future
xmlTableNode.SelectSingleNode("TABLE_FILEGROUP").InnerXml = xnChild_Source.SelectSingleNode("TABLE_FILEGROUP").InnerXml;
// walk all source and dest references nodes and add them to the xml diff doc
CompareTableObjs("References", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
// walk all source and dest index nodes and add them to the xml diff doc
CompareTableObjs("Indexes", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
// walk all source and dest constraints nodes and add them to the xml diff doc
CompareTableObjs("Constraints", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
}
else
{
xmlTableNode = xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE", xmlDiffDoc.NamespaceURI);
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_NAME", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_OWNER", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_FILEGROUP", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_REFERENCE", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_CONSTRAINTS", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_ORIG_CONSTRAINTS", xmlDiffDoc.NamespaceURI));
xmlTableNode.AppendChild(xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE_ORIG_REFERENCE", xmlDiffDoc.NamespaceURI));
xmlTableNode.Attributes.Append((XmlAttribute)xmlDiffDoc.CreateNode(XmlNodeType.Attribute, "Action", xmlDiffDoc.NamespaceURI));
xmlTableNode.SelectSingleNode("TABLE_NAME").InnerXml = tableName;
xmlTableNode.Attributes["Action"].Value = "Alter";
xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xmlTableNode);
// assume same owner as source table, may need to change this in the future
xmlTableNode.SelectSingleNode("TABLE_OWNER").InnerXml = xnChild_Source.SelectSingleNode("TABLE_OWNER").InnerXml;
// assume same FileGroup as source table, may need to change this in the future
xmlTableNode.SelectSingleNode("TABLE_FILEGROUP").InnerXml = xnChild_Source.SelectSingleNode("TABLE_FILEGROUP").InnerXml;
// walk all source and dest references nodes and add them to the xml diff doc
CompareTableObjs("References", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
// walk all source and dest index nodes and add them to the xml diff doc
CompareTableObjs("Indexes", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
// walk all source and dest constraints nodes and add them to the xml diff doc
CompareTableObjs("Constraints", xnChild_Source, xmlDestTable, xmlTableNode, xmlDiffDoc, xmlDiff);
}
}
else
continue;
}
else // a new table which doesn't have the add element or attribute for the columns, just the table itself
{
// add copy of source table node (and child nodes) to xmldiffdoc, since it doesn't exist in the destination
// table
xmlTableNode = xmlDiffDoc.CreateNode(XmlNodeType.Element, "TABLE", xmlDiffDoc.NamespaceURI);
xmlTableNode.InnerXml = xnChild_Source.InnerXml;
xmlTableNode.Attributes.Append((XmlAttribute)xmlDiffDoc.CreateNode(XmlNodeType.Attribute, "Action", xmlDiffDoc.NamespaceURI));
xmlTableNode.Attributes["Action"].Value = "Add";
xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xmlTableNode);
}
}
navSource = null;
navDest = null;
}
/// <summary>
/// compares two xml data sources as xml strings
/// </summary>
/// <param name="querySource">the SQL query text for the source</param>
/// <param name="queryTarget">the SQL query text for the target</param>
/// <param name="connectionSource">The sql connection object for the source</param>
/// <param name="connectionTarget">The sql connection object for the target</param>
/// <param name="asTextFile"></param>
/// <returns></returns>
public static string CompareData(string querySource, string queryTarget, SqlConnection connectionSource, SqlConnection connectionTarget, bool asTextFile)
{
bool isEqual = false;
string tempFile = "TableDiffReport.html";
string sourceName = querySource.Replace("select * from ", "").Split(' ')[0].Replace("\\", "_").Replace(":", "-") + ".xml";
string targetName = queryTarget.Replace("select * from ", "").Split(' ')[0].Replace("\\", "_").Replace(":", "-") + ".xml";
//output diff file.
string diffFile = sourceName.Replace(".xml", "") + "_DIFF_" + targetName;
XmlDiffOptions xdo = XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreChildOrder | XmlDiffOptions.IgnoreNamespaces | XmlDiffOptions.IgnorePI;
XmlDocument original = new XmlDocument();
original.LoadXml(GetXMLData(querySource, connectionSource));
original.Save(sourceName);
XmlDocument doc = new XmlDocument();
doc.LoadXml(GetXMLData(queryTarget, connectionTarget));
doc.Save(targetName);
if (asTextFile)
{
XmlDiffView diffView = new XmlDiffView();
diffView.DifferencesAsFormattedText(sourceName, targetName, diffFile.Replace(".xml", "") + ".txt", false, xdo);
diffView = null;
return diffFile.Replace(".xml", "") + ".txt";
}
else
{
XmlTextWriter diffWriter = new XmlTextWriter(diffFile, Encoding.UTF8);
diffWriter.Formatting = Formatting.Indented;
using (diffWriter)
{
XmlDiff diff = new XmlDiff();
isEqual = diff.Compare(original, doc, diffWriter);
diff.Options = xdo;
}
if (isEqual)
{
//This means the files were identical for given options.
MessageBox.Show("Tables are identical", "Identical",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return string.Empty;
}
using (XmlReader diffGram = XmlReader.Create(diffFile))
{
XmlDiffView diffView = new XmlDiffView();
diffView.Load(new XmlNodeReader(original), diffGram);
using (TextWriter htmlWriter = new StreamWriter(tempFile))
{
SideBySideXmlNotepadHeader(sourceName, targetName, htmlWriter);
diffView.GetHtml(htmlWriter);
}
diffView = null;
}
}
return tempFile;
}
private static void CompareXml(string actualFileLocation, string expectedFileName)
{
Contract.Requires(!String.IsNullOrEmpty(actualFileLocation));
Contract.Requires(!String.IsNullOrEmpty(expectedFileName));
Contract.Requires(File.Exists(actualFileLocation));
var actualFile = new XmlDocument();
actualFile.Load(actualFileLocation);
var expectedFile = new XmlDocument();
expectedFile.Load(Assembly.GetExecutingAssembly().GetManifestResourceStream("Oddleif.RunKeeper.Client.Test.ExpectedOutput." + expectedFileName));
var diff = new XmlDiff();
Assert.IsTrue(diff.Compare(expectedFile.DocumentElement, actualFile.DocumentElement));
}
private static void Main(string[] args)
{
var bFragments = false;
var flag1 = false;
var xmlDiffAlgorithm = XmlDiffAlgorithm.Auto;
try
{
if (args.Length < 3)
{
TestXmlDiff.WriteUsage();
return;
}
var options = XmlDiffOptions.None;
var index = 0;
var empty = string.Empty;
while (args[index][0] == '/')
{
if (args[index].Length != 2)
{
Console.Write("Invalid option: " + args[index] + "\n");
return;
}
switch (args[index][1])
{
case 'c':
options |= XmlDiffOptions.IgnoreComments;
break;
case 'd':
options |= XmlDiffOptions.IgnoreDtd;
break;
case 'e':
flag1 = true;
break;
case 'f':
bFragments = true;
break;
case 'n':
options |= XmlDiffOptions.IgnoreNamespaces;
break;
case 'o':
options |= XmlDiffOptions.IgnoreChildOrder;
break;
case 'p':
options |= XmlDiffOptions.IgnorePI;
break;
case 'r':
options |= XmlDiffOptions.IgnorePrefixes;
break;
case 't':
xmlDiffAlgorithm = XmlDiffAlgorithm.Fast;
break;
case 'w':
options |= XmlDiffOptions.IgnoreWhitespace;
break;
case 'x':
options |= XmlDiffOptions.IgnoreXmlDecl;
break;
case 'z':
xmlDiffAlgorithm = XmlDiffAlgorithm.Precise;
break;
default:
Console.Write("Invalid option: " + args[index] + "\n");
return;
}
empty += (string)(object)args[index][1];
++index;
if (args.Length - index < 3)
{
TestXmlDiff.WriteUsage();
return;
}
}
var str1 = args[index];
var str2 = args[index + 1];
var str3 = args[index + 2];
var flag2 = args.Length - index == 4 && args[index + 3] == "verify";
var str4 = str1.Substring(str1.LastIndexOf("\\") + 1) + " & " + str2.Substring(str2.LastIndexOf("\\") + 1) + " -> " + str3.Substring(str3.LastIndexOf("\\") + 1);
if (empty != string.Empty)
{
str4 = str4 + " (" + empty + ")";
}
Console.Write(str4.Length >= 60 ? str4 + "\n" + new string(' ', 60) : str4 + new string(' ', 60 - str4.Length));
var diffgramWriter1 = (XmlWriter) new XmlTextWriter(str3, (Encoding) new UnicodeEncoding());
var xmlDiff = new XmlDiff(options);
xmlDiff.Algorithm = xmlDiffAlgorithm;
bool flag3;
if (flag1)
{
if (bFragments)
{
Console.Write("Cannot have option 'd' and 'f' together.");
return;
}
var xmlDocument1 = new XmlDocument();
xmlDocument1.Load(str1);
var xmlDocument2 = new XmlDocument();
xmlDocument2.Load(str2);
flag3 = xmlDiff.Compare((XmlNode)xmlDocument1, (XmlNode)xmlDocument2, diffgramWriter1);
}
else
{
flag3 = xmlDiff.Compare(str1, str2, bFragments, diffgramWriter1);
}
if (flag3)
{
Console.Write("identical");
}
else
{
Console.Write("different");
}
diffgramWriter1.Close();
if (!flag3 && flag2)
{
XmlNode sourceNode;
if (bFragments)
{
var nameTable = new NameTable();
var xmlTextReader = new XmlTextReader((Stream) new FileStream(str1, FileMode.Open, FileAccess.Read), XmlNodeType.Element, new XmlParserContext((XmlNameTable)nameTable, new XmlNamespaceManager((XmlNameTable)nameTable), string.Empty, XmlSpace.Default));
var xmlDocument = new XmlDocument();
var documentFragment = xmlDocument.CreateDocumentFragment();
XmlNode newChild;
while ((newChild = xmlDocument.ReadNode((XmlReader)xmlTextReader)) != null)
{
if (newChild.NodeType != XmlNodeType.Whitespace)
{
documentFragment.AppendChild(newChild);
}
}
sourceNode = (XmlNode)documentFragment;
}
else
{
var xmlDocument = new XmlDocument();
xmlDocument.XmlResolver = (XmlResolver)null;
xmlDocument.Load(str1);
sourceNode = (XmlNode)xmlDocument;
}
new XmlPatch().Patch(ref sourceNode, (XmlReader) new XmlTextReader(str3));
if (sourceNode.NodeType == XmlNodeType.Document)
{
((XmlDocument)sourceNode).Save("_patched.xml");
}
else
{
var xmlTextWriter = new XmlTextWriter("_patched.xml", Encoding.Unicode);
sourceNode.WriteTo((XmlWriter)xmlTextWriter);
xmlTextWriter.Close();
}
var diffgramWriter2 = (XmlWriter) new XmlTextWriter("_2ndDiff.xml", (Encoding) new UnicodeEncoding());
if (xmlDiff.Compare("_patched.xml", str2, bFragments, diffgramWriter2))
{
Console.Write(" - ok");
}
else
{
Console.Write(" - FAILED");
}
diffgramWriter2.Close();
}
Console.Write("\n");
}
catch (Exception ex)
{
Console.Write("\n*** Error: " + ex.Message + " (source: " + ex.Source + ")\n");
}
if (!Debugger.IsAttached)
{
return;
}
Console.Write("\nPress enter...\n");
Console.Read();
}
public bool XmlDiffHtm(string source, string target, string intervalo, string server, string classe)
{
// Randomiza para criar arquivos unicos de comparação
r = new Random();
bool isEqual = false;
//Pega o usuário logado...
MembershipUser currentUser = Membership.GetUser();
//output diff file.
startupPath = ConfigurationManager.AppSettings["XMLData"] + "\\RPTs";
diffFile = startupPath + Path.DirectorySeparatorChar + "vxd" + r.Next() + ".out";
//
XmlTextWriter tw = new XmlTextWriter(new StreamWriter(diffFile));
tw.Formatting = Formatting.Indented;
try
{
XmlReader expected = XmlReader.Create(new StringReader(target));
XmlReader actual = XmlReader.Create(new StringReader(source));
XmlDiff diff = new XmlDiff( XmlDiffOptions.IgnoreChildOrder |
XmlDiffOptions.IgnoreComments |
XmlDiffOptions.IgnoreXmlDecl |
XmlDiffOptions.IgnoreWhitespace);
isEqual = diff.Compare(actual, expected, tw);
tw.Close();
//-----------------------------------------------------------------
// Cria a comparação dos XMLs...
XmlDiffView dv = new XmlDiffView();
// Carrega o arquivo orig = source + o arquivo XML das Diff...
XmlTextReader orig = new XmlTextReader(new StringReader(source)); //source
XmlTextReader diffGram = new XmlTextReader(diffFile);
dv.Load(orig,
diffGram);
orig.Close();
diffGram.Close();
// Chama a função para gravar e formatar o conteudo + diff em HTM...
if (!isEqual)
{ GrHtm(dv, intervalo, server, classe); }
//
return isEqual;
}
catch (XmlException xe)
{
divMessage.InnerHtml = "<span id='msg' style='color:#FF3300;font-size:Smaller;font-weight:bold;'>Ocorreu um erro de Comparação - " + xe.StackTrace + "</span>";
return isEqual;
}
}
private bool CompareXmlFiles(string expectationFile, string transformedResultFile, out string diffFile)
{
diffFile = Path.GetTempFileName();
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
var xmldiff = new XmlDiff(XmlDiffOptions.IgnoreDtd |
XmlDiffOptions.IgnoreNamespaces |
XmlDiffOptions.IgnorePrefixes |
XmlDiffOptions.IgnoreWhitespace |
XmlDiffOptions.IgnoreXmlDecl);
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
using (var writer = new XmlTextWriter(diffFile, Encoding.UTF8))
{
return xmldiff.Compare(expectationFile, transformedResultFile, false, writer);
}
}
public void Run()
{
Stream strmDiff = null;
DateTime dtStart = DateTime.Now;
int iFileCount = 0;
try
{
string strXmlInputRoot = ConfigurationManager.AppSettings.Get("XmlInputDirectory");
inputDirectory = new DirectoryInfo(string.Format("{0}\\today", strXmlInputRoot));
updateDirectory = new DirectoryInfo(string.Format("{0}\\update", strXmlInputRoot));
currentDirectory = new DirectoryInfo(string.Format("{0}\\current", strXmlInputRoot));
rejectDirectory = new DirectoryInfo(string.Format("{0}\\reject", strXmlInputRoot));
// delete all files in update directory
updateDirectory.Empty();
// get list of files in input & current directories
FileInfo[] arrFiles = inputDirectory.GetFiles();
arrFiles = (from oFile in arrFiles
orderby oFile.Length ascending
select oFile).ToArray<FileInfo>();
string[] arrCurrentFiles = Directory.GetFiles(currentDirectory.FullName);
writeLogInfo(string.Format("{0} files in today's folder", arrFiles.Length.ToString()));
int iMaxFiles = arrFiles.Length;
/*
if (iMaxFiles > 100)
iMaxFiles = 100;
*/
for (int i = 0; i < iMaxFiles; i++)
{
FileInfo fiFile = arrFiles[i];
iFileCount++;
writeLogInfo(fiFile.Name + " : " + iFileCount.ToString());
if (validateXml(fiFile))
{
xmlDocToday = oDoc;
if (!arrCurrentFiles.Contains<string>(string.Format("{0}\\{1}", currentDirectory.FullName, fiFile.Name)))
{
if (processWholeFile(fiFile, xmlDocToday))
{
// Move file to "Current" and "Update" folders
fiFile.CopyTo(string.Format("{0}\\{1}", updateDirectory.FullName, fiFile.Name));
fiFile.MoveTo(string.Format("{0}\\{1}", currentDirectory.FullName, fiFile.Name));
}
}
else
{
xmlCurrent.Load(string.Format("{0}\\{1}", currentDirectory.FullName, fiFile.Name));
strmDiff = new MemoryStream();
XmlTextWriter diffGram = new XmlTextWriter(new StreamWriter(strmDiff));
diffGram.Formatting = Formatting.Indented;
XmlDiff diff = new XmlDiff(XmlDiffOptions.IgnoreChildOrder);
diff.Compare(xmlCurrent, xmlDocToday, diffGram);
strmDiff.Position = 0;
strRead = new StreamReader(strmDiff);
string strDiffGraph = strRead.ReadToEnd();
xmlDiffGraph.LoadXml(strDiffGraph);
if (xmlDiffGraph.ChildNodes[1].HasChildNodes)
{
if (processWholeFile(fiFile, xmlDocToday))
{
// Move file to "Current" and "Update" folders
fiFile.CopyTo(string.Format("{0}\\{1}", updateDirectory.FullName, fiFile.Name));
fiFile.MoveTo(string.Format("{0}\\{1}", currentDirectory.FullName, fiFile.Name));
}
}
}
}
else
{
fiFile.MoveTo(string.Format("{0}\\{1}", rejectDirectory.FullName, fiFile.Name));
}
}
//PublishTours(itmTourFolder);
}
catch (Exception ex)
{
logError(ex.ToString());
}
finally
{
// clean up resources
if (strmDiff != null)
{
strmDiff.Close();
strmDiff.Dispose();
}
if (strRead != null)
{
strRead.Close();
strRead.Dispose();
}
writeLogInfo((DateTime.Now - dtStart).TotalSeconds.ToString());
}
}
/// <summary>
/// Compares table indexes, table constraints, and table FK/PK references from two distinct XML schema files. These
/// files are generated by the SerializeDB method. This method is called by the CompareTables method.
/// </summary>
/// <param name="objType">The type of database table related object collection to compare, i.e. indexes, constraints
/// (check and default), and references.</param>
/// <param name="SourceTable">The SourceTable XML Node containing all table object related child nodes to compare with
/// the destination child nodes.</param>
/// <param name="DestTable">The DestTable XML Node containing all table object related child nodes to compare with
/// the source child nodes.</param>
/// <param name="DiffTable">The XML Diffgram table node to update.</param>
/// <param name="xmlDiffDoc">The XML Diffgram document to update.</param>
/// <param name="xmlDiff">The XmlDiff Object used from the GotDotNet XmlDiff class. Performs the XML node compare.</param>
private static void CompareTableObjs(string objType, XmlNode SourceTable, XmlNode DestTable, XmlNode DiffTable,
XmlDocument xmlDiffDoc, XmlDiff xmlDiff)
{
string MainNode = string.Empty;
string OrigNode = string.Empty;
string xpathpart = string.Empty;
string objName = string.Empty;
switch (objType.ToLower())
{
case "indexes":
{
MainNode = "TABLE_INDEX";
OrigNode = "TABLE_ORIG_INDEX";
xpathpart = "TABLE_INDEX[index_name='";
objName = "index_name";
break;
}
case "constraints":
{
MainNode = "TABLE_CONSTRAINTS";
OrigNode = "TABLE_ORIG_CONSTRAINTS";
xpathpart = "TABLE_CONSTRAINTS[CONSTRAINT_NAME='";
objName = "CONSTRAINT_NAME";
break;
}
case "references":
{
MainNode = "TABLE_REFERENCE";
OrigNode = "TABLE_ORIG_REFERENCE";
xpathpart = "TABLE_REFERENCE[Constraint='";
objName = "Constraint";
break;
}
}
XmlNodeList xmlSourceObjs = SourceTable.SelectNodes(MainNode);
XmlNodeList xmlDestObjs = DestTable.SelectNodes(MainNode);
// compare source and dest nodes, also looking for missing dest nodes
foreach (XmlNode xnsourceobj in xmlSourceObjs)
{
XmlNode xn = xnsourceobj.SelectSingleNode(objName);
if (xn != null)
{
string source_obj_name = xn.InnerXml;
XmlNode dest_obj_node = DestTable.SelectSingleNode(xpathpart + source_obj_name + "']");
// if dest index node is found then compare
if (dest_obj_node != null)
{
// if the source and dest index nodes don't match then add both the the xml diff file
if (!xmlDiff.Compare(xnsourceobj, dest_obj_node))
{
// check node for children, otherwise its a waste of time
if (xnsourceobj.HasChildNodes)
{
XmlNode xnChild1 = xmlDiffDoc.CreateNode(XmlNodeType.Element, MainNode, xmlDiffDoc.NamespaceURI);
xnChild1.InnerXml = xnsourceobj.InnerXml;
DiffTable.AppendChild(xnChild1);
}
// check node for children, otherwise its a waste of time
if (dest_obj_node.HasChildNodes)
{
XmlNode xnChild2 = xmlDiffDoc.CreateNode(XmlNodeType.Element, OrigNode, xmlDiffDoc.NamespaceURI);
xnChild2.InnerXml = dest_obj_node.InnerXml;
DiffTable.AppendChild(xnChild2);
}
}
}
else // missing dest node, so add source node
{
// check node for children, otherwise its a waste of time
if (xnsourceobj.HasChildNodes)
{
XmlNode xnChild1 = xmlDiffDoc.CreateNode(XmlNodeType.Element, MainNode, xmlDiffDoc.NamespaceURI);
xnChild1.InnerXml = xnsourceobj.InnerXml;
DiffTable.AppendChild(xnChild1);
}
}
}
}
// look for dest nodes that don't exist in source
foreach (XmlNode xndestobj in xmlDestObjs)
{
XmlNode xn = xndestobj.SelectSingleNode(objName);
if (xn != null)
{
string dest_obj_name = xn.InnerXml;
XmlNode source_index_node = SourceTable.SelectSingleNode(xpathpart + dest_obj_name + "']");
// if dest node doesn't exist in source table then add dest node to the xml diff doc so thaqt it can be removed
if (source_index_node == null || !source_index_node.HasChildNodes)
{
// check node for children, otherwise its a waste of time
if (xndestobj.HasChildNodes)
{
XmlNode xnChild2 = xmlDiffDoc.CreateNode(XmlNodeType.Element, OrigNode, xmlDiffDoc.NamespaceURI);
xnChild2.InnerXml = xndestobj.InnerXml;
DiffTable.AppendChild(xnChild2);
}
}
}
}
}
static void Main(string[] args)
{
bool fragments = false;
XmlDiffAlgorithm algorithm = XmlDiffAlgorithm.Auto;
XmlDiffOptions options = XmlDiffOptions.None;
// process options
int curArgsIndex = 0;
while ( curArgsIndex < args.Length &&
( args[curArgsIndex][0] == '/' || args[curArgsIndex][0] == '-' ) ) {
if ( args[curArgsIndex].Length != 2 ) {
Console.WriteLine( "Invalid option: " + args[curArgsIndex] );
WriteUsage();
return;
}
switch ( args[curArgsIndex][1] ) {
case 'o':
options |= XmlDiffOptions.IgnoreChildOrder;
break;
case 'c':
options |= XmlDiffOptions.IgnoreComments;
break;
case 'p':
options |= XmlDiffOptions.IgnorePI;
break;
case 'w':
options |= XmlDiffOptions.IgnoreWhitespace;
break;
case 'n':
options |= XmlDiffOptions.IgnoreNamespaces;
break;
case 'r':
options |= XmlDiffOptions.IgnorePrefixes;
break;
case 'x':
options |= XmlDiffOptions.IgnoreXmlDecl;
break;
case 'd':
options |= XmlDiffOptions.IgnoreDtd;
break;
case 'f':
fragments = true;
break;
case 't':
algorithm = XmlDiffAlgorithm.Fast;
break;
case 'z':
algorithm = XmlDiffAlgorithm.Precise;
break;
case '?':
WriteUsage();
return;
default:
Console.Write( "Invalid option: " + args[curArgsIndex] + "\n" );
return;
}
curArgsIndex++;
}
if ( args.Length < 2 ) {
Console.WriteLine( "Invalid arguments." );
WriteUsage();
return;
}
// extract names from command line
string sourceXmlFileName = args[ curArgsIndex ];
string changedXmlFileName = args[ curArgsIndex + 1 ];
string ignoreFileName = args[curArgsIndex + 2];
string diffgramFileName = (curArgsIndex + 3 < args.Length) ? args[curArgsIndex + 3] : null;
Console.WriteLine( "Comparing " + sourceXmlFileName + " to " + changedXmlFileName + " using ignore config " + ignoreFileName );
// create XmlTextWriter where the diffgram will be saved
XmlWriter diffgramWriter = null;
if ( diffgramFileName != null ) {
diffgramWriter = new XmlTextWriter( diffgramFileName, Encoding.Unicode );
}
// create XmlDiff object & set the desired options and algorithm
XmlDiff xmlDiff = new XmlDiff( options );
xmlDiff.Algorithm = algorithm;
// Compare the XML files
bool bEqual = false;
try {
bEqual = xmlDiff.Compare(sourceXmlFileName, changedXmlFileName, fragments, diffgramWriter, ignoreFileName);
}
catch (Exception e) {
WriteError(e.Message);
Console.ReadKey();
return;
}
if (bEqual) {
Console.WriteLine( "Files are identical." );
}
else {
Console.WriteLine( "Files are different." );
}
if ( diffgramWriter != null ) {
diffgramWriter.Close();
Console.WriteLine( "XDL diffgram has been saved to " + diffgramFileName + "." );
}
Console.ReadKey();
return;
}
public bool DoTest(string sfmFileName, string mapFileName, string phase4KeyFileName, string locationOfFinalFile)
{
m_sfmName = sfmFileName;
m_mapName = mapFileName;
m_keyName = phase4KeyFileName;
m_Phase5Output = locationOfFinalFile;
Converter conv = new Converter();
// read in the Lex Import Fields
LexImportFields autoFields = new LexImportFields();
autoFields.ReadLexImportFields(@"C:\fw\DistFiles\Language Explorer\Import\ImportFields.xml");
// if there are auto fields in the xml file, pass them on to the converter
Hashtable htAutoFields = autoFields.GetAutoFields();
foreach (DictionaryEntry laf in htAutoFields)
{
string entryClass = laf.Key as String;
LexImportField lexField = laf.Value as LexImportField;
string fwDest = lexField.ID;
conv.AddPossibleAutoField(entryClass, fwDest);
}
//// here the Auto import fields needs to be added to the converter as it is in the actual import process
//conv.AddPossibleAutoField("Entry", "eires");
//conv.AddPossibleAutoField("Sense", "sires");
//conv.AddPossibleAutoField("Subentry", "seires");
//conv.AddPossibleAutoField("Variant", "veires");
conv.Convert(m_sfmName, m_mapName, m_phase1output);
ProcessPhase1Errors();
DoTransform(m_BuildPhase2XSLT, m_phase1output, m_Phase2XSLT);
DoTransform(m_Phase2XSLT, m_phase1output, m_Phase2Output);
DoTransform(m_Phase3XSLT, m_Phase2Output, m_Phase3Output);
#if true
// put the phase4output in to the 'phase 5' file for comparing as there is no phase 5 now.
DoTransform(m_Phase4XSLT, m_Phase3Output, m_Phase5Output);
Microsoft.XmlDiffPatch.XmlDiff diff = new Microsoft.XmlDiffPatch.XmlDiff(
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreChildOrder |
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreComments |
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreWhitespace);
bool same = diff.Compare(m_keyName, m_Phase5Output, false);
#else
DoTransform(m_Phase4XSLT, m_Phase3Output, m_Phase4Output);
// strip out the id and target attributes as the guids WILL be different
DoTransform(m_Phase5XSLT, m_Phase4Output, m_Phase5Output);
DoTransform(m_Phase5XSLT, m_keyName, m_KeyOutput);
Microsoft.XmlDiffPatch.XmlDiff diff = new Microsoft.XmlDiffPatch.XmlDiff(
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreChildOrder |
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreComments |
Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreWhitespace );
bool same = diff.Compare(m_KeyOutput, m_Phase5Output, false);
#endif
return same;
}
static void Main( string[] args )
{
bool bFragment = false;
bool bNodes = false;
XmlDiffAlgorithm algorithm = XmlDiffAlgorithm.Auto;
try
{
if ( args.Length < 3 )
{
WriteUsage();
return;
}
XmlDiffOptions options = XmlDiffOptions.None;
// process options
int curArgsIndex = 0;
string optionsString = string.Empty;
while ( args[curArgsIndex][0] == '/' )
{
if ( args[curArgsIndex].Length != 2 )
{
System.Console.Write( "Invalid option: " + args[curArgsIndex] + "\n" );
return;
}
switch ( args[curArgsIndex][1] )
{
case 'o':
options |= XmlDiffOptions.IgnoreChildOrder;
break;
case 'c':
options |= XmlDiffOptions.IgnoreComments;
break;
case 'p':
options |= XmlDiffOptions.IgnorePI;
break;
case 'w':
options |= XmlDiffOptions.IgnoreWhitespace;
break;
case 'n':
options |= XmlDiffOptions.IgnoreNamespaces;
break;
case 'r':
options |= XmlDiffOptions.IgnorePrefixes;
break;
case 'x':
options |= XmlDiffOptions.IgnoreXmlDecl;
break;
case 'd':
options |= XmlDiffOptions.IgnoreDtd;
break;
case 'e':
bNodes = true;
break;
case 'f':
bFragment = true;
break;
case 't':
algorithm = XmlDiffAlgorithm.Fast;
break;
case 'z':
algorithm = XmlDiffAlgorithm.Precise;
break;
default:
System.Console.Write( "Invalid option: " + args[curArgsIndex] + "\n" );
return;
}
optionsString += args[curArgsIndex][1];
curArgsIndex++;
if ( args.Length - curArgsIndex < 3 )
{
WriteUsage();
return;
}
}
// extract names from command line
string sourceXml = args[ curArgsIndex ];
string targetXml = args[ curArgsIndex + 1 ];
string diffgram = args[ curArgsIndex + 2 ];
bool bVerify = ( args.Length - curArgsIndex == 4 ) && ( args[ curArgsIndex + 3 ] == "verify" );
// write legend
string legend = sourceXml.Substring( sourceXml.LastIndexOf("\\") + 1 ) + " & " +
targetXml.Substring( targetXml.LastIndexOf("\\") + 1 ) + " -> " +
diffgram.Substring( diffgram.LastIndexOf("\\") + 1 );
if ( optionsString != string.Empty )
legend += " (" + optionsString + ")";
if ( legend.Length < 60 )
legend += new String( ' ', 60 - legend.Length );
else
legend += "\n" + new String( ' ', 60 );
System.Console.Write( legend );
// create diffgram writer
XmlWriter DiffgramWriter = new XmlTextWriter( diffgram, new System.Text.UnicodeEncoding() );
// create XmlDiff object & set the options
XmlDiff xmlDiff = new XmlDiff( options );
xmlDiff.Algorithm = algorithm;
// compare xml files
bool bIdentical;
if ( bNodes ) {
if ( bFragment ) {
Console.Write( "Cannot have option 'd' and 'f' together." );
return;
}
XmlDocument sourceDoc = new XmlDocument();
sourceDoc.Load( sourceXml );
XmlDocument targetDoc = new XmlDocument();
targetDoc.Load( targetXml );
bIdentical = xmlDiff.Compare( sourceDoc, targetDoc, DiffgramWriter );
}
else {
bIdentical = xmlDiff.Compare( sourceXml, targetXml, bFragment, DiffgramWriter );
}
/*
* if ( bMeasurePerf ) {
Type type = xmlDiff.GetType();
MemberInfo[] mi = type.GetMember( "_xmlDiffPerf" );
if ( mi != null && mi.Length > 0 ) {
XmlDiffPerf xmldiffPerf = (XmlDiffPerf)type.InvokeMember( "_xmlDiffPerf", BindingFlags.GetField, null, xmlDiff, new object[0]);
}
}
*/
// write result
if ( bIdentical )
System.Console.Write( "identical" );
else
System.Console.Write( "different" );
DiffgramWriter.Close();
// verify
if ( !bIdentical && bVerify )
{
XmlNode sourceNode;
if ( bFragment )
{
NameTable nt = new NameTable();
XmlTextReader tr = new XmlTextReader( new FileStream( sourceXml, FileMode.Open, FileAccess.Read ),
XmlNodeType.Element,
new XmlParserContext( nt, new XmlNamespaceManager( nt ),
string.Empty, XmlSpace.Default ) );
XmlDocument doc = new XmlDocument();
XmlDocumentFragment frag = doc.CreateDocumentFragment();
XmlNode node;
while ( ( node = doc.ReadNode( tr ) ) != null ) {
if ( node.NodeType != XmlNodeType.Whitespace )
frag.AppendChild( node );
}
sourceNode = frag;
}
else
{
// load source document
XmlDocument sourceDoc = new XmlDocument();
sourceDoc.XmlResolver = null;
sourceDoc.Load( sourceXml );
sourceNode = sourceDoc;
}
// patch it & save
new XmlPatch().Patch( ref sourceNode, new XmlTextReader( diffgram ) );
if ( sourceNode.NodeType == XmlNodeType.Document )
((XmlDocument)sourceNode).Save( "_patched.xml" );
else {
XmlTextWriter tw = new XmlTextWriter( "_patched.xml", Encoding.Unicode );
sourceNode.WriteTo( tw );
tw.Close();
}
XmlWriter diffgramWriter2 = new XmlTextWriter( "_2ndDiff.xml", new System.Text.UnicodeEncoding() );
// compare patched source document and target document
if ( xmlDiff.Compare( "_patched.xml", targetXml, bFragment, diffgramWriter2 ) )
System.Console.Write( " - ok" );
else
System.Console.Write( " - FAILED" );
diffgramWriter2.Close();
}
System.Console.Write( "\n" );
}
catch ( Exception e )
{
Console.Write("\n*** Error: " + e.Message + " (source: " + e.Source + ")\n");
}
if ( System.Diagnostics.Debugger.IsAttached )
{
Console.Write( "\nPress enter...\n" );
Console.Read();
}
}
private static bool Compare(out StringBuilder diff, string goalFilePath, string foundFilePath, IEnumerable<Replacement> replacements, IEnumerable<string> elementsToExclude, IEnumerable<Attribute> attributesToExclude, bool ignoreChildOrder, bool ignoreComments)
{
bool retVal;
diff = new StringBuilder();
var foundFileDocument = new XmlDocument();
var goalFileDocument = new XmlDocument();
TextReader goalFileReader = null;
TextReader foundFileReader = null;
XmlReader foundFileXmlReader = null;
XmlReader goalXmlReader = null;
try
{
goalFileReader = new StringReader(XmlDocumentCleaner.ReplaceInDocument(goalFilePath, replacements));
foundFileReader = new StringReader(XmlDocumentCleaner.ReplaceInDocument(foundFilePath, replacements));
foundFileDocument.Load(foundFileReader);
goalFileDocument.Load(goalFileReader);
foreach (string element in elementsToExclude)
{
XmlDocumentCleaner.RemoveElements(ref foundFileDocument, element);
XmlDocumentCleaner.RemoveElements(ref goalFileDocument, element);
}
foreach (Attribute attribute in attributesToExclude)
{
XmlDocumentCleaner.RemoveAttribute(ref foundFileDocument, attribute);
XmlDocumentCleaner.RemoveAttribute(ref goalFileDocument, attribute);
}
foundFileXmlReader = new XmlNodeReader(foundFileDocument);
goalXmlReader = new XmlNodeReader(goalFileDocument);
var comparer = new XmlDiff();
comparer.IgnoreChildOrder = ignoreChildOrder;
comparer.IgnoreComments = ignoreComments;
XmlWriter diffWriter = XmlWriter.Create(diff);
retVal = comparer.Compare(goalXmlReader, foundFileXmlReader, diffWriter);
diffWriter.Flush();
}
finally
{
if (goalXmlReader != null) goalXmlReader.Close();
if (foundFileXmlReader != null) foundFileXmlReader.Close();
if (goalFileReader != null) goalFileReader.Dispose();
if (foundFileReader != null) foundFileReader.Dispose();
}
return retVal;
}
static void Main(string[] args)
{
bool bFragment = false;
bool bNodes = false;
XmlDiffAlgorithm algorithm = XmlDiffAlgorithm.Auto;
try
{
if (args.Length < 3)
{
WriteUsage();
return;
}
XmlDiffOptions options = XmlDiffOptions.None;
// process options
int curArgsIndex = 0;
string optionsString = string.Empty;
while (args[curArgsIndex][0] == '/')
{
if (args[curArgsIndex].Length != 2)
{
System.Console.Write("Invalid option: " + args[curArgsIndex] + "\n");
return;
}
switch (args[curArgsIndex][1])
{
case 'o':
options |= XmlDiffOptions.IgnoreChildOrder;
break;
case 'c':
options |= XmlDiffOptions.IgnoreComments;
break;
case 'p':
options |= XmlDiffOptions.IgnorePI;
break;
case 'w':
options |= XmlDiffOptions.IgnoreWhitespace;
break;
case 'n':
options |= XmlDiffOptions.IgnoreNamespaces;
break;
case 'r':
options |= XmlDiffOptions.IgnorePrefixes;
break;
case 'x':
options |= XmlDiffOptions.IgnoreXmlDecl;
break;
case 'd':
options |= XmlDiffOptions.IgnoreDtd;
break;
case 'e':
bNodes = true;
break;
case 'f':
bFragment = true;
break;
case 't':
algorithm = XmlDiffAlgorithm.Fast;
break;
case 'z':
algorithm = XmlDiffAlgorithm.Precise;
break;
default:
System.Console.Write("Invalid option: " + args[curArgsIndex] + "\n");
return;
}
optionsString += args[curArgsIndex][1];
curArgsIndex++;
if (args.Length - curArgsIndex < 3)
{
WriteUsage();
return;
}
}
// extract names from command line
string sourceXml = args[curArgsIndex];
string targetXml = args[curArgsIndex + 1];
string diffgram = args[curArgsIndex + 2];
bool bVerify = (args.Length - curArgsIndex == 4) && (args[curArgsIndex + 3] == "verify");
// write legend
string legend = sourceXml.Substring(sourceXml.LastIndexOf("\\") + 1) + " & " +
targetXml.Substring(targetXml.LastIndexOf("\\") + 1) + " -> " +
diffgram.Substring(diffgram.LastIndexOf("\\") + 1);
if (optionsString != string.Empty)
{
legend += " (" + optionsString + ")";
}
if (legend.Length < 60)
{
legend += new String(' ', 60 - legend.Length);
}
else
{
legend += "\n" + new String(' ', 60);
}
System.Console.Write(legend);
// create diffgram writer
XmlWriter DiffgramWriter = new XmlTextWriter(diffgram, new System.Text.UnicodeEncoding());
// create XmlDiff object & set the options
XmlDiff xmlDiff = new XmlDiff(options);
xmlDiff.Algorithm = algorithm;
// compare xml files
bool bIdentical;
if (bNodes)
{
if (bFragment)
{
Console.Write("Cannot have option 'd' and 'f' together.");
return;
}
XmlDocument sourceDoc = new XmlDocument();
sourceDoc.Load(sourceXml);
XmlDocument targetDoc = new XmlDocument();
targetDoc.Load(targetXml);
bIdentical = xmlDiff.Compare(sourceDoc, targetDoc, DiffgramWriter);
}
else
{
bIdentical = xmlDiff.Compare(sourceXml, targetXml, bFragment, DiffgramWriter);
}
/*
* if ( bMeasurePerf ) {
* Type type = xmlDiff.GetType();
* MemberInfo[] mi = type.GetMember( "_xmlDiffPerf" );
* if ( mi != null && mi.Length > 0 ) {
* XmlDiffPerf xmldiffPerf = (XmlDiffPerf)type.InvokeMember( "_xmlDiffPerf", BindingFlags.GetField, null, xmlDiff, new object[0]);
* }
* }
*/
// write result
if (bIdentical)
{
System.Console.Write("identical");
}
else
{
System.Console.Write("different");
}
DiffgramWriter.Close();
// verify
if (!bIdentical && bVerify)
{
XmlNode sourceNode;
if (bFragment)
{
NameTable nt = new NameTable();
XmlTextReader tr = new XmlTextReader(new FileStream(sourceXml, FileMode.Open, FileAccess.Read),
XmlNodeType.Element,
new XmlParserContext(nt, new XmlNamespaceManager(nt),
string.Empty, XmlSpace.Default));
XmlDocument doc = new XmlDocument();
XmlDocumentFragment frag = doc.CreateDocumentFragment();
XmlNode node;
while ((node = doc.ReadNode(tr)) != null)
{
if (node.NodeType != XmlNodeType.Whitespace)
{
frag.AppendChild(node);
}
}
sourceNode = frag;
}
else
{
// load source document
XmlDocument sourceDoc = new XmlDocument();
sourceDoc.XmlResolver = null;
sourceDoc.Load(sourceXml);
sourceNode = sourceDoc;
}
// patch it & save
new XmlPatch().Patch(ref sourceNode, new XmlTextReader(diffgram));
if (sourceNode.NodeType == XmlNodeType.Document)
{
((XmlDocument)sourceNode).Save("_patched.xml");
}
else
{
XmlTextWriter tw = new XmlTextWriter("_patched.xml", Encoding.Unicode);
sourceNode.WriteTo(tw);
tw.Close();
}
XmlWriter diffgramWriter2 = new XmlTextWriter("_2ndDiff.xml", new System.Text.UnicodeEncoding());
// compare patched source document and target document
if (xmlDiff.Compare("_patched.xml", targetXml, bFragment, diffgramWriter2))
{
System.Console.Write(" - ok");
}
else
{
System.Console.Write(" - FAILED");
}
diffgramWriter2.Close();
}
System.Console.Write("\n");
}
catch (Exception e)
{
Console.Write("\n*** Error: " + e.Message + " (source: " + e.Source + ")\n");
}
if (System.Diagnostics.Debugger.IsAttached)
{
Console.Write("\nPress enter...\n");
Console.Read();
}
}
/// <summary>
/// Compares database objects (except tables and columns) from two distinct XML schema files. These files are generated
/// by the SerializeDB method. This method is called from the CompareSchema method.
/// </summary>
/// <param name="_serverDB">Used to identify which server the compare objects came from</param>
/// <param name="xmlSourceDoc">The XmlDataDocument, the source XML to compare with the destination XML.</param>
/// <param name="xmlDestinationDoc">The XmlDataDocument, the destination/target XML to compare with the source XML.</param>
/// <param name="xmlDiffDoc">The XML Diffgram document to update.</param>
/// <param name="type">The type of database object collection to compare, i.e. defaults, UDDTs, rules, views, functions,
/// stored procedures, and triggers.</param>
/// <param name="xmlDiff">The XmlDiff Object used from the GotDotNet XmlDiff class. Performs the XML node compare.</param>
/// <param name="CompareTextFlag">Flag that performs full text compare between objects</param>
/// <param name="sqlObjectName">specifies a specific SQL object to compare</param>
public static void CompareObjects(string _serverDB, XmlDocument xmlSourceDoc, XmlDocument xmlDestinationDoc,
XmlDocument xmlDiffDoc, _NodeType type, XmlDiff xmlDiff, bool CompareTextFlag, string sqlObjectName)
{
SortedList sl = new SortedList();
SortedList slDep = new SortedList();
bool addFlag = false;
bool alterFlag = false;
bool sortFlag = false;
string selectNodes = string.Empty;
string selectText = string.Empty;
string typeName = string.Empty;
string depText = string.Empty;
// iterate thru the source tables
// we are going to ignore destination tables which are not in the source DB
// as they could be custom tables added by some outside tool or person
switch (type)
{
case _NodeType.SPROC:
{
selectNodes = SPROCPATH;
selectText = SPROCTEXT;
depText = SPROCDEP;
typeName = type.ToString();
sortFlag = true;
break;
}
case _NodeType.FUNCTION:
{
selectNodes = FUNCPATH;
selectText = FUNCTEXT;
depText = FUNCDEP;
typeName = type.ToString().Substring(0, 4);
sortFlag = true;
break;
}
case _NodeType.VIEW:
{
selectNodes = VIEWPATH;
selectText = VIEWTEXT;
depText = VIEWDEP;
typeName = type.ToString();
sortFlag = true;
break;
}
case _NodeType.TRIGGER:
{
selectNodes = TRIGGERPATH;
selectText = TRIGGERTEXT;
typeName = type.ToString();
break;
}
case _NodeType.DEFAULT:
{
selectNodes = DEFAULTPATH;
selectText = DEFAULTTEXT;
typeName = type.ToString();
break;
}
case _NodeType.RULE:
{
selectNodes = RULEPATH;
selectText = RULETEXT;
typeName = type.ToString();
break;
}
case _NodeType.UDDT:
{
selectNodes = UDDTPATH;
selectText = UDDTTEXT;
typeName = type.ToString();
break;
}
}
SortedList slMatch = new SortedList();
XmlNodeList xNodeList = xmlSourceDoc.SelectNodes(selectNodes, nsmgr_Source);
XmlNode xnDestParent = xmlDestinationDoc.SelectSingleNode(selectNodes, nsmgr_Dest);
// use stringbuilder class as it should be faster
StringBuilder sourceTxt = new StringBuilder();
StringBuilder destTxt = new StringBuilder();
StringBuilder sortedname = new StringBuilder();
foreach (XmlNode xnChild_Source in xNodeList)
{
XmlNode xnDest = null;
XmlNodeList XmlDestTextList = null;
sourceTxt.Length = 0;
destTxt.Length = 0;
int destNodeCount = 0;
int sourceNodeCount = 0;
string SqlObjectName = xnChild_Source.ChildNodes[0].InnerXml;
if (sqlObjectName != null && !SqlObjectName.ToLower().Equals(sqlObjectName.ToLower()))
{
continue; // loop until passed in object name is found
}
string xpath = selectText + SqlObjectName + "']";
XmlNode xnChk = xnChild_Source.SelectSingleNode("Check_Sum");
string src_checksum = string.Empty;
string dst_checksum = string.Empty;
if (xnChk != null)
{
src_checksum = xnChk.InnerXml;
}
logger.Debug("\n{2}: Comparing {1}: {0}.", SqlObjectName, type.ToString().ToLower(), _serverDB);
// walk thru destination xml doc nodes to find matching sproc node
if (xnDestParent != null)
{
xnDest = xnDestParent.SelectSingleNode(selectNodes + "[" + xpath.Split('[')[1]);
}
// get xmlnodes for text rows in destination doc
if (xnDest != null)
{
xnChk = xnDest.SelectSingleNode("Check_Sum");
if (xnChk != null)
{
dst_checksum = xnChk.InnerXml;
}
// if objects don't compare then walk each line of text
if (!xmlDiff.Compare(xnChild_Source, xnDest))
{
XmlDestTextList = xnDest.SelectNodes(selectText.Split('[')[0]);
// only comapre the text length (not a checksum) if there is not a match on the nodes
if (xnChk != null && dst_checksum == src_checksum)
{
continue;
}
}
else
{
continue;
}
}
if (xnDest != null && XmlDestTextList != null && XmlDestTextList.Count > 0)
{
// don't care about existing UDDTs and Defaults, only new ones
// so resume at next node
if (type == _NodeType.UDDT || type == _NodeType.DEFAULT || type == _NodeType.RULE)
{
continue;
}
if (CompareTextFlag)
{
// get xmlnodes for text rows in source
XmlNodeList xnlSource = xnChild_Source.SelectNodes(xpath, nsmgr_Source);
// build text for source
foreach (XmlNode xnSource in xnlSource)
{
// ignore blank text nodes, tabs, newline and carriage returns
if (xnSource.SelectSingleNode("Text") == null || xnSource.SelectSingleNode("Text").InnerText.Length == 0)
{
continue;
}
sourceNodeCount += 1;
sourceTxt.Append(xnSource.SelectSingleNode("Text").InnerText.ToLower().Trim());
sourceTxt.Replace(" ", "");
sourceTxt.Replace("\n", "");
sourceTxt.Replace("\r", "");
sourceTxt.Replace("\t", "");
}
if (sourceTxt.ToString().Length > 0)
{
// build text for destination
foreach (XmlNode xnChild in XmlDestTextList)
{
// ignore blank text nodes, tabs, newline and carriage returns
if (xnChild.SelectSingleNode("Text") == null || xnChild.SelectSingleNode("Text").InnerText.Length == 0)
{
continue;
}
destNodeCount += 1;
destTxt.Append(xnChild.SelectSingleNode("Text").InnerText.ToLower().Trim());
destTxt.Replace(" ", "");
destTxt.Replace("\n", "");
destTxt.Replace("\r", "");
destTxt.Replace("\t", "");
// look for this text string in the source text string
// if theres no match then we do not need to look thru
// all the dest text nodes, so exit out of loop, instead of continuing on
// Contains = true if the value parameter occurs within this string, or if value is the empty string (""); otherwise, false.
if (!sourceTxt.ToString().Contains(destTxt.ToString()) && destTxt.ToString().Length > 0)
{
break;
}
}
}
//CompareInfo compare = CultureInfo.InvariantCulture.CompareInfo;
//int compareResult = compare.Compare(sourceTxt.ToString(), destTxt.ToString(), CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreNonSpace);
}
else
{
alterFlag = true;
}
// compare source and dest text
if (sourceTxt.ToString().ToLower() != destTxt.ToString().ToLower())
{
alterFlag = true;
}
// if no differences then resume at next source node
if (!alterFlag)
{
continue;
}
}
else // we have a source node, but no matching destination node so set the add flag to true
{
addFlag = true;
}
// if no destination text, we need to add it from the source
if (sourceNodeCount > 0 && (destNodeCount == 0 || xnDest == null))
{
// the object_text node was not found in the destination so add parent node for object to DiffDoc as an add
addFlag = true;
}
XmlNode xNode = null;
if (addFlag)
{
xNode = xmlDiffDoc.CreateNode(XmlNodeType.Element, typeName, xmlDiffDoc.NamespaceURI);
XmlAttribute xNodeAttrib = xmlDiffDoc.CreateAttribute("Action");
xNodeAttrib.Value = "Add";
xNode.InnerXml = xnChild_Source.InnerXml;
xNode.Attributes.Append(xNodeAttrib);
if (!sortFlag) xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xNode);
addFlag = false;
}
if (alterFlag)
{
xNode = xmlDiffDoc.CreateNode(XmlNodeType.Element, typeName, xmlDiffDoc.NamespaceURI);
XmlAttribute xNodeAttrib = xmlDiffDoc.CreateAttribute("Action");
xNodeAttrib.Value = "Alter";
xNode.InnerXml = xnChild_Source.InnerXml;
xNode.Attributes.Append(xNodeAttrib);
if (!sortFlag) xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xNode);
alterFlag = false;
}
if (sortFlag)
{
if (xNode != null)
{
XmlNodeList xnlSource = xnChild_Source.SelectNodes(depText + SqlObjectName + "']", nsmgr_Source);
// get dependencies names and add to sorted list
int ii = 0;
foreach (XmlNode xnSource in xnlSource)
{
if (xnSource.ChildNodes[1] != null)
{
slDep.Add(string.Format("{1:0000}!{0}", SqlObjectName.ToLower(), ii), xnSource.ChildNodes[1].InnerXml.ToLower());
ii += 1;
}
}
if (ii > 0)
{
sl.Add(string.Format("{1:0000}!{0}", SqlObjectName.ToLower(), ii), xNode);
}
else
{
sl.Add(string.Format("0000!{0}", SqlObjectName.ToLower()), xNode);
}
}
}
} // end of main for loop
if (sortFlag)
{
// if sldep has count > 0 then we need to do some additional sorting
SortedList sl2 = new SortedList();
int zz = 0;
for (int ii = 0; ii < sl.Count; ii++)
{
sl2.Add(string.Format("{1:00000},{0}", sl.GetKey(ii).ToString(), zz), sl.GetByIndex(ii));
zz += 10;
}
if (slDep.Count > 0)
{
int start = 0;
RecurseDependencies(_serverDB, ref sl2, ref slDep, 0, ref start);
}
for (int ii = 0; ii < sl2.Count; ii++)
{
XmlNode xn = (XmlNode)sl2.GetByIndex(ii);
xmlDiffDoc.SelectSingleNode("/DataBase_Schema").AppendChild(xn);
}
}
}
private void CompareResults(String name) {
PdfReader reader = new PdfReader(OUT + name + ".pdf");
string orig = RESOURCES + "xml\\test" + name + ".xml";
string curr = TARGET + "xml\\test" + name + ".xml";
FileStream xmlOut = new FileStream(curr, FileMode.Create);
new MyTaggedPdfReaderTool().ConvertToXml(reader, xmlOut);
xmlOut.Close();
XmlDiff xmldiff = new XmlDiff(XmlDiffOptions.None);
Assert.True(xmldiff.Compare(orig, curr, false));
}
public void GenerateOutput(BuildItem buildItem, Stream outputStream, IDictionary<string, Stream> inputFormatStreams, string defaultNamespace)
{
outputStream = new UncloseableStream(outputStream);
Stream undeadOial = inputFormatStreams["UndeadOIAL"];
Stream liveOial = inputFormatStreams["LiveOIAL"];
XmlDiff xmlDiff = new XmlDiff(XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl | XmlDiffOptions.IgnorePrefixes);
xmlDiff.Algorithm = XmlDiffAlgorithm.Precise;
bool identical = false;
MemoryStream diffgram = new MemoryStream(8192);
using (XmlWriter diffgramWriter = XmlWriter.Create(diffgram))
{
try
{
using (XmlReader undeadReader = XmlReader.Create(undeadOial, XmlReaderSettings), liveReader = XmlReader.Create(liveOial, XmlReaderSettings))
{
identical = xmlDiff.Compare(undeadReader, liveReader, diffgramWriter);
}
}
finally
{
undeadOial.Seek(0, SeekOrigin.Begin);
liveOial.Seek(0, SeekOrigin.Begin);
}
}
// Files have been compared, and the diff has been written to the diffgramwriter.
TextWriter resultHtml = new StreamWriter(outputStream);
resultHtml.WriteLine("<html><head>");
resultHtml.WriteLine("<style TYPE='text/css' MEDIA='screen'>");
resultHtml.Write("<!-- td { font-family: Courier New; font-size:14; } " +
"th { font-family: Arial; } " +
"p { font-family: Arial; } -->");
resultHtml.WriteLine("</style></head>");
resultHtml.WriteLine("<body><h3 style='font-family:Arial'>XmlDiff view</h3><table border='0'><tr><td><table border='0'>");
resultHtml.WriteLine("<tr><th>Undead OIAL</th><th>Live OIAL</th></tr>" +
"<tr><td colspan=2><hr size=1></td></tr>");
if (identical)
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are identical.</td></tr>");
}
else
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are different.</td></tr>");
}
diffgram.Seek(0, SeekOrigin.Begin);
XmlDiffView xmlDiffView = new XmlDiffView();
XmlTextReader sourceReader = new XmlTextReader(undeadOial);
sourceReader.XmlResolver = null;
xmlDiffView.Load(sourceReader, new XmlTextReader(diffgram));
xmlDiffView.GetHtml(resultHtml);
resultHtml.WriteLine("</table></table></body></html>");
resultHtml.Flush();
resultHtml.Close();
}
private void CompareResults(String orig, String curr) {
PdfReader cmpReader = new PdfReader(CMP_FOLDER + orig);
PdfReader outReader = new PdfReader(OUT_FOLDER + curr);
byte[] cmpBytes = cmpReader.Metadata, outBytes = outReader.Metadata;
IXmpMeta xmpMeta = XmpMetaFactory.ParseFromBuffer(cmpBytes);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.CREATEDATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.MODIFYDATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.METADATADATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_PDF, PdfProperties.PRODUCER, true, true);
cmpBytes = XmpMetaFactory.SerializeToBuffer(xmpMeta, new SerializeOptions(SerializeOptions.SORT));
xmpMeta = XmpMetaFactory.ParseFromBuffer(outBytes);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.CREATEDATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.MODIFYDATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_XMP, XmpBasicProperties.METADATADATE, true, true);
XmpUtils.RemoveProperties(xmpMeta, XmpConst.NS_PDF, PdfProperties.PRODUCER, true, true);
outBytes = XmpMetaFactory.SerializeToBuffer(xmpMeta, new SerializeOptions(SerializeOptions.SORT));
XmlDiff xmldiff = new XmlDiff(XmlDiffOptions.None);
if (!xmldiff.Compare(new XmlTextReader(new MemoryStream(cmpBytes)),
new XmlTextReader(new MemoryStream(outBytes)))) {
String currXmlName = curr.Replace(".pdf", ".xml");
FileStream outStream = new FileStream(OUT_FOLDER + "cmp_" + currXmlName, FileMode.Create);
outStream.Write(cmpBytes, 0, cmpBytes.Length);
outStream = new FileStream(OUT_FOLDER + currXmlName, FileMode.Create);
outStream.Write(outBytes, 0, outBytes.Length);
Assert.Fail("The XMP packages are different!!!");
}
}
/// <summary>
/// Invokes the XmlDiff Compare method. The strings attribute order and whitespace are ignored.
/// </summary>
/// <param name="diffs">The raw byte array of "diffgram" XML returned.</param>
/// <param name="same">True if the two xml strings are identical.</param>
/// <returns>Number of bytes read.</returns>
private int Compare(out byte [] diffs, out bool same)
{
Encoding enc = Encoding.UTF8; //.Unicode;
System.IO.Stream stream = new System.IO.MemoryStream();
XmlDiff xDiff = new XmlDiff(XmlDiffOptions.IgnoreWhitespace);
XmlWriter writer = new XmlTextWriter(stream, enc);
same = xDiff.Compare(m_baseReader, m_targetReader, writer);
stream.Position = 0;
diffs = new Byte[stream.Length];
int bytesRead = stream.Read(diffs,0,(int)stream.Length);
writer.Close(); // closes stream too.
m_Compared = true;
return bytesRead;
}
virtual protected bool CompareXmls(String xml1, String xml2) {
XmlDiff xmldiff = new XmlDiff(XmlDiffOptions.None);
return xmldiff.Compare(xml1, xml2, false);
}
public void Serialization()
{
try {
XmlDiff diff = new XmlDiff();
TemplateBox templateBox = new TemplateBox(TemplatingResources.TemplatesDefault);
String result = templateBox.Serialize();
//Utils.WriteToFile(@"C:\temp\templates.xml", result);
diff.IgnoreChildOrder = true;
diff.IgnoreComments = true;
diff.IgnoreDtd = true;
diff.IgnoreNamespaces = true;
diff.IgnorePI = true;
diff.IgnorePrefixes = true;
diff.IgnoreWhitespace = true;
diff.IgnoreXmlDecl = true;
StringWriter diffgramString = new StringWriter();
XmlTextWriter diffgramXml = new XmlTextWriter(diffgramString);
bool diffBool = diff.Compare(new XmlTextReader(new StringReader(result)), new XmlTextReader(new StringReader(TemplatingResources.TemplatesDefault)), diffgramXml);
//MessageBox.Show(diffgramString.ToString());
Assert.True(diffBool, diffgramXml.ToString());
} catch (Exception e) {
Assert.Fail("Exception: " + e.GetType().Name + "\n" + e.Message + "\n" + e.StackTrace);
}
}
private void Compare(String outPdf, String cmpPdf) {
CompareTool ct = new CompareTool(outPdf, cmpPdf);
Assert.IsNull(ct.Compare(OUT_FOLDER, "difference"));
String outXml = Path.GetFileNameWithoutExtension(outPdf);
String cmpXml = Path.GetFileNameWithoutExtension(cmpPdf);
outXml = OUT_FOLDER + outXml.Replace(".pdf", "") + ".xml";
cmpXml = OUT_FOLDER + "cmp_" + cmpXml.Replace("cmp_", "").Replace(".pdf", "") + ".xml";
PdfReader reader = new PdfReader(outPdf);
new MyTaggedPdfReaderTool().ConvertToXml(reader, new FileStream(outXml, FileMode.Create));
reader.Close();
reader = new PdfReader(outPdf);
new MyTaggedPdfReaderTool().ConvertToXml(reader, new FileStream(cmpXml, FileMode.Create));
reader.Close();
XmlDiff xmldiff = new XmlDiff(XmlDiffOptions.None);
Assert.True(xmldiff.Compare(cmpXml, outXml, false));
}
