How to unit test if my object is really serializable?

Question

I am using C # 2.0 with Nunit Test. I have some object that needs to be serialized. These objects are quite complex (inheritance at different levels and contains many objects, events and delegates).

How can I create a Unit Test to make sure my object is safe to serializable?

Answer 1

I have this in some unit test here on the assignment:

MyComplexObject dto = new MyComplexObject(); MemoryStream mem = new MemoryStream(); BinaryFormatter b = new BinaryFormatter(); try { b.Serialize(mem, dto); } catch (Exception ex) { Assert.Fail(ex.Message); } 

It may help ... maybe another method might be better, but this one works well.

Answer 2

Here is a general way:

 public static Stream Serialize(object source) { IFormatter formatter = new BinaryFormatter(); Stream stream = new MemoryStream(); formatter.Serialize(stream, source); return stream; } public static T Deserialize<T>(Stream stream) { IFormatter formatter = new BinaryFormatter(); stream.Position = 0; return (T)formatter.Deserialize(stream); } public static T Clone<T>(object source) { return Deserialize<T>(Serialize(source)); } 

Answer 3

In addition to the above test, which ensures that the serializer accepts your object, you need to run a round-trip test. Detach the results to a new object and make sure that both instances are equivalent.

Answer 4

serialize the object (to memory or disk), deserialize it, use reflection to compare the two, then run all the unit tests for this object again (except for serialization)

this suggests that your unit tests may take an object as a target instead of creating your own

Answer 5

Here is a solution that recursively uses IsSerializable to verify that the object and all its properties are Serializable.

  private static void AssertThatTypeAndPropertiesAreSerializable(Type type) { // base case if (type.IsValueType || type == typeof(string)) return; Assert.IsTrue(type.IsSerializable, type + " must be marked [Serializable]"); foreach (var propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { if (propertyInfo.PropertyType.IsGenericType) { foreach (var genericArgument in propertyInfo.PropertyType.GetGenericArguments()) { if (genericArgument == type) continue; // base case for circularly referenced properties AssertThatTypeAndPropertiesAreSerializable(genericArgument); } } else if (propertyInfo.GetType() != type) // base case for circularly referenced properties AssertThatTypeAndPropertiesAreSerializable(propertyInfo.PropertyType); } } 

Answer 6

Unfortunately, you cannot verify this. Imagine this case:

 [Serializable] class Foo { public Bar MyBar { get; set; } } [Serializable] class Bar { int x; } class DerivedBar : Bar { } public void TestSerializeFoo() { Serialize(new Foo()); // OK Serialize(new Foo() { MyBar = new Bar() }; // OK Serialize(new Foo() { MyBar = new DerivedBar() }; // Boom } 

Answer 7

Maybe a little late, but if you use the FluentAssertions library, then it has custom assertions for XML serialization, binary serialization, and serialization of data contracts.

 theObject.Should().BeXmlSerializable(); theObject.Should().BeBinarySerializable(); theObject.Should().BeDataContractSerializable(); theObject.Should().BeBinarySerializable<MyClass>( options => options.Excluding(s => s.SomeNonSerializableProperty));