コード例 #1
0
        public void DefaultConfiguredToUseValidatingParser()
        {
            var diffConfiguration = new DiffConfiguration();
            Assert.Equal(DiffConfiguration.DEFAULT_USE_VALIDATING_PARSER,
                         diffConfiguration.UseValidatingParser);

            bool exception = false;
            using (FileStream controlFileStream = File.Open(ValidatorTests.VALID_FILE,
                                                            FileMode.Open,
                                                            FileAccess.Read))
            using (FileStream testFileStream = File.Open(ValidatorTests.INVALID_FILE,
                                                         FileMode.Open,
                                                         FileAccess.Read))
            {
                try
                {
                    var diff = new XmlDiff(new StreamReader(controlFileStream),
                                           new StreamReader(testFileStream));
                    diff.Compare();
                }
                catch (Exception)
                {
                    // should be an XmlSchemaValidationException in .NET 2.0
                    // and later
                    exception = true;
                }
            }
            Assert.True(exception, "expected validation to fail");
        }
コード例 #2
0
ファイル: XmlDiff.cs プロジェクト: horsdal/XmlUnit.Xunit
 public XmlDiff(XmlInput control, XmlInput test,
                DiffConfiguration diffConfiguration)
 {
     _diffConfiguration = diffConfiguration;
     controlInput = control;
     testInput = test;
 }
コード例 #3
0
        public void DefaultConfiguredWithGenericDescription()
        {
            var diffConfiguration = new DiffConfiguration();
            Assert.Equal(DiffConfiguration.DEFAULT_DESCRIPTION,
                         diffConfiguration.Description);

            Assert.Equal(DiffConfiguration.DEFAULT_DESCRIPTION,
                         new XmlDiff("", "").OptionalDescription);
        }
コード例 #4
0
        public void CompareExpectedXMLs()
        {
            Dictionary<string, string> expected = new Dictionary<string, string>();
            Dictionary<string, string> actual = new Dictionary<string, string>();

            RunReport(mValidTrxFile);
            
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
            xmlNamespaceManager.AddNamespace("prefix", "urn:model.allure.qatools.yandex.ru");

            DiffConfiguration diffConfiguration = new DiffConfiguration(String.Empty, false, WhitespaceHandling.None, true);
            
            FillCategoryToXmlMap("sample-output", expected);
            FillCategoryToXmlMap(mTargetDir, actual);

            if (expected.Keys.Count != actual.Keys.Count)
            {
                Assert.Fail("Expected {0} categories but found {1}.", expected.Keys.Count, actual.Keys.Count);
            }

            foreach (string category in actual.Keys)
            {
                if (!expected.ContainsKey(category))
                {
                    Assert.Fail("The category " + category + " was not expected.");
                }

                string expectedFile = expected[category];
                string actualFile = actual[category];

                string expectedFileText = File.ReadAllText(expectedFile);
                string actualFileText = File.ReadAllText(actualFile);

                XmlInput control = new XmlInput(expectedFileText);
                XmlInput test = new XmlInput(actualFileText);
                
                XmlDiff xmlDiff = new XmlDiff(control, test, diffConfiguration);
                    
                DiffResult diffResult = xmlDiff.Compare();
                if (!diffResult.Identical)
                {
                    string failureMessage = String.Format("The expected file {0} was different from the actual file {1}", expectedFile, actualFile);
                    failureMessage += Environment.NewLine;
                    failureMessage += "Expected XML: ";
                    failureMessage += expectedFileText;
                    failureMessage += Environment.NewLine;
                    failureMessage += "Actual XML: ";
                    failureMessage += actualFileText;
                    failureMessage += Environment.NewLine;
                    failureMessage += "Difference: ";
                    failureMessage += diffResult.Difference;

                    Assert.Fail(failureMessage);
                }
            }
        }
コード例 #5
0
        public void CanConfigureNotToUseValidatingParser()
        {
            var diffConfiguration = new DiffConfiguration(false);
            Assert.Equal(false, diffConfiguration.UseValidatingParser);

            FileStream controlFileStream = File.Open(ValidatorTests.VALID_FILE,
                                                     FileMode.Open, FileAccess.Read);
            FileStream testFileStream = File.Open(ValidatorTests.INVALID_FILE,
                                                  FileMode.Open, FileAccess.Read);
            try
            {
                var diff = new XmlDiff(new XmlInput(controlFileStream),
                                       new XmlInput(testFileStream),
                                       diffConfiguration);
                diff.Compare();
            }
            finally
            {
                controlFileStream.Close();
                testFileStream.Close();
            }
        }
コード例 #6
0
        public void DefaultConfiguredWithWhitespaceHandlingAll()
        {
            var diffConfiguration = new DiffConfiguration();
            Assert.Equal(WhitespaceHandling.All, diffConfiguration.WhitespaceHandling);

            PerformAssertion(xmlWithoutWhitespace, xmlWithWhitespaceElement, false);
            PerformAssertion(xmlWithoutWhitespace, xmlWithoutWhitespaceElement, false);
            PerformAssertion(xmlWithoutWhitespace, xmlWithWhitespace, false);
            PerformAssertion(xmlWithoutWhitespaceElement, xmlWithWhitespaceElement, false);
        }
コード例 #7
0
 public void DiffWithIgnoringAttrbituesRetursEqualsIfHasSameNodesAndDifferentValues()
 {
     var xmlUnitConfiguration = new DiffConfiguration {IgnoreAttribute = true};
     PerformAssertion(xmlIgnoringAttrbutesA, xmlIgnoringAttrbutesB,
                     true, xmlUnitConfiguration);
 }
コード例 #8
0
 public void IgnoreAttributeIsFalseByDefault()
 {
     var xmlUnitConfiguration = new DiffConfiguration();
     Assert.False(xmlUnitConfiguration.IgnoreAttribute);
     
 }
コード例 #9
0
 public void CanConfigureWhitespaceHandlingNone()
 {
     var xmlUnitConfiguration =
         new DiffConfiguration(WhitespaceHandling.None);
     PerformAssertion(xmlWithoutWhitespace, xmlWithWhitespaceElement,
                      true, xmlUnitConfiguration);
     PerformAssertion(xmlWithoutWhitespace, xmlWithoutWhitespaceElement,
                      true, xmlUnitConfiguration);
     PerformAssertion(xmlWithoutWhitespace, xmlWithWhitespace,
                      true, xmlUnitConfiguration);
     PerformAssertion(xmlWithoutWhitespaceElement, xmlWithWhitespaceElement,
                      true, xmlUnitConfiguration);
 }
コード例 #10
0
 private void PerformAssertion(string control, string test, bool assertion,
                               DiffConfiguration xmlUnitConfiguration)
 {
     var diff = new XmlDiff(new XmlInput(control), new XmlInput(test),
                            xmlUnitConfiguration);
     PerformAssertion(diff, assertion);
 }