public void XmlCompareConstrainsSimpleSimilarTest() { var expected = XmlSamples.GetContent("elements"); var actual = XmlSamples.GetContent("elements-with-different-order"); Assert.That(expected, IsXml.Similar(actual)); }
public void WriteCollectionWithDifferentItemTypeTest() { var value = GetCollection(new List <Foo> { new Foo { Id = 1, Name = "foo" }, new FooBar { Id = 2, Name = "foo-bar" } }); var actual = CreateConverter().ToXml(value.GetType(), value); var expected = string.Format( @"<xml> <foo> <id>1</id> <name>foo</name> </foo> <foo xsi:type=""{0}"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""> <id>2</id> <name>foo-bar</name> </foo> </xml>", typeof(FooBar)); Assert.That(actual, IsXml.Equals(expected).WithIgnore(XmlComparisonType.NamespacePrefix)); }
public void Serialize_IsXml_NoDefaultAndSettings() { var isXml = new IsXml(); isXml.Value = "decimal(10,2)"; var testXml = new TestXml(); testXml.Constraints.Add(isXml); var serializer = new XmlSerializer(typeof(TestXml)); var stream = new MemoryStream(); var writer = new StreamWriter(stream, Encoding.UTF8); serializer.Serialize(writer, testXml); var content = Encoding.UTF8.GetString(stream.ToArray()); writer.Close(); stream.Close(); Debug.WriteLine(content); Assert.That(content, Is.StringContaining("<is")); Assert.That(content, Is.StringContaining(">decimal(10,2)<")); Assert.That(content, Is.Not.StringContaining("efault")); Assert.That(content, Is.Not.StringContaining("eference")); }
public void IsXml_Invoke_IsXml_ReturnsTrue() { const string xmlFragment = @"<InnerError>Index #0 Message: Login failed for user 'testuser2'. LineNumber: 65536 Source: .Net SqlClient Data Provider Procedure: </InnerError><InnerError>ExecuteReader requires an open and available Connection. The connection's current state is closed. at System.Data.SqlClient.SqlCommand.ValidateCommand(String method, Boolean async) at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean asyncWrite) at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method) at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior, String method) at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior) at Dev2.Services.Sql.SqlServer.ExecuteReader[T](SqlCommand command, CommandBehavior commandBehavior, Func`2 handler) in c:\Development\Dev\Dev2.Services.Sql\SqlServer.cs:line 121 at Dev2.Services.Sql.SqlServer.FetchDataTable(SqlParameter[] parameters) in c:\Development\Dev\Dev2.Services.Sql\SqlServer.cs:line 61 at Dev2.Services.Execution.DatabaseServiceExecution.SqlExecution(ErrorResultTO errors, Object& executeService) in c:\Development\Dev\Dev2.Services.Execution\DatabaseServiceExecution.cs:line 118</InnerError>"; //------------Setup for test-------------------------- var notStartsWith = new IsXml(); var cols = new string[2]; cols[0] = xmlFragment; //------------Execute Test--------------------------- var result = notStartsWith.Invoke(cols); Assert.IsTrue(result); }
public void XmlCompareConstraintSimpleEqualsTest() { var expected = XmlSamples.GetContent("attr"); var actual = XmlSamples.GetContent("attr-with-another-order"); Assert.That(expected, IsXml.Equals(actual)); }
public void XmlCompareConstrainsXDocumentEqual() { var expected = XDocument.Parse(XmlSamples.GetContent("elements")); var actual = XDocument.Parse(XmlSamples.GetContent("elements-with-comment")); Assert.That(expected, IsXml.Equals(actual).WithIgnoreComment()); }
public void CompareNamespacesWithDifferentPrefixesIsSimilarTest() { var actual = XmlSamples.GetContent("ns"); var expected = XmlSamples.GetContent("ns-with-another-prefix"); Assert.That(expected, IsXml.Similar(actual)); }
public void WriteAttributeTest(BasicSample sample) { var expected = string.Format("<xml value=\"{0}\" />", sample.StringValue); var actual = GetConverter().ToXml(sample.Value, member: GetAttributeMember()); Assert.That(actual, IsXml.Equals(expected)); }
public void WriteElementTest(BasicSample sample) { var expected = string.Format("<xml>{0}</xml>", sample.StringValue); var actual = GetConverter().ToXml(sample.Value); Assert.That(actual, IsXml.Equals(expected)); }
public void XmlCompareConstrainUseNUnitFormatter() { var actual = XmlSamples.GetContent("elements"); var expected = XmlSamples.GetContent("elements-with-comment"); Assert.That(expected, IsXml.Different(actual).WithIgnoreComment(false)); }
public void SerializeEnumerableTest() { var value = new List <Foo> { new Foo { Id = 1 }, new Foo { Id = 2 } }; var actual = GetSerializer().ToXml <IEnumerable <Foo> >(value); var expected = string.Format(@" <ienumerable xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xsi:type=""{0}""> <foo> <id>1</id> </foo> <foo> <id>2</id> </foo> </ienumerable>", value.GetType().FullName); Assert.That(actual, IsXml.Equals(expected).WithIgnoreDeclaration()); }
public void WriteNullableTest() { var converter = new XmlNullableConverter(); var actual = converter.ToXml <int?>(1); var expected = "<xml>1</xml>"; Assert.That(actual, IsXml.Equals(expected)); }
public void WriteNullableAttributeTest() { var converter = new XmlOptionalConverter(); var actual = converter.ToXml <Optional <int?> >(1, member: GetAttributeMember <int?>()); var expected = "<xml value=\"1\" />"; Assert.That(actual, IsXml.Equals(expected)); }
public void WriteNullAttributeTest() { var serializer = new XmlSerializer(); var actual = serializer.ToXml(new TestClass2()); var expected = "<TestClass2 />"; Assert.That(actual, IsXml.Equals(expected).WithIgnoreDeclaration()); }
public void WriteNullTest() { var converter = new XmlOptionalConverter(); var actual = converter.ToXml <Optional <int?> >(null); var expected = "<xml />"; Assert.That(actual, IsXml.Equals(expected)); }
protected NBiConstraint InstantiateConstraint(IsXml ctrXml, DataTypeXml sutXml) { var expected = ctrXml.Value; var ctr = new IsConstraint(expected); return(ctr); }
public void XmlCompareConstrainsEqualsWithDifferentOrder() { var expected = XmlSamples.GetContent("elements"); var actual = XmlSamples.GetContent("elements-with-different-order"); Assert.That( expected, IsXml.Equals(actual).UseAnalizer(XmlAnalyzer.Custom().SetEqual(XmlComparisonType.NodeListSequence))); }
public void XmlValidationConstraintSchemaWithNamespaceTest() { var document = XmlSamples.GetContent("ns"); var emptyNamespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns.xsd"); var namespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns_app1.xsd"); string nameSpace = @"http://example.org"; Assert.That(document, IsXml.Valid().WithSchema(emptyNamespaceSchemaPath).WithSchema(nameSpace, namespaceSchemaPath)); }
public void XmlValidationConstraintTextReaderSchema() { var document = XmlSamples.GetContent("ns-without-namespace"); var namespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns-without-namespace.xsd"); Assert.That( document, IsXml.Valid().WithSchema(namespaceSchemaPath)); }
public void WriteInt32CollectionTest() { var value = GetCollection(new List <int> { 1, 2, 3 }); var actual = CreateConverter().ToXml(value.GetType(), value); var expected = "<xml><int>1</int><int>2</int><int>3</int></xml>"; Assert.That(actual, IsXml.Equals(expected)); }
public void XmlCompareConstrainWithXsdReference() { var actual = XmlSamples.GetContent("with-xsd-reference"); var expected = XmlSamples.GetContent("with-xsd-another-reference"); Assert.That( expected, IsXml.Equals(actual) .UseAnalizer(XmlAnalyzer.Custom().SetEqual(XmlComparisonType.SchemaLocation))); }
public void IsHandling_DataTypeIs_True() { var sutXml = new DataTypeXml(); var ctrXml = new IsXml(); var testCaseFactory = new TestCaseFactory(); var actual = testCaseFactory.IsHandling(sutXml.GetType(), ctrXml.GetType()); Assert.That(actual, Is.True); }
public void IsXml_HandlesType_ReturnsIsXmlType() { var decisionType = enDecisionType.IsXML; //------------Setup for test-------------------------- var isXml = new IsXml(); //------------Execute Test--------------------------- //------------Assert Results------------------------- Assert.AreEqual(decisionType, isXml.HandlesType()); }
public void WriteNullWithNullIncludeHandlingTest() { var serializer = new XmlSerializer(); serializer.Settings.OmitXmlDeclaration = true; serializer.Settings.NullValueHandling = XmlNullValueHandling.Include; var actual = serializer.ToXml(new TestClass()); var expected = @"<TestClass xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""><Value xsi:nil=""true"" /></TestClass>"; Assert.That(actual, IsXml.Equals(expected)); }
public void SerializeNullTest() { var serializer = GetSerializer(); serializer.Settings.NullValueHandling = XmlNullValueHandling.Include; var actual = serializer.ToXml <Foo>(null); var expected = @"<?xml version=""1.0"" encoding=""utf-16""?> <foo xsi:nil=""true"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" />"; Assert.That(actual, IsXml.Equals(expected)); }
public void XmlCompareConstrainCustomAnalyzerIgnoreNodeMissing() { var expected = XmlSamples.GetContent("elements"); var actual = XmlSamples.GetContent("elements-with-comment"); Assert.That( expected, IsXml.Equals(actual) .WithIgnoreComment(false) .UseAnalizer(XmlAnalyzer.Custom() .SetEqual(XmlComparisonType.NodeList) .SetEqual(XmlComparisonType.NodeListLookup))); }
public void WriteFooTest() { var value = new Foo { Id = 1, Name = "test" }; var actual = GetConverter().ToXml(value); var expected = "<xml><id>1</id><name>test</name></xml>"; Assert.That(actual, IsXml.Equals(expected)); }
public void GivenSomeString_IsXml_Invoke_ReturnsFalse() { //------------Setup for test-------------------------- var isXml = new IsXml(); var cols = new string[2]; cols[0] = "Eight"; //------------Execute Test--------------------------- var result = isXml.Invoke(cols); //------------Assert Results------------------------- Assert.IsFalse(result); }
public void WriteFooWithIgnoreNullHandlingTest() { var value = new Foo { Id = 1, Name = null }; var contract = GetContractWithIgnoreNull(); var actual = GetConverter().ToXml(value, contract: contract); var expected = "<xml><id>1</id></xml>"; Assert.That(actual, IsXml.Equals(expected)); }
public void WriteFooWithIncludeNullHandlingTest() { var value = new Foo { Id = 1, Name = null }; var contract = GetContractWithIncludeNull(); var actual = GetConverter().ToXml(value, contract: contract); var expected = @"<xml><id>1</id><name xsi:nil=""true"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" /></xml>"; Assert.That(actual, IsXml.Equals(expected).WithIgnore(XmlComparisonType.NamespacePrefix)); }