public static void DiffResultToBaseline(string output, string baseline)
        {
            string outputPath = Path.Combine(PathUtils.GetTestResultsPath(), output);
            string baselinePath = Path.Combine(PathUtils.GetBaselinesPath(), baseline);

            string baselineStr;
            StringBuilder outputStrBuilder = new StringBuilder();
            string outputStr;

            using (StreamReader baselineStream = new StreamReader(baselinePath))
            {
                using (StreamReader outputStream = new StreamReader(outputPath))
                {
                    baselineStr = baselineStream.ReadToEnd();
                    string tmpStr;
                    while ((tmpStr = outputStream.ReadLine()) != null)
                    {
                        if (!string.IsNullOrEmpty(tmpStr) &&
                            !tmpStr.StartsWith("[TestIgnore]"))
                        {
                            outputStrBuilder.Append(tmpStr);
                        }
                    }
                    outputStr = outputStrBuilder.ToString();
                }
            }

            string[] baselineDocs = SplitXmlDocuments(baselineStr);
            string[] outputDocs = SplitXmlDocuments(outputStr);

            Assert.AreEqual(baselineDocs.Length, outputDocs.Length);
            for (int docIdx = 0; docIdx < baselineDocs.Length; docIdx++)
            {

                string baselineXmlDocStr = baselineDocs[docIdx];
                string outputXmlDocStr = outputDocs[docIdx];

                XmlDocument baselineDocument = new XmlDocument();
                baselineDocument.LoadXml(baselineXmlDocStr);

                XmlDocument outputDocument = new XmlDocument();
                outputDocument.LoadXml(outputXmlDocStr);

                Assert.AreEqual(baselineDocument.ChildNodes.Count, outputDocument.ChildNodes.Count);

                for (int i = 0; i < baselineDocument.ChildNodes.Count; i++)
                {
                    XmlNode currBaselineNode = baselineDocument.ChildNodes[i];
                    XmlNode currOutputNode = outputDocument.ChildNodes[i];

                    DiffResultToBaselineNode(currBaselineNode, currOutputNode);
                }
            }
        }
Exemple #2
0
        public static void DiffResultToBaseline(string output, string baseline, bool regexCompare = false)
        {
            string outputPath   = Path.Combine(PathUtils.GetTestResultsPath(), output);
            string baselinePath = Path.Combine(PathUtils.GetBaselinesPath(), baseline);

            try
            {
                string baselineStr;
                string outputStr;

                List <string> baselineStrList = new List <string>();
                List <string> outputStrList   = new List <string>();

                using (StreamReader baselineStream = new StreamReader(baselinePath))
                    using (StreamReader outputStream = new StreamReader(outputPath))
                    {
                        string tmpStr;

                        StringBuilder strBuilder = new StringBuilder();
                        while ((tmpStr = baselineStream.ReadLine()) != null)
                        {
                            if (!string.IsNullOrEmpty(tmpStr))
                            {
                                strBuilder.Append(tmpStr);
                                baselineStrList.Add($"^{tmpStr}$");
                            }
                        }
                        baselineStr = strBuilder.ToString();

                        strBuilder = new StringBuilder();
                        while ((tmpStr = outputStream.ReadLine()) != null)
                        {
                            if (!string.IsNullOrEmpty(tmpStr) &&
                                !tmpStr.StartsWith("[TestIgnore]"))
                            {
                                strBuilder.Append(tmpStr);
                                outputStrList.Add(tmpStr);
                            }
                        }
                        outputStr = strBuilder.ToString();
                    }

                if (regexCompare)
                {
                    Assert.IsTrue(baselineStrList.Count == outputStrList.Count, "Baseline file line count does not match output file line count.");

                    for (int i = 0; i < baselineStrList.Count; i++)
                    {
                        Match match = Regex.Match(outputStrList[i], baselineStrList[i]);
                        if (!match.Success)
                        {
                            Assert.Fail("Baseline file regex failed to match output file:\n" + baselineStrList[i] + "\n" + outputStrList[i]);
                        }
                    }
                }
                else
                {
                    // Use XML comparison
                    string[] baselineDocs = SplitXmlDocuments(baselineStr);
                    string[] outputDocs   = SplitXmlDocuments(outputStr);

                    Assert.AreEqual(baselineDocs.Length, outputDocs.Length);
                    for (int docIdx = 0; docIdx < baselineDocs.Length; docIdx++)
                    {
                        string baselineXmlDocStr = baselineDocs[docIdx];
                        string outputXmlDocStr   = outputDocs[docIdx];

                        XmlDocument baselineDocument = new XmlDocument();
                        baselineDocument.LoadXml(baselineXmlDocStr);

                        XmlDocument outputDocument = new XmlDocument();
                        outputDocument.LoadXml(outputXmlDocStr);

                        Assert.AreEqual(baselineDocument.ChildNodes.Count, outputDocument.ChildNodes.Count);

                        for (int i = 0; i < baselineDocument.ChildNodes.Count; i++)
                        {
                            XmlNode currBaselineNode = baselineDocument.ChildNodes[i];
                            XmlNode currOutputNode   = outputDocument.ChildNodes[i];

                            DiffResultToBaselineNode(currBaselineNode, currOutputNode);
                        }
                    }
                }
            }
            catch (AssertFailedException)
            {
                Console.WriteLine($"Baseline FilePath: {baselinePath}");
                Console.WriteLine();
                Console.WriteLine($"Output FilePath: {outputPath}");
                throw;
            }
        }