Esempio n. 1
0
        public void ShouldSucceedForEqualXmlsComplex()
        {
            const string xmlA = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <a:root xmlns:a=""http://test.com/testing"">
                  <a:elem1 attr1=""attr1"" attr2=""attr2"">
                    value
                  </a:elem1>
                  <a:elem1 attr1=""attr1"" attr2=""attr2"">
                      <c:elem2 xmlns:c=""http://test.com/testing1"">
                      </c:elem2>
                      <d:elem2 xmlns:d=""http://test.com/testing1"">
                      <![CDATA[Text]]>
                      </d:elem2>
                  </a:elem1>
              </a:root>";

            const string xmlB = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root xmlns=""http://test.com/testing"">
                  <elem1 attr1=""attr1"" attr2=""attr2"" xmlns:b=""http://test.com/testing1"">
                      <b:elem2 xmlns:c=""http://test.com/testing1"">Text</b:elem2>
                      <b:elem2 />
                  </elem1>
                  <elem1 attr1=""attr1"" attr2=""attr2"">value</elem1>
              </root>";

            var result = XmlSpecificationEquality.AreEqual(xmlA, xmlB);

            Assert.That(result.Success, Is.True);
            Assert.That(result.FailObject, Is.Null);
        }
Esempio n. 2
0
        public void ShouldFailForCDataMismatch()
        {
            const string xmlA = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <a:root xmlns:a=""http://test.com/testing"">
                  <a:elem1 attr1=""attr1"" attr2=""attr2"">
                    value
                  </a:elem1>
                  <a:elem1 attr1=""attr1"" attr2=""attr2"">
                      <c:elem2 xmlns:c=""http://test.com/testing1"">
                      </c:elem2>
                      <d:elem2 xmlns:d=""http://test.com/testing1"">
                      <![CDATA[
                        Text]]>
                      </d:elem2>
                  </a:elem1>
              </a:root>";

            const string xmlB = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root xmlns=""http://test.com/testing"">
                  <elem1 attr1=""attr1"" attr2=""attr2"" xmlns:b=""http://test.com/testing1"">
                      <b:elem2 xmlns:c=""http://test.com/testing1"">
                        <![CDATA[Text]]>
                      </b:elem2>
                      <b:elem2 />
                  </elem1>
                  <elem1 attr1=""attr1"" attr2=""attr2"">value</elem1>
              </root>";

            var result = XmlSpecificationEquality.AreEqual(xmlA, xmlB);


            Assert.That(result.Success, Is.False);
            Assert.That(result.FailObject, Is.TypeOf <XCData>());
            Assert.That(result.FailObject.GetXPath(), Is.EqualTo("/a:root[1]/a:elem1[2]/d:elem2[2]/text()"));
        }
Esempio n. 3
0
        public void ShouldSucceedForEqualRoot()
        {
            const string xmlA = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <a:root xmlns:a=""http://test.com/testing""/>";

            const string xmlB = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root xmlns=""http://test.com/testing"">
              </root>";

            var result = XmlSpecificationEquality.AreEqual(xmlA, xmlB);

            Assert.That(result.Success, Is.True);
            Assert.That(result.FailObject, Is.Null);
        }
Esempio n. 4
0
        public void ShouldFailForRootWithDifferentNamespace()
        {
            const string xmlA = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <a:root xmlns:a=""http://test.com/testing"">
              </a:root>";

            const string xmlB = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root>
              </root>";

            var result = XmlSpecificationEquality.AreEqual(xmlA, xmlB);

            Assert.That(result.Success, Is.False);
            Assert.That(result.FailObject, Is.TypeOf <XElement>());
            Assert.That(result.FailObject.GetXPath(), Is.EqualTo("/a:root[1]"));
        }
        public override ConstraintResult ApplyTo <TActual>(TActual actual)
        {
            XmlEqualityResult result;

            try
            {
                result = XmlSpecificationEquality.AreEqual(GetXElement(actual), _expected);
            }
            catch (Exception e)
            {
                result = new XmlEqualityResult {
                    ErrorMessage = e.Message, FailObject = _expected
                };
            }

            return(new XmlSpecificationEqualityConstraintResult(this, actual, result));
        }
        private static XElement GetXElement(object element)
        {
            var xelement = element as XElement;

            if (xelement != null)
            {
                return(xelement);
            }

            var s = element as string;

            if (s != null)
            {
                return(XmlSpecificationEquality.ParseXml(s).Root);
            }

            throw new ArgumentException("Cannot test this type of object.");
        }
Esempio n. 7
0
        public void ShouldfailForXmlsDifferingInElement()
        {
            const string xmlA = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root xmlns=""http://test.com/testing"">
                  <elem1 attr1=""attr1"" attr2=""attr2"">
                    value
                  </elem1>
                  <elem3>
                  </elem3>
              </root>";

            const string xmlB = @"<?xml version=""1.0"" encoding=""UTF-8""?>
              <root xmlns=""http://test.com/testing"">
                  <elem2/>
                  <elem1 attr2=""attr2"" attr1=""attr1"">value</elem1>
              </root>";

            var result = XmlSpecificationEquality.AreEqual(xmlA, xmlB);

            Assert.That(result.Success, Is.False);
            Assert.That(result.FailObject, Is.TypeOf <XElement>());
            Assert.That(result.FailObject.GetXPath(), Is.EqualTo("/root[1]/elem3[1]"));
        }