// Constructor
        internal MinimalTreeDistanceAlgo( XmlDiff xmlDiff )
        {
            Debug.Assert( OperationCost.Length - 1 == (int)XmlDiffOperation.Undefined,
                      "Correct the OperationCost array so that it reflects the XmlDiffOperation enum." );

            Debug.Assert( xmlDiff != null );
            _xmlDiff = xmlDiff;
        }
Exemple #2
1
        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));
        }
 public Comparer(IDiffManager manager)
 {
     _results = new List<BaseDiffResultObject>();
     _diff = new XmlDiff();
     _diffOptions = new XmlDiffOptions();
     _tempFilePath = Path.GetTempFileName();
     Manager = manager;
 }
        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>&nbsp;&nbsp;<font style='background-color: red'" +
                "color='black'>removed</font>&nbsp;&nbsp;<font style='background-color: " +
                "lightgreen' color='black'>changed</font>&nbsp;&nbsp;" +
                "<font style='background-color: red' color='blue'>moved from</font>" +
                "&nbsp;&nbsp;<font style='background-color: yellow' color='blue'>moved to" +
                "</font>&nbsp;&nbsp;<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);
        }
        /// <summary>
        /// Create a default XML difference engine using the <see cref="DefaultDiffOptions" />
        /// </summary>
        /// <returns></returns>
        public static XmlDiff DefaultDiffEngine()
        {
            var xmlDiff = new XmlDiff
            {
                Options = DefaultDiffOptions(),
                Algorithm = XmlDiffAlgorithm.Auto
            };

            return xmlDiff;
        }
		public CoordinateSystemXmlReaderTest() 
		{
			XmlDiffOptions ignoreMost = XmlDiffOptions.IgnoreChildOrder | 
				XmlDiffOptions.IgnoreComments | 
				XmlDiffOptions.IgnoreDtd | 
				XmlDiffOptions.IgnorePI |
				XmlDiffOptions.IgnoreWhitespace |
				XmlDiffOptions.IgnoreXmlDecl ;

			_xmlDiff = new XmlDiff(ignoreMost);
		}
// Constructor

	internal XmlHash( XmlDiff xmlDiff )
	{
        // set flags
        _bIgnoreChildOrder  = xmlDiff.IgnoreChildOrder;
        _bIgnoreComments    = xmlDiff.IgnoreComments;
        _bIgnorePI          = xmlDiff.IgnorePI;
        _bIgnoreWhitespace  = xmlDiff.IgnoreWhitespace;
        _bIgnoreNamespaces  = xmlDiff.IgnoreNamespaces;
        _bIgnorePrefixes    = xmlDiff.IgnorePrefixes;
        _bIgnoreXmlDecl     = xmlDiff.IgnoreXmlDecl;
        _bIgnoreDtd         = xmlDiff.IgnoreDtd;
	}
        private static XmlDiff GetDiffTool()
        {
            var diff = new Microsoft.XmlDiffPatch.XmlDiff();

            diff.IgnoreWhitespace = true;
            diff.IgnoreComments   = true;
            diff.IgnoreXmlDecl    = true;
            diff.IgnoreDtd        = true;
            //diff.IgnoreChildOrder = true;
            diff.IgnorePrefixes = true;
            return(diff);
        }
Exemple #10
0
        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;
            }
        }
Exemple #11
0
        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);
                }
            }
        }
Exemple #12
0
 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
                );
            }
        }
Exemple #15
0
        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();
        }
Exemple #16
0
        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();
            }
        }
Exemple #17
0
 internal Diffgram(XmlDiff xmlDiff)
     : base(0UL)
 {
     this._xmlDiff = xmlDiff;
 }
        // Methods
        internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
        {
            xmlWriter.WriteStartElement( XmlDiff.Prefix, "remove", XmlDiff.NamespaceUri );
            xmlWriter.WriteAttributeString( "match", _sourceNode.GetRelativeAddress() );
            if ( !_bSubtree )
            xmlWriter.WriteAttributeString( "subtree", "no" );
            if ( _operationID != 0 )
            xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );

            WriteChildrenTo( xmlWriter, xmlDiff );

            xmlWriter.WriteEndElement();
        }
        // Methods
        internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
        {
            xmlWriter.WriteStartElement( XmlDiff.Prefix, "node", XmlDiff.NamespaceUri );
            xmlWriter.WriteAttributeString( "match", _sourceNode.GetRelativeAddress() );

            WriteChildrenTo( xmlWriter, xmlDiff );

            xmlWriter.WriteEndElement();
        }
Exemple #20
0
 // compares the node to another one and returns the xmldiff operation for changing this node to the other
 internal override XmlDiffOperation GetDiffOperation(XmlDiffNode changedNode, XmlDiff xmlDiff)
 {
     Debug.Assert(false, "This method should be never called.");
     return(XmlDiffOperation.Undefined);
 }
        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();
            */
        }
Exemple #22
0
        private ulong ComputeHashXmlNode(XmlNode node)
        {
            switch (node.NodeType)
            {
            case XmlNodeType.Element:
            {
                XmlElement    el = (XmlElement)node;
                HashAlgorithm ha = new HashAlgorithm();

                HashElement(ha, el.LocalName, el.Prefix, el.NamespaceURI);
                ComputeHashXmlChildren(ha, el);

                return(ha.Hash);
            }

            case XmlNodeType.Attribute:
                // attributes are hashed in ComputeHashXmlChildren;
                Debug.Assert(false);
                return(0);

            case XmlNodeType.Whitespace:
                return(0);

            case XmlNodeType.SignificantWhitespace:
                if (!_bIgnoreWhitespace)
                {
                    goto case XmlNodeType.Text;
                }
                return(0);

            case XmlNodeType.Comment:
                if (!_bIgnoreComments)
                {
                    return(HashCharacterNode(XmlNodeType.Comment, ((XmlCharacterData)node).Value));
                }
                return(0);

            case XmlNodeType.Text:
            {
                XmlCharacterData cd = (XmlCharacterData)node;
                if (_bIgnoreWhitespace)
                {
                    return(HashCharacterNode(cd.NodeType, XmlDiff.NormalizeText(cd.Value)));
                }
                else
                {
                    return(HashCharacterNode(cd.NodeType, cd.Value));
                }
            }

            case XmlNodeType.CDATA:
            {
                XmlCharacterData cd = (XmlCharacterData)node;
                return(HashCharacterNode(cd.NodeType, cd.Value));
            }

            case XmlNodeType.ProcessingInstruction:
            {
                if (_bIgnorePI)
                {
                    return(0);
                }

                XmlProcessingInstruction pi = (XmlProcessingInstruction)node;
                return(HashPI(pi.Target, pi.Value));
            }

            case XmlNodeType.EntityReference:
            {
#if NETCORE
                throw new NotSupportedException("XmlNodeType.EntityReference is not supported");
#else
                XmlEntityReference er = (XmlEntityReference)node;
                return(HashER(er.Name));
#endif
            }

            case XmlNodeType.XmlDeclaration:
            {
                if (_bIgnoreXmlDecl)
                {
                    return(0);
                }
                XmlDeclaration decl = (XmlDeclaration)node;
                return(HashXmlDeclaration(XmlDiff.NormalizeXmlDeclaration(decl.Value)));
            }

            case XmlNodeType.DocumentType:
            {
                if (_bIgnoreDtd)
                {
                    return(0);
                }
#if NETCORE
                throw new NotSupportedException("XmlNodeType.DocumentType is not supported");
#else
                XmlDocumentType docType = (XmlDocumentType)node;
                return(HashDocumentType(docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset));
#endif
            }

            case XmlNodeType.DocumentFragment:
                return(0);

            default:
                Debug.Assert(false);
                return(0);
            }
        }
Exemple #23
0
        private void ComputeHashXmlChildren(HashAlgorithm ha, XmlNode parent)
        {
            XmlElement el = parent as XmlElement;

            if (el != null)
            {
                ulong attrHashSum            = 0;
                int   attrsCount             = 0;
                XmlAttributeCollection attrs = ((XmlElement)parent).Attributes;
                for (int i = 0; i < attrs.Count; i++)
                {
                    XmlAttribute attr = (XmlAttribute)attrs.Item(i);

                    ulong hashValue = 0;

                    // default namespace def
                    if (attr.LocalName == "xmlns" && attr.Prefix == string.Empty)
                    {
                        if (_bIgnoreNamespaces)
                        {
                            continue;
                        }
                        hashValue = HashNamespace(string.Empty, attr.Value);
                    }
                    // namespace def
                    else if (attr.Prefix == "xmlns")
                    {
                        if (_bIgnoreNamespaces)
                        {
                            continue;
                        }
                        hashValue = HashNamespace(attr.LocalName, attr.Value);
                    }
                    // attribute
                    else
                    {
                        if (_bIgnoreWhitespace)
                        {
                            hashValue = HashAttribute(attr.LocalName, attr.Prefix, attr.NamespaceURI, XmlDiff.NormalizeText(attr.Value));
                        }
                        else
                        {
                            hashValue = HashAttribute(attr.LocalName, attr.Prefix, attr.NamespaceURI, attr.Value);
                        }
                    }

                    Debug.Assert(hashValue != 0);

                    attrsCount++;
                    attrHashSum += hashValue;
                }

                if (attrsCount != 0)
                {
                    ha.AddULong(attrHashSum);
                    ha.AddInt(attrsCount);
                }
            }

            int childrenCount = 0;

            if (_bIgnoreChildOrder)
            {
                ulong   totalHashSum = 0;
                XmlNode curChild     = parent.FirstChild;
                while (curChild != null)
                {
                    ulong hashValue = ComputeHashXmlNode(curChild);
                    if (hashValue != 0)
                    {
                        totalHashSum += hashValue;
                        childrenCount++;
                    }
                    curChild = curChild.NextSibling;
                }
                ha.AddULong(totalHashSum);
            }
            else
            {
                XmlNode curChild = parent.FirstChild;
                while (curChild != null)
                {
                    ulong hashValue = ComputeHashXmlNode(curChild);
                    if (hashValue != 0)
                    {
                        ha.AddULong(hashValue);
                        childrenCount++;
                    }
                    curChild = curChild.NextSibling;
                }
            }
            if (childrenCount != 0)
            {
                ha.AddInt(childrenCount);
            }
        }
        private void ComputeTreeDistance(int sourcePos, int targetPos)
        {
            int sourcePosLeft = _sourceNodes[sourcePos].Left;
            int targetPosLeft = _targetNodes[targetPos].Left;
            int i, j;

            // init borders of _forestDist array
            EditScriptAddOpened    esAdd    = new EditScriptAddOpened(targetPosLeft, EmptyEditScript);
            EditScriptRemoveOpened esRemove = new EditScriptRemoveOpened(sourcePosLeft, EmptyEditScript);

            _forestDist[sourcePosLeft - 1, targetPosLeft - 1]._cost       = 0;
            _forestDist[sourcePosLeft - 1, targetPosLeft - 1]._editScript = EmptyEditScript;

            for (i = sourcePosLeft; i <= sourcePos; i++)
            {
                _forestDist[i, targetPosLeft - 1]._cost       = (i - sourcePosLeft + 1) * OperationCost[(int)XmlDiffOperation.Remove];
                _forestDist[i, targetPosLeft - 1]._editScript = esRemove;
            }
            for (j = targetPosLeft; j <= targetPos; j++)
            {
                _forestDist[sourcePosLeft - 1, j]._cost       = (j - targetPosLeft + 1) * OperationCost[(int)XmlDiffOperation.Add];
                _forestDist[sourcePosLeft - 1, j]._editScript = esAdd;
            }

#if DEBUG
            Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "\nForest distance (" + sourcePos + "," + targetPos + "):\n");
            Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "       0    ");
            for (j = targetPosLeft; j <= targetPos; j++)
            {
                Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, j + "    ");
            }
            Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "\n   ");
            for (j = targetPosLeft - 1; j <= targetPos; j++)
            {
                Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "*****");
            }
            Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "\n0  *   0   ");
            for (j = targetPosLeft; j <= targetPos; j++)
            {
                Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "-" + _forestDist[sourcePosLeft - 1, j]._cost + "   ");
            }
            Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "\n");
#endif

            // compute the inside of _forestDist array
            for (i = sourcePosLeft; i <= sourcePos; i++)
            {
#if DEBUG
                Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, i + "  *  |" + _forestDist[i, targetPosLeft - 1]._cost + "   ");
#endif

                for (j = targetPosLeft; j <= targetPos; j++)
                {
                    int sourceCurLeft = _sourceNodes[i].Left;
                    int targetCurLeft = _targetNodes[j].Left;

                    int removeCost = _forestDist[i - 1, j]._cost + OperationCost[(int)XmlDiffOperation.Remove];
                    int addCost    = _forestDist[i, j - 1]._cost + OperationCost[(int)XmlDiffOperation.Add];

                    if (sourceCurLeft == sourcePosLeft && targetCurLeft == targetPosLeft)
                    {
                        XmlDiffOperation changeOp = _sourceNodes[i].GetDiffOperation(_targetNodes[j], _xmlDiff);

                        Debug.Assert(XmlDiff.IsChangeOperation(changeOp) ||
                                     changeOp == XmlDiffOperation.Match ||
                                     changeOp == XmlDiffOperation.Undefined);

                        if (changeOp == XmlDiffOperation.Match)
                        {
                            // identical nodes matched
                            OpNodesMatch(i, j);
                        }
                        else
                        {
                            int changeCost = _forestDist[i - 1, j - 1]._cost + OperationCost[(int)changeOp];

                            if (changeCost < addCost)
                            {
                                // operation 'change'
                                if (changeCost < removeCost)
                                {
                                    OpChange(i, j, changeOp, changeCost);
                                }
                                // operation 'remove'
                                else
                                {
                                    OpRemove(i, j, removeCost);
                                }
                            }
                            else
                            {
                                // operation 'add'
                                if (addCost < removeCost)
                                {
                                    OpAdd(i, j, addCost);
                                }
                                // operation 'remove'
                                else
                                {
                                    OpRemove(i, j, removeCost);
                                }
                            }
                        }

                        _treeDist[i, j]._cost       = _forestDist[i, j]._cost;
                        _treeDist[i, j]._editScript = _forestDist[i, j]._editScript.GetClosedScript(i, j);;
                    }
                    else
                    {
                        int m = sourceCurLeft - 1;
                        int n = targetCurLeft - 1;

                        if (m < sourcePosLeft - 1)
                        {
                            m = sourcePosLeft - 1;
                        }
                        if (n < targetPosLeft - 1)
                        {
                            n = targetPosLeft - 1;
                        }

                        // cost of concatenating of the two edit scripts
                        int compoundEditCost = _forestDist[m, n]._cost + _treeDist[i, j]._cost;

                        if (compoundEditCost < addCost)
                        {
                            if (compoundEditCost < removeCost)
                            {
                                // copy script
                                if (_treeDist[i, j]._editScript == EmptyEditScript)
                                {
                                    Debug.Assert(_treeDist[i, j]._cost == 0);
                                    OpCopyScript(i, j, m, n);
                                }
                                // concatenate scripts
                                else
                                {
                                    OpConcatScripts(i, j, m, n);
                                }
                            }
                            // operation 'remove'
                            else
                            {
                                OpRemove(i, j, removeCost);
                            }
                        }
                        else
                        {
                            // operation 'add'
                            if (addCost < removeCost)
                            {
                                OpAdd(i, j, addCost);
                            }
                            // operation 'remove'
                            else
                            {
                                OpRemove(i, j, removeCost);
                            }
                        }
                    }
#if DEBUG
                    Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, _forestDist[i, j]._cost + "   ");
#endif
                }
#if DEBUG
                Trace.WriteIf(XmlDiff.T_ForestDistance.Enabled, "\n");
#endif
            }
        }
Exemple #25
0
        internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff)
        {
            xmlWriter.WriteStartElement("xd", "add", "http://schemas.microsoft.com/xmltools/2002/xmldiff");
            switch (this._targetNode.NodeType)
            {
            case XmlDiffNodeType.XmlDeclaration:
                xmlWriter.WriteAttributeString("type", 17.ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteString(((XmlDiffXmlDeclaration)this._targetNode).Value);
                break;

            case XmlDiffNodeType.DocumentType:
                xmlWriter.WriteAttributeString("type", 10.ToString());
                var targetNode1 = (XmlDiffDocumentType)this._targetNode;
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteAttributeString("name", targetNode1.Name);
                if (targetNode1.PublicId != string.Empty)
                {
                    xmlWriter.WriteAttributeString("publicId", targetNode1.PublicId);
                }
                if (targetNode1.SystemId != string.Empty)
                {
                    xmlWriter.WriteAttributeString("systemId", targetNode1.SystemId);
                }
                if (targetNode1.Subset != string.Empty)
                {
                    xmlWriter.WriteCData(targetNode1.Subset);
                    break;
                }
                break;

            case XmlDiffNodeType.Element:
                xmlWriter.WriteAttributeString("type", 1.ToString());
                var targetNode2 = this._targetNode as XmlDiffElement;
                xmlWriter.WriteAttributeString("name", targetNode2.LocalName);
                if (targetNode2.NamespaceURI != string.Empty)
                {
                    xmlWriter.WriteAttributeString("ns", targetNode2.NamespaceURI);
                }
                if (targetNode2.Prefix != string.Empty)
                {
                    xmlWriter.WriteAttributeString("prefix", targetNode2.Prefix);
                }
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                this.WriteChildrenTo(xmlWriter, xmlDiff);
                break;

            case XmlDiffNodeType.Attribute:
                xmlWriter.WriteAttributeString("type", 2.ToString());
                var targetNode3 = this._targetNode as XmlDiffAttribute;
                xmlWriter.WriteAttributeString("name", targetNode3.LocalName);
                if (targetNode3.NamespaceURI != string.Empty)
                {
                    xmlWriter.WriteAttributeString("ns", targetNode3.NamespaceURI);
                }
                if (targetNode3.Prefix != string.Empty)
                {
                    xmlWriter.WriteAttributeString("prefix", targetNode3.Prefix);
                }
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteString(targetNode3.Value);
                break;

            case XmlDiffNodeType.Text:
                xmlWriter.WriteAttributeString("type", ((int)this._targetNode.NodeType).ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteString((this._targetNode as XmlDiffCharData).Value);
                break;

            case XmlDiffNodeType.CDATA:
                xmlWriter.WriteAttributeString("type", ((int)this._targetNode.NodeType).ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteCData((this._targetNode as XmlDiffCharData).Value);
                break;

            case XmlDiffNodeType.EntityReference:
                xmlWriter.WriteAttributeString("type", 5.ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteAttributeString("name", ((XmlDiffER)this._targetNode).Name);
                break;

            case XmlDiffNodeType.ProcessingInstruction:
                xmlWriter.WriteAttributeString("type", ((int)this._targetNode.NodeType).ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                var targetNode4 = this._targetNode as XmlDiffPI;
                xmlWriter.WriteProcessingInstruction(targetNode4.Name, targetNode4.Value);
                break;

            case XmlDiffNodeType.Comment:
                xmlWriter.WriteAttributeString("type", ((int)this._targetNode.NodeType).ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteComment((this._targetNode as XmlDiffCharData).Value);
                break;

            case XmlDiffNodeType.SignificantWhitespace:
                xmlWriter.WriteAttributeString("type", ((int)this._targetNode.NodeType).ToString());
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteString(((XmlDiffCharData)this._targetNode).Value);
                break;

            case XmlDiffNodeType.Namespace:
                xmlWriter.WriteAttributeString("type", 2.ToString());
                var targetNode5 = this._targetNode as XmlDiffNamespace;
                if (targetNode5.Prefix != string.Empty)
                {
                    xmlWriter.WriteAttributeString("prefix", "xmlns");
                    xmlWriter.WriteAttributeString("name", targetNode5.Prefix);
                }
                else
                {
                    xmlWriter.WriteAttributeString("name", "xmlns");
                }
                if (this._operationID != 0UL)
                {
                    xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
                }
                xmlWriter.WriteString(targetNode5.NamespaceURI);
                break;
            }
            xmlWriter.WriteEndElement();
        }
Exemple #26
0
 // compares the node to another one and returns true, if the nodes are identical;
 // on elements this method ignores namespace declarations
 internal virtual bool IsSameAs(XmlDiffNode node, XmlDiff xmlDiff)
 {
     return(GetDiffOperation(node, xmlDiff) == XmlDiffOperation.Match);
 }
Exemple #27
0
        private void Patch(ref XmlNode sourceNode, XmlDocument diffDoc)
        {
            XmlElement diffgramEl = diffDoc.DocumentElement;

            if (diffgramEl.LocalName != "xmldiff" || diffgramEl.NamespaceURI != XmlDiff.NamespaceUri)
            {
                XmlPatchError.Error(XmlPatchError.ExpectingDiffgramElement);
            }

            XmlNamedNodeMap diffgramAttributes = diffgramEl.Attributes;
            XmlAttribute    srcDocAttr         = (XmlAttribute)diffgramAttributes.GetNamedItem("srcDocHash");

            if (srcDocAttr == null)
            {
                XmlPatchError.Error(XmlPatchError.MissingSrcDocAttribute);
            }

            ulong hashValue = 0;

            try
            {
                hashValue = ulong.Parse(srcDocAttr.Value);
            }
            catch
            {
                XmlPatchError.Error(XmlPatchError.InvalidSrcDocAttribute);
            }

            XmlAttribute optionsAttr = (XmlAttribute)diffgramAttributes.GetNamedItem("options");

            if (optionsAttr == null)
            {
                XmlPatchError.Error(XmlPatchError.MissingOptionsAttribute);
            }

            // parse options
            XmlDiffOptions xmlDiffOptions = XmlDiffOptions.None;

            try
            {
                xmlDiffOptions = XmlDiff.ParseOptions(optionsAttr.Value);
            }
            catch
            {
                XmlPatchError.Error(XmlPatchError.InvalidOptionsAttribute);
            }

            _ignoreChildOrder = ((int)xmlDiffOptions & (int)XmlDiffOptions.IgnoreChildOrder) != 0;

            // Calculate the hash value of source document and check if it agrees with
            // of srcDocHash attribute value.
            if (!XmlDiff.VerifySource(sourceNode, hashValue, xmlDiffOptions))
            {
                XmlPatchError.Error(XmlPatchError.SrcDocMismatch);
            }

            // Translate diffgram & Apply patch
            if (sourceNode.NodeType == XmlNodeType.Document)
            {
                Patch patch = CreatePatch(sourceNode, diffgramEl);

                // create temporary root element and move all document children under it
                XmlDocument sourceDoc = (XmlDocument)sourceNode;
                XmlElement  tempRoot  = sourceDoc.CreateElement("tempRoot");
                XmlNode     child     = sourceDoc.FirstChild;
                while (child != null)
                {
                    XmlNode tmpChild = child.NextSibling;

                    if (child.NodeType != XmlNodeType.XmlDeclaration &&
                        child.NodeType != XmlNodeType.DocumentType)
                    {
                        sourceDoc.RemoveChild(child);
                        tempRoot.AppendChild(child);
                    }

                    child = tmpChild;
                }
                sourceDoc.AppendChild(tempRoot);

                // Apply patch
                XmlNode temp = null;
                patch.Apply(tempRoot, ref temp);

                // remove the temporary root element
                if (sourceNode.NodeType == XmlNodeType.Document)
                {
                    sourceDoc.RemoveChild(tempRoot);
                    Debug.Assert(tempRoot.Attributes.Count == 0);
                    while ((child = tempRoot.FirstChild) != null)
                    {
                        tempRoot.RemoveChild(child);
                        sourceDoc.AppendChild(child);
                    }
                }
            }
            else if (sourceNode.NodeType == XmlNodeType.DocumentFragment)
            {
                Patch   patch = CreatePatch(sourceNode, diffgramEl);
                XmlNode temp  = null;
                patch.Apply(sourceNode, ref temp);
            }
            else
            {
                // create fragment with sourceNode as its only child
                XmlDocumentFragment fragment               = sourceNode.OwnerDocument.CreateDocumentFragment();
                XmlNode             previousSourceParent   = sourceNode.ParentNode;
                XmlNode             previousSourceSibbling = sourceNode.PreviousSibling;

                if (previousSourceParent != null)
                {
                    previousSourceParent.RemoveChild(sourceNode);
                }
                if (sourceNode.NodeType != XmlNodeType.XmlDeclaration)
                {
                    fragment.AppendChild(sourceNode);
                }
                else
                {
                    fragment.InnerXml = sourceNode.OuterXml;
                }

                Patch   patch = CreatePatch(fragment, diffgramEl);
                XmlNode temp  = null;
                patch.Apply(fragment, ref temp);

                XmlNodeList childNodes = fragment.ChildNodes;
                if (childNodes.Count != 1)
                {
                    XmlPatchError.Error(XmlPatchError.InternalErrorMoreThanOneNodeLeft, childNodes.Count.ToString());
                }

                sourceNode = childNodes.Item(0);
                fragment.RemoveAll();
                if (previousSourceParent != null)
                {
                    previousSourceParent.InsertAfter(sourceNode, previousSourceSibbling);
                }
            }
        }
Exemple #28
0
 internal XmlDiffDocument(XmlDiff xmlDiff)
   : base(0)
 {
   this._bLoaded = false;
   this._XmlDiff = xmlDiff;
 }
        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));
        }
Exemple #30
0
 internal override void WriteToXmlReadable(XmlWriter xmlWriter, XmlDiff xmlDiff)
 {
     _xmlDiff = xmlDiff;
     WriteToXmlReadable(xmlWriter);
 }
Exemple #31
0
        internal XmlDiffNode LoadNode(XmlNode node, ref int childPosition)
        {
            switch (node.NodeType)
            {
            case XmlNodeType.Element:
                XmlDiffElement elem = new XmlDiffElement(++childPosition, node.LocalName, node.Prefix, node.NamespaceURI);
                LoadChildNodes(elem, node);
                elem.ComputeHashValue(_xmlHash);
                return(elem);

            case XmlNodeType.Attribute:
                Debug.Assert(false, "Attributes cannot be loaded by this method.");
                return(null);

            case XmlNodeType.Text:
                string          textValue = (_XmlDiff.IgnoreWhitespace) ? XmlDiff.NormalizeText(node.Value) : node.Value;
                XmlDiffCharData text      = new XmlDiffCharData(++childPosition, textValue, XmlDiffNodeType.Text);
                text.ComputeHashValue(_xmlHash);
                return(text);

            case XmlNodeType.CDATA:
                XmlDiffCharData cdata = new XmlDiffCharData(++childPosition, node.Value, XmlDiffNodeType.CDATA);
                cdata.ComputeHashValue(_xmlHash);
                return(cdata);

            case XmlNodeType.EntityReference:
                XmlDiffER er = new XmlDiffER(++childPosition, node.Name);
                er.ComputeHashValue(_xmlHash);
                return(er);

            case XmlNodeType.Comment:
                ++childPosition;
                if (_XmlDiff.IgnoreComments)
                {
                    return(null);
                }

                XmlDiffCharData comment = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.Comment);
                comment.ComputeHashValue(_xmlHash);
                return(comment);

            case XmlNodeType.ProcessingInstruction:
                ++childPosition;
                if (_XmlDiff.IgnorePI)
                {
                    return(null);
                }

                XmlDiffPI pi = new XmlDiffPI(childPosition, node.Name, node.Value);
                pi.ComputeHashValue(_xmlHash);
                return(pi);

            case XmlNodeType.SignificantWhitespace:
                ++childPosition;
                if (_XmlDiff.IgnoreWhitespace)
                {
                    return(null);
                }
                XmlDiffCharData ws = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.SignificantWhitespace);
                ws.ComputeHashValue(_xmlHash);
                return(ws);

            case XmlNodeType.XmlDeclaration:
                ++childPosition;
                if (_XmlDiff.IgnoreXmlDecl)
                {
                    return(null);
                }
                XmlDiffXmlDeclaration xmlDecl = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(node.Value));
                xmlDecl.ComputeHashValue(_xmlHash);
                return(xmlDecl);

            case XmlNodeType.EndElement:
                return(null);

            case XmlNodeType.DocumentType:
                childPosition++;
                if (_XmlDiff.IgnoreDtd)
                {
                    return(null);
                }
#if NETCORE
                throw new NotSupportedException("XmlNodeType.DocumentType is not supported.");
#else
                XmlDocumentType     docType     = (XmlDocumentType)node;
                XmlDiffDocumentType diffDocType = new XmlDiffDocumentType(childPosition, docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset);
                diffDocType.ComputeHashValue(_xmlHash);
                return(diffDocType);
#endif
            default:
                Debug.Assert(false);
                return(null);
            }
        }
 // Methods
 internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
 {
     xmlWriter.WriteStartElement( XmlDiff.Prefix, "remove", XmlDiff.NamespaceUri );
     GetAddressOfAttributeInterval( _attributes, xmlWriter );
     Debug.Assert( _operationID == 0 );
     xmlWriter.WriteEndElement();
 }
Exemple #33
0
        // Loads child nodes of the 'parent' node
        internal void LoadChildNodes(XmlDiffParentNode parent, XmlNode parentDomNode)
        {
            XmlDiffNode savedLastChild = _curLastChild;

            _curLastChild = null;

            // load attributes & namespace nodes
            XmlNamedNodeMap attribs = parentDomNode.Attributes;

            if (attribs != null && attribs.Count > 0)
            {
                IEnumerator attrEnum = attribs.GetEnumerator();
                while (attrEnum.MoveNext())
                {
                    XmlAttribute attr = (XmlAttribute)attrEnum.Current;
                    if (attr.Prefix == "xmlns")
                    {
                        if (!_XmlDiff.IgnoreNamespaces)
                        {
                            XmlDiffNamespace nsNode = new XmlDiffNamespace(attr.LocalName, attr.Value);
                            nsNode.ComputeHashValue(_xmlHash);
                            InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode);
                        }
                    }
                    else if (attr.Prefix == string.Empty && attr.LocalName == "xmlns")
                    {
                        if (!_XmlDiff.IgnoreNamespaces)
                        {
                            XmlDiffNamespace nsNode = new XmlDiffNamespace(string.Empty, attr.Value);
                            nsNode.ComputeHashValue(_xmlHash);
                            InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode);
                        }
                    }
                    else
                    {
                        string           attrValue = _XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(attr.Value) : attr.Value;
                        XmlDiffAttribute newAttr   = new XmlDiffAttribute(attr.LocalName, attr.Prefix, attr.NamespaceURI, attrValue);
                        newAttr.ComputeHashValue(_xmlHash);
                        InsertAttributeOrNamespace((XmlDiffElement)parent, newAttr);
                    }
                }
            }

            // load children
            XmlNodeList children = parentDomNode.ChildNodes;

            if (children.Count == 0)
            {
                goto End;
            }

            int         childPosition = 0;
            IEnumerator childEnum     = children.GetEnumerator();

            while (childEnum.MoveNext())
            {
                XmlNode node = (XmlNode)childEnum.Current;

                // ignore whitespaces between nodes
                if (node.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }

                XmlDiffNode newDiffNode = LoadNode((XmlNode)childEnum.Current, ref childPosition);
                if (newDiffNode != null)
                {
                    InsertChild(parent, newDiffNode);
                }
            }

End:
            _curLastChild = savedLastChild;
        }
Exemple #34
0
// Constructor
        internal Diffgram(XmlDiff xmlDiff) : base(0)
        {
            _xmlDiff = xmlDiff;
        }
Exemple #35
0
 internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff)
 {
     this._xmlDiff = xmlDiff;
     this.WriteTo(xmlWriter);
 }
Exemple #36
0
 internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff)
 {
     _xmlDiff = xmlDiff;
     WriteTo(xmlWriter);
 }
Exemple #37
0
        // Loads child nodes of the 'parent' node
        internal void LoadChildNodes(XmlDiffParentNode parent, XmlReader reader, bool bEmptyElement)
        {
            XmlDiffNode savedLastChild = _curLastChild;

            _curLastChild = null;

            // load attributes & namespace nodes
            while (reader.MoveToNextAttribute())
            {
                if (reader.Prefix == "xmlns")
                {
                    if (!_XmlDiff.IgnoreNamespaces)
                    {
                        XmlDiffNamespace nsNode = new XmlDiffNamespace(reader.LocalName, reader.Value);
                        nsNode.ComputeHashValue(_xmlHash);
                        InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode);
                    }
                }
                else if (reader.Prefix == string.Empty && reader.LocalName == "xmlns")
                {
                    if (!_XmlDiff.IgnoreNamespaces)
                    {
                        XmlDiffNamespace nsNode = new XmlDiffNamespace(string.Empty, reader.Value);
                        nsNode.ComputeHashValue(_xmlHash);
                        InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode);
                    }
                }
                else
                {
                    string           attrValue = _XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(reader.Value) : reader.Value;
                    XmlDiffAttribute attr      = new XmlDiffAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, attrValue);
                    attr.ComputeHashValue(_xmlHash);
                    InsertAttributeOrNamespace((XmlDiffElement)parent, attr);
                }
            }

            // empty element -> return, do not load chilren
            if (bEmptyElement)
            {
                goto End;
            }

            int childPosition = 0;

            // load children
            if (!reader.Read())
            {
                goto End;
            }

            do
            {
                // ignore whitespaces between nodes
                if (reader.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }

                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                {
                    bool           bEmptyEl = reader.IsEmptyElement;
                    XmlDiffElement elem     = new XmlDiffElement(++childPosition, reader.LocalName, reader.Prefix, reader.NamespaceURI);

                    LoadChildNodes(elem, reader, bEmptyEl);

                    elem.ComputeHashValue(_xmlHash);
                    InsertChild(parent, elem);
                    break;
                }

                case XmlNodeType.Attribute:
                {
                    Debug.Assert(false, "We should never get to this point, attributes should be read at the beginning of thid method.");
                    break;
                }

                case XmlNodeType.Text:
                {
                    string          textValue    = (_XmlDiff.IgnoreWhitespace) ? XmlDiff.NormalizeText(reader.Value) : reader.Value;
                    XmlDiffCharData charDataNode = new XmlDiffCharData(++childPosition, textValue, XmlDiffNodeType.Text);
                    charDataNode.ComputeHashValue(_xmlHash);
                    InsertChild(parent, charDataNode);
                    break;
                }

                case XmlNodeType.CDATA:
                {
                    XmlDiffCharData charDataNode = new XmlDiffCharData(++childPosition, reader.Value, XmlDiffNodeType.CDATA);
                    charDataNode.ComputeHashValue(_xmlHash);
                    InsertChild(parent, charDataNode);
                    break;
                }

                case XmlNodeType.EntityReference:
                {
                    XmlDiffER er = new XmlDiffER(++childPosition, reader.Name);
                    er.ComputeHashValue(_xmlHash);
                    InsertChild(parent, er);
                    break;
                }

                case XmlNodeType.Comment:
                {
                    ++childPosition;
                    if (!_XmlDiff.IgnoreComments)
                    {
                        XmlDiffCharData charDataNode = new XmlDiffCharData(childPosition, reader.Value, XmlDiffNodeType.Comment);
                        charDataNode.ComputeHashValue(_xmlHash);
                        InsertChild(parent, charDataNode);
                    }
                    break;
                }

                case XmlNodeType.ProcessingInstruction:
                {
                    ++childPosition;
                    if (!_XmlDiff.IgnorePI)
                    {
                        XmlDiffPI pi = new XmlDiffPI(childPosition, reader.Name, reader.Value);
                        pi.ComputeHashValue(_xmlHash);
                        InsertChild(parent, pi);
                    }
                    break;
                }

                case XmlNodeType.SignificantWhitespace:
                {
                    if (reader.XmlSpace == XmlSpace.Preserve)
                    {
                        ++childPosition;
                        if (!_XmlDiff.IgnoreWhitespace)
                        {
                            XmlDiffCharData charDataNode = new XmlDiffCharData(childPosition, reader.Value, XmlDiffNodeType.SignificantWhitespace);
                            charDataNode.ComputeHashValue(_xmlHash);
                            InsertChild(parent, charDataNode);
                        }
                    }
                    break;
                }

                case XmlNodeType.XmlDeclaration:
                {
                    ++childPosition;
                    if (!_XmlDiff.IgnoreXmlDecl)
                    {
                        XmlDiffXmlDeclaration xmlDecl = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(reader.Value));
                        xmlDecl.ComputeHashValue(_xmlHash);
                        InsertChild(parent, xmlDecl);
                    }
                    break;
                }

                case XmlNodeType.EndElement:
                    goto End;

                case XmlNodeType.DocumentType:
                    childPosition++;
                    if (!_XmlDiff.IgnoreDtd)
                    {
                        XmlDiffDocumentType docType = new XmlDiffDocumentType(childPosition,
                                                                              reader.Name,
                                                                              reader.GetAttribute("PUBLIC"),
                                                                              reader.GetAttribute("SYSTEM"),
                                                                              reader.Value);
                        docType.ComputeHashValue(_xmlHash);
                        InsertChild(parent, docType);
                    }
                    break;

                default:
                    Debug.Assert(false);
                    break;
                }
            } while (reader.Read());

End:
            _curLastChild = savedLastChild;
        }
        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();
            }
        }
Exemple #39
0
 // compares the node to another one and returns the xmldiff operation for changing this node to the other one
 internal abstract XmlDiffOperation GetDiffOperation(XmlDiffNode changedNode, XmlDiff xmlDiff);
Exemple #40
0
 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));
 }
Exemple #41
0
        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!!!");
            }
        }
        internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff)
        {
            xmlWriter.WriteStartElement("xd", "change", "http://schemas.microsoft.com/xmltools/2002/xmldiff");
            xmlWriter.WriteAttributeString("match", this._sourceNode.GetRelativeAddress());
            if (this._operationID != 0UL)
            {
                xmlWriter.WriteAttributeString("opid", this._operationID.ToString());
            }
            switch (this._op)
            {
            case XmlDiffOperation.ChangeElementName:
                var sourceNode1 = (XmlDiffElement)this._sourceNode;
                var targetNode1 = (XmlDiffElement)this._targetNode;
                if (sourceNode1.LocalName != targetNode1.LocalName)
                {
                    xmlWriter.WriteAttributeString("name", targetNode1.LocalName);
                }
                if (sourceNode1.Prefix != targetNode1.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces)
                {
                    xmlWriter.WriteAttributeString("prefix", targetNode1.Prefix);
                }
                if (sourceNode1.NamespaceURI != targetNode1.NamespaceURI && !xmlDiff.IgnoreNamespaces)
                {
                    xmlWriter.WriteAttributeString("ns", targetNode1.NamespaceURI);
                }
                this.WriteChildrenTo(xmlWriter, xmlDiff);
                break;

            case XmlDiffOperation.ChangePI:
                var sourceNode2 = (XmlDiffPI)this._sourceNode;
                var targetNode2 = (XmlDiffPI)this._targetNode;
                if (sourceNode2.Value == targetNode2.Value)
                {
                    xmlWriter.WriteAttributeString("name", targetNode2.Name);
                    break;
                }
                xmlWriter.WriteProcessingInstruction(targetNode2.Name, targetNode2.Value);
                break;

            case XmlDiffOperation.ChangeER:
                xmlWriter.WriteAttributeString("name", ((XmlDiffER)this._targetNode).Name);
                break;

            case XmlDiffOperation.ChangeCharacterData:
                var targetNode3 = (XmlDiffCharData)this._targetNode;
                switch (this._targetNode.NodeType)
                {
                case XmlDiffNodeType.Text:
                case XmlDiffNodeType.SignificantWhitespace:
                    xmlWriter.WriteString(targetNode3.Value);
                    break;

                case XmlDiffNodeType.CDATA:
                    xmlWriter.WriteCData(targetNode3.Value);
                    break;

                case XmlDiffNodeType.Comment:
                    xmlWriter.WriteComment(targetNode3.Value);
                    break;
                }
                break;

            case XmlDiffOperation.ChangeXmlDeclaration:
                xmlWriter.WriteString(((XmlDiffXmlDeclaration)this._targetNode).Value);
                break;

            case XmlDiffOperation.ChangeDTD:
                var sourceNode3 = (XmlDiffDocumentType)this._sourceNode;
                var targetNode4 = (XmlDiffDocumentType)this._targetNode;
                if (sourceNode3.Name != targetNode4.Name)
                {
                    xmlWriter.WriteAttributeString("name", targetNode4.Name);
                }
                if (sourceNode3.SystemId != targetNode4.SystemId)
                {
                    xmlWriter.WriteAttributeString("systemId", targetNode4.SystemId);
                }
                if (sourceNode3.PublicId != targetNode4.PublicId)
                {
                    xmlWriter.WriteAttributeString("publicId", targetNode4.PublicId);
                }
                if (sourceNode3.Subset != targetNode4.Subset)
                {
                    xmlWriter.WriteCData(targetNode4.Subset);
                    break;
                }
                break;

            case XmlDiffOperation.ChangeAttr:
                var sourceNode4 = (XmlDiffAttribute)this._sourceNode;
                var targetNode5 = (XmlDiffAttribute)this._targetNode;
                if (sourceNode4.Prefix != targetNode5.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces)
                {
                    xmlWriter.WriteAttributeString("prefix", targetNode5.Prefix);
                }
                if (sourceNode4.NamespaceURI != targetNode5.NamespaceURI && !xmlDiff.IgnoreNamespaces)
                {
                    xmlWriter.WriteAttributeString("ns", targetNode5.NamespaceURI);
                }
                xmlWriter.WriteString(targetNode5.Value);
                break;
            }
            xmlWriter.WriteEndElement();
        }
Exemple #43
0
 internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
 {
     _xmlDiff = xmlDiff;
     WriteTo( xmlWriter );
 }
Exemple #44
0
		/// <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);
 }
Exemple #46
0
 // Constructor
 internal Diffgram( XmlDiff xmlDiff )
     : base(0)
 {
     _xmlDiff = xmlDiff;
 }
        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;
            }
        }
    // compares the node to another one and returns the xmldiff operation for changing this node to the other
	internal override XmlDiffOperation GetDiffOperation( XmlDiffNode changedNode, XmlDiff xmlDiff )
	{
        if ( changedNode.NodeType != XmlDiffNodeType.Document )
            return XmlDiffOperation.Undefined;
        else 
			return XmlDiffOperation.Match;
	}
        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);
            }
        }
        // Constructor
        internal DiffgramGenerator( XmlDiff xmlDiff )
        {
            Debug.Assert( xmlDiff != null );

            _xmlDiff = xmlDiff;
            _bChildOrderSignificant = !xmlDiff.IgnoreChildOrder;

            _lastOperationID = 0;
        }
        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));
        }