Unit Testing [Serializable]

A common struggle with unit testing is
figuring when to just assume somebody else’s code works. One such example
is serializability: for simple classes, it should “just work” so we
shouldn’t need to write a unit test for each of them. However, I still
wanted to be able to verify that all classes in certain namespaces were
marked as [Serializable], so I wrote the following test:

[TestCase(typeof(Money), "Solutionizing.Domain")]
[TestCase(typeof(App), "Solutionizing.Web.Models")]
public void Types_should_be_Serializable(Type sampleType, string @namespace)
var assembly = sampleType.Assembly;

var unserializableTypes = (
from t in assembly.GetTypes()
where t.Namespace != null && t.Namespace.StartsWith(@namespace, StringComparison.Ordinal)
where !t.IsSerializable && ShouldBeSerializable(t)
select t


After we have a reference to the Assembly under test, we
use a LINQ to Objects query against its types. If a type matches our
namespace filter, we make sure it’s serializable if it should be.
Finally, by using ToArray() and ShouldBeEmpty()
we’re given a nice error message if the test fails:

TestCase 'Solutionizing.Tests.SerializabilityTests.Types_should_be_Serializable(Solutionizing.Domain.Money, Solutionizing.Domain)'
Expected: <empty>
But was:  < <Solutionizing.Domain.Oops>, <Solutionizing.Domain.OopsAgain> >
SerializabilityTests.cs(29,0): at Solutionizing.Tests.SerializabilityTests.Types_should_be_Serializable(Type sampleType, String namespace)

I use a few criteria to determine if I expect the type to be

private bool ShouldBeSerializable(Type t)
if (IsExempt(t))
return false;
if (t.IsAbstract && t.IsSealed) // Static class
return false;
if (t.IsInterface)
return false;
if (!t.IsPublic)
return false;

return true;

Other than IsExempt(), the code should be more or less
self-explanatory. If you had never bothered to check how static classes
are represented in IL, now you know: abstract (can’t be instantiated) +
sealed (can’t be inherited). Also, note that !IsPublic will
cover compiler-generated classes for iterators and closures that we
don’t need to serialize.

The final piece is providing a way we can exempt certain classes from
being tested:

private bool IsExempt(Type t)
return exemptTypes.Any(e => e.IsAssignableFrom(t));

private Type[] exemptTypes = new []
typeof(SomeClassWithDictionary), // Wrapped dictionary is not serializable
typeof(Attribute) // Metadata are never serialized

Of course, this isn’t a replacement for actually testing that custom
serialization works correctly for more complicated objects, particularly
if your classes may depend on others that aren’t covered by these
tests. But I have still found this test to be a useful first level of

Review: Pragmatic Unit Testing In C# with NUnit (2nd Edition)