/// <summary>
/// Calls:
/// - BinaryFormatterAssert.Roundtrip(item)
/// - XmlSerializerAssert.Roundtrip(item)
/// - DataContractSerializerAssert.Roundtrip(item)
/// </summary>
/// <returns>The roundtripped results.</returns>
public static RoundtripResults <T> RoundtripAll <T>(T item)
{
var binary = BinaryFormatterAssert.Roundtrip(item);
var xmlSerializer = XmlSerializerAssert.Roundtrip(item);
var dataContract = DataContractSerializerAssert.Roundtrip(item);
return(new RoundtripResults <T>(binary, xmlSerializer, dataContract));
}
public void FromXml()
{
var xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n" +
"<DataContractDummy xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/Gu.SerializationAsserts.Tests.Dtos\">\r\n" +
" <Value>2</Value>\r\n" +
"</DataContractDummy>";
var dummy = DataContractSerializerAssert.FromXml <DataContractDummy>(xml);
Assert.AreEqual(2, dummy.Value);
}
public void HappyPath()
{
var actual = new Dummy {
Value = 2
};
var roundtrip = DataContractSerializerAssert.Roundtrip(actual);
Assert.AreEqual(roundtrip.Value, actual.Value);
FieldAssert.Equal(actual, roundtrip);
}
public void EqualItems()
{
var expected = new DataContractDummy {
Value = 2
};
var actual = new DataContractDummy {
Value = 2
};
DataContractSerializerAssert.Equal(expected, actual);
}
public void EqualXmlAttributeClass()
{
var actual = new XmlAttributeClass {
Value = 2
};
var expectedXml = "<XmlAttributeClass Value=\"2\" />";
var roundtrip = DataContractSerializerAssert.Equal(expectedXml, actual, XmlAssertOptions.IgnoreNamespaces | XmlAssertOptions.IgnoreDeclaration);
Assert.AreEqual(roundtrip.Value, actual.Value);
FieldAssert.Equal(actual, roundtrip);
}
public void HasDataContractAttributeThrowsIfMissing()
{
var expected = " Expected type Gu.SerializationAsserts.Tests.Dtos.MissingAttributes to have [DataContractAttribute]";
var ex1 = Assert.Throws <AssertException>(() => DataContractSerializerAssert.HasDataContractAttribute <MissingAttributes>());
Assert.AreEqual(expected, ex1.Message);
var ex2 = Assert.Throws <AssertException>(() => DataContractSerializerAssert.HasDataContractAttribute(typeof(MissingAttributes)));
Assert.AreEqual(expected, ex2.Message);
}
public void ReadingOutsideEndElementThrows()
{
var actual = new ReadingOutsideEndElement {
Value = 2
};
Assert.Throws <AssertException>(() => DataContractSerializerAssert.Roundtrip(actual));
//var ex = Assert.Throws<AssertException>(() => DataContractSerializerAssert.Roundtrip(actual));
//var expectedMessage = " Roundtrip of item in ContainerClass Failed.\r\n" +
// " This means there is an error in serialization.\r\n" +
// " If you are implementing IXmlSerializable check that you handle ReadEndElement properly as it is a common source of bugs.";
//Assert.AreEqual(expectedMessage, ex.Message);
}
public void EqualNoDeclarationOrNamespaces()
{
var actual = new DataContractDummy {
Value = 2
};
var expectedXml = "<DataContractDummy>\r\n" +
" <Value>2</Value>\r\n" +
"</DataContractDummy>";
var roundtrip = DataContractSerializerAssert.Equal(expectedXml, actual, XmlAssertOptions.IgnoreDeclaration | XmlAssertOptions.IgnoreNamespaces);
Assert.AreEqual(roundtrip.Value, actual.Value);
FieldAssert.Equal(actual, roundtrip);
}
public void ToXml()
{
var dummy = new DataContractDummy {
Value = 2
};
var xml = DataContractSerializerAssert.ToXml(dummy);
var expected = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n" +
"<DataContractDummy xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/Gu.SerializationAsserts.Tests.Dtos\">\r\n" +
" <Value>2</Value>\r\n" +
"</DataContractDummy>";
Assert.AreEqual(expected, xml);
}
public void RoundtripForgotReadElementThrows()
{
var actual = new ForgotReadElement {
Value = 2
};
var ex = Assert.Throws <AssertException>(() => DataContractSerializerAssert.Roundtrip(actual));
var expectedMessage = " Simple roundtrip failed. Source is not equal to roundtripped.\r\n" +
" AssertException: Found this difference between expected and actual:\r\n" +
" expected.value: 2\r\n" +
" actual.value: 0";
Assert.AreEqual(expectedMessage, ex.Message);
}
public void Equal()
{
var actual = new DataContractDummy {
Value = 2
};
var expectedXml = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n" +
"<DataContractDummy xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/Gu.SerializationAsserts.Tests.Dtos\">\r\n" +
" <Value>2</Value>\r\n" +
"</DataContractDummy>";
var roundtrip = DataContractSerializerAssert.Equal(expectedXml, actual);
Assert.AreEqual(roundtrip.Value, actual.Value);
FieldAssert.Equal(actual, roundtrip);
}
public void AllPropertiesHasDataMemberAttributesThrowsIfMissing()
{
var expected = " Expected all properties for type Gu.SerializationAsserts.Tests.Dtos.MissingAttributes to have [DataMemberAttribute]\r\n" +
" The following properties does not:\r\n" +
" Value";
var ex1 = Assert.Throws <AssertException>(() => DataContractSerializerAssert.AllPropertiesHasDataMemberAttributes <MissingAttributes>());
Assert.AreEqual(expected, ex1.Message);
var ex2 = Assert.Throws <AssertException>(() => DataContractSerializerAssert.AllPropertiesHasDataMemberAttributes(typeof(MissingAttributes)));
Assert.AreEqual(expected, ex2.Message);
}
public void ReadingOutsideEndElementEqual()
{
var actual = new ReadingOutsideEndElement {
Value = 2
};
var expectedXml = "<ReadingOutsideEndElement><Value>2</Value></ReadingOutsideEndElement>";
Assert.Throws <AssertException>(() => DataContractSerializerAssert.Equal(expectedXml, actual, XmlAssertOptions.IgnoreNamespaces | XmlAssertOptions.IgnoreDeclaration));
//var ex = Assert.Throws<AssertException>(() => DataContractSerializerAssert.Equal(expectedXml, actual, XmlAssertOptions.IgnoreNamespaces | XmlAssertOptions.IgnoreDeclaration));
//var expectedMessage = " Roundtrip of actual in ContainerClass Failed.\r\n" +
// " This means there is an error in serialization.\r\n" +
// " If you are implementing IXmlSerializable check that you handle ReadEndElement properly as it is a common source of bugs.";
//Assert.AreEqual(expectedMessage, ex.Message);
}
public void ToEscapedXml()
{
var dummy = new Dummy {
Value = 2
};
var xml = DataContractSerializerAssert.ToEscapedXml(dummy);
Console.Write(xml);
var expected = "\"<?xml version=\\\"1.0\\\" encoding=\\\"utf-16\\\"?>\\r\\n\" +\r\n" +
"\"<Dummy xmlns:i=\\\"http://www.w3.org/2001/XMLSchema-instance\\\" xmlns=\\\"http://schemas.datacontract.org/2004/07/Gu.SerializationAsserts.Tests.Dtos\\\">\\r\\n\" +\r\n" +
"\" <Value>2</Value>\\r\\n\" +\r\n" +
"\"</Dummy>\"";
Assert.AreEqual(expected, xml);
}
public void NotEqualItems()
{
var expected = new DataContractDummy {
Value = 1
};
var actual = new DataContractDummy {
Value = 2
};
var ex = Assert.Throws <AssertException>(() => DataContractSerializerAssert.Equal(expected, actual));
var expectedMessage = " Xml differ at line 3 index 7.\r\n" +
" Expected: 3| <Value>1</Value>\r\n" +
" But was: 3| <Value>2</Value>\r\n" +
" --------------------^";
Assert.AreEqual(expectedMessage, ex.Message);
}
public void HasDataContractAttributeHappyPath()
{
DataContractSerializerAssert.HasDataContractAttribute <DataContractDummy>();
DataContractSerializerAssert.HasDataContractAttribute(typeof(DataContractDummy));
}
public void AllPropertiesHasDataMemberAttributesHappyPath()
{
DataContractSerializerAssert.AllPropertiesHasDataMemberAttributes <DataContractDummy>();
DataContractSerializerAssert.AllPropertiesHasDataMemberAttributes(typeof(DataContractDummy));
}
