예제 #1
0
        public void ExtractItems()
        {
            var outputDir = Path.Combine(GetTestProjectDir("ConsoleApp"), NativeExeOutputDirectory);
            var exe       = Path.Combine(outputDir, "ConsoleApp.exe");

            var fileName = Path.GetTempFileName();

            Console.WriteLine("Using temp file: " + fileName);

            var result = BuildProject("ConsoleApp", targets: "ExtractItemsTest", properties: new { ExtractItemsOutputFile = fileName });

            var expected1 = Resources.ExtractItemsTestExpected1.Replace("$(TestProjects)", TestProjectsRoot);

            Diff diff = DiffBuilder.Compare(Input.FromFile(fileName))
                        .WithDifferenceEvaluator(DifferenceEvaluators.IgnorePrologDifferences())
                        .WithTest(Input.FromString(expected1))
                        .Build();

            Assert.IsFalse(diff.HasDifferences(), diff.ToString());

            fileName = Path.GetTempFileName();
            Console.WriteLine("Using temp file: " + fileName);
            var expected2 = Resources.ExtractItemsTestExpected2.Replace("$(TestProjects)", TestProjectsRoot);

            result = BuildProject("ConsoleApp", targets: "ExtractItemsTest", properties: new { ExtractItemsOutputFile = fileName, TestVariable = "Something" });
            diff   = DiffBuilder.Compare(Input.FromFile(fileName))
                     .WithDifferenceEvaluator(DifferenceEvaluators.IgnorePrologDifferences())
                     .WithTest(Input.FromString(expected2))
                     .Build();

            Assert.IsFalse(diff.HasDifferences(), diff.ToString());
        }
예제 #2
0
 /// <summary>
 /// Adds placeholder support to an IDifferenceEngineConfigurer
 /// considering an additional DifferenceEvaluator.
 /// </summary>
 /// <param name="configurer">configurer the configurer to add support to</param>
 /// <param name="placeholderOpeningDelimiterRegex">regular
 /// expression for the opening delimiter of placeholder,
 /// defaults to
 /// PlaceholderDifferenceEvaluator#PLACEHOLDER_DEFAULT_OPENING_DELIMITER_REGEX
 /// if the parameter is null or blank</param>
 /// <param name="placeholderClosingDelimiterRegex">regular
 /// expression for the closing delimiter of placeholder,
 /// defaults to
 /// PlaceholderDifferenceEvaluator#PLACEHOLDER_DEFAULT_CLOSING_DELIMITER_REGEX
 /// if the parameter is null or blank</param>
 /// <param name="evaluator">the additional evaluator -
 /// placeholder support is chained after the given
 /// evaluator.</param>
 /// <return>the configurer with placeholder support added in.</return>
 public static D WithPlaceholderSupportUsingDelimitersChainedAfter <D>(this D configurer,
                                                                       string placeholderOpeningDelimiterRegex, string placeholderClosingDelimiterRegex,
                                                                       DifferenceEvaluator evaluator)
     where D : IDifferenceEngineConfigurer <D>
 {
     return(configurer.WithDifferenceEvaluator(DifferenceEvaluators.Chain(
                                                   evaluator, new PlaceholderDifferenceEvaluator(placeholderOpeningDelimiterRegex,
                                                                                                 placeholderClosingDelimiterRegex).Evaluate)));
 }
예제 #3
0
        public void HasIgnorePlaceholder_Equal_NoWhitespaceInPlaceholder_CDATA_TEST()
        {
            string control = "<elem1><elem11>${xmlunit.ignore}</elem11></elem1>";
            string test    = "<elem1><elem11><![CDATA[abc]]></elem11></elem1>";
            var    diff    = DiffBuilder.Compare(control).WithTest(test)
                             .WithDifferenceEvaluator(DifferenceEvaluators.Chain(
                                                          DifferenceEvaluators.Default, new PlaceholderDifferenceEvaluator().Evaluate))
                             .Build();

            Assert.IsFalse(diff.HasDifferences());
        }
        public virtual bool IsEqual(XmlNode expected, XmlNode actual)
        {
            // XMLUnit's DiffBuilder - https://github.com/xmlunit/user-guide/wiki/DiffBuilder
            // Do NOT ignore whitespace because that trims text node values which is destructive and not equivalent in enterprise systems.
            this.differences = DiffBuilder.Compare(Input.FromNode(expected))
                               .WithTest(Input.FromNode(actual))
                               .IgnoreComments()
                               .CheckForSimilar()                                                // ignore child order, namespace prefixes etc - https://github.com/xmlunit/user-guide/wiki/DifferenceEvaluator#default-differenceevaluator
                               .WithNodeMatcher(new DefaultNodeMatcher(ElementSelectors.ByName)) // allows for comparisons of nodes in different order
                               .WithDifferenceEvaluator(DifferenceEvaluators.Chain(DifferenceEvaluators.Default, IgnoreElementTagNameDifferenceEvaluator.Evaluate))
                               .WithComparisonFormatter(this.comparisonFormatter)
                               .Build();

            return(!this.differences.HasDifferences());
        }
예제 #5
0
        private ComparisonResult IgnoreCaseDifferenceEvaluator(Org.XmlUnit.Diff.Comparison comparison, ComparisonResult outcome)
        {
            if (outcome == ComparisonResult.EQUAL)
            {
                return(outcome);
            }
            var controlNode = comparison.ControlDetails.Target?.OuterXml;
            var targetNode  = comparison.TestDetails.Target?.OuterXml;

            if (string.Equals(controlNode, targetNode, StringComparison.InvariantCultureIgnoreCase))
            {
                return(ComparisonResult.EQUAL);
            }

            return(DifferenceEvaluators.Default(comparison, outcome));
        }
예제 #6
0
        public void TestDiff_withDifferenceEvaluator_shouldNotInterfereWithSimilar()
        {
            // prepare testData
            string control = "<a><b><![CDATA[abc]]></b></a>";
            string test    = "<a><b>abc</b></a>";

            // run test
            var myDiff = DiffBuilder.Compare(control).WithTest(test)
                         .WithDifferenceEvaluator(
                DifferenceEvaluators.Chain(DifferenceEvaluators.Default,
                                           IgnoreAttributeDifferenceEvaluator("attr")))
                         .CheckForSimilar()
                         .Build();

            // validate result
            Assert.IsFalse(myDiff.HasDifferences(), myDiff.ToString());
        }
예제 #7
0
        private static Diff CreateDiff(string expectedHtml, string testHtml)
        {
            Diff?diffResult = null;

            Should.NotThrow(() =>
            {
                var test    = Input.FromString(WrapInTestRoot(testHtml)).Build();
                var control = Input.FromString(WrapInTestRoot(expectedHtml)).Build();
                diffResult  = DiffBuilder.Compare(control)
                              .IgnoreWhitespace()
                              .WithTest(test)
                              .WithDifferenceEvaluator(DifferenceEvaluators.Chain(
                                                           DifferenceEvaluators.Default,
                                                           RegexAttributeDifferenceEvaluator.Default,
                                                           CssClassAttributeDifferenceEvaluator.Default)
                                                       )
                              .Build();
            }, CreateParseErrorText(expectedHtml, testHtml));

            return(diffResult !);
        }