¡Buenas!

Me pareció original la idea de publicar este tema para que podamos compartir tests de unidad (Unit Test) y/o tests de integración (Integration Test) que sean reutilizables,
como una especie de snippets de código. Y así mentener nuestros proyectos libres de bugs.

Esta class nos servirá para mantener una referencia de los (nombres de) ensamblados que se evaluarán en el test.
Como es evidente, los ensamblados deberán estar referenciados en el proyecto de Unit Testing:

Public NotInheritable Class Fields
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' The referenced assembly names to test their members.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    Public Shared ReadOnly AssemblyNames As String() = {
        "Microsoft.VisualStudio.QualityTools.UnitTestFramework",
        "..."
    }
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' The minimum recommended size for a Structure type.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="http://stackoverflow.com/a/1082340/1248295"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    Public Shared ReadOnly MinimumRecommendedStructureSize As Integer = 8
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' The maximum recommended size for a Structure type.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="http://msdn.microsoft.com/en-us/library/ms229017.aspx"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    Public Shared ReadOnly MaximumRecommendedStructureSize As Integer = 16
 
    Private Sub New()
    End Sub
 
End Class

' ***********************************************************************
' Author   : Elektro
' Modified : 15-December-2016
' ***********************************************************************
 
Option Strict On
Option Explicit On
Option Infer Off
 
Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System.Reflection
Imports System.Runtime.InteropServices
 
''' <summary>
''' Performs various tests on the <see langword="Structure"/> members of all the assemblies defined in
''' <see cref="Fields.AssemblyNames"/>.
''' </summary>
<TestClass()>
Public Class StructureTests
 
#Region " Test Methods "
 
    ''' <summary>
    ''' Performs a test on the <see langword="Structure"/> members of all the assemblies defined in
    ''' <see cref="Fields.AssemblyNames"/>, 
    ''' to determine whether a structure has the proper instance size regarding to .NET design guidelines.
    ''' </summary>
    <TestMethod()>
    <TestCategory("Structures")>
    Public Sub TestStructureSizes()
 
        Dim testFailed As Boolean = False
        Dim testException As AssertFailedException = Nothing
 
        ' Safe Structures to exclude in this test.
        ' ----------------------------------------
        ' These structures could be smaller or bigger than what is recommended, however, are not considered an error.
        Dim excludedStructs As String() = {
            "MyNamespace.MyStructure"
        }
 
        For Each assName As String In Fields.AssemblyNames
 
            Dim ass As Assembly = Assembly.Load(assName)
            Debug.WriteLine(String.Format("Testing Assembly '{0}.dll'...", assName))
            Debug.WriteLine(String.Empty)
 
            Dim excludedStructures As IEnumerable(Of Type) =
                From t As Type In ass.GetTypes()
                Where (t.IsValueType) AndAlso (Not t.IsClass) AndAlso (Not t.IsEnum) AndAlso (t.IsVisible)
                Where excludedStructs.Contains(String.Format("{0}.{1}", t.Namespace, t.Name))
                Order By String.Format("{0}.{1}", t.Namespace, t.Name)
 
            Dim includedStructures As IEnumerable(Of Type) =
                From t As Type In ass.GetTypes()
                Where (t.IsValueType) AndAlso (Not t.IsClass) AndAlso (Not t.IsEnum) AndAlso (t.IsVisible)
                Where Not excludedStructs.Contains(String.Format("{0}.{1}", t.Namespace, t.Name))
                Order By String.Format("{0}.{1}", t.Namespace, t.Name)
 
            If (excludedStructures.Count <> 0) Then
                Debug.WriteLine(String.Format("    Excluded Structures:"))
                For Each t As Type In excludedStructures
                    Debug.WriteLine(String.Format("        '{0}.{1}')",
                                              t.Namespace, t.Name))
                Next t
                Debug.WriteLine(String.Empty)
            End If
 
            If (includedStructures.Count <> 0) Then
                For Each t As Type In includedStructures
                    Try
                        Me.EvaluateStructureSize(t)
 
                    Catch ex As AssertFailedException
                        Debug.WriteLine(String.Format("    Testing Structure '{0}.{1}' ({2} Bytes)... FAIL", t.Namespace, t.Name, Marshal.SizeOf(t)))
                        If (testException Is Nothing) Then
                            testException = ex
                            testFailed = True
                        End If
 
                    Catch ex As Exception
                        Debug.WriteLine(String.Format("    Testing Structure '{0}.{1}'... ERROR. EXCEPTION THROWN.",
                                                      t.Namespace, t.Name))
                        Debug.WriteLine("EXCEPTION MESSAGE:")
                        Debug.WriteLine(ex.Message)
                        Throw
 
                    End Try
 
                Next t
                Debug.WriteLine(String.Empty)
            End If
 
            If (testFailed) Then
                Throw testException
            End If
 
        Next assName
 
    End Sub
 
#End Region
 
#Region " Private Methods "
 
    ''' <summary>
    ''' Determines whether the instance size of a structure is smaller and/or greater than the size recommended.
    ''' </summary>
    Private Sub EvaluateStructureSize(ByVal t As Type)
 
        Dim currentStructureSize As Integer = Marshal.SizeOf(t)
 
        Assert.IsTrue((currentStructureSize >= Fields.MinimumRecommendedStructureSize),
                        String.Format("The current instance size of Structure '{0}.{1}' is {2} bytes, which is smaller than the minimum recommended {3} bytes.",
                                      t.Namespace, t.Name, currentStructureSize, Fields.MinimumRecommendedStructureSize))
 
        Assert.IsTrue((currentStructureSize <= Fields.MaximumRecommendedStructureSize),
                        String.Format("The current instance size of Structure '{0}.{1}' is {2} bytes, which is greater than the maximum recommended {3} bytes.",
                                      t.Namespace, t.Name, currentStructureSize, Fields.MaximumRecommendedStructureSize))
 
        Debug.WriteLine(String.Format("    Testing Structure '{0}.{1}' ({2} Bytes)... Ok", t.Namespace, t.Name, currentStructureSize))
 
    End Sub
 
#End Region
 
End Class

Esta class nos servirá para mantener una referencia de los (nombres de) ensamblados que se evaluarán en el test.
Como es evidente, los ensamblados deberán estar referenciados en el proyecto de Unit Testing:

Public NotInheritable Class Fields
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' The referenced assembly names to test their members.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    Public Shared ReadOnly AssemblyNames As String() = {
        "Microsoft.VisualStudio.QualityTools.UnitTestFramework",
        "..."
    }
 
    Private Sub New()
    End Sub
 
End Class

' ***********************************************************************
' Author   : Elektro
' Modified : 16-December-2016
' ***********************************************************************
 
Option Strict On
Option Explicit On
Option Infer Off
 
Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System.Reflection
Imports System.IO
 
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Tests for the <see cref="IDisposable"/> members defined in the assemblies of <see cref="Fields.AssemblyNames"/>.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
<TestClass()>
Public NotInheritable Class TypeTests
 
#Region " Test Methods "
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Performs a test on the <see cref="IDisposable"/> members defined in the assemblies of <see cref="Fields.AssemblyNames"/>, 
    ''' to evaluate the disposability of the <see cref="IDisposable"/> members.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    <TestMethod()>
    <TestCategory("Types")>
    Public Sub TestIDisposableTypes()
 
        Dim testFailed As Boolean = False
        Dim testException As AssertFailedException = Nothing
 
        ' Safe disposable types to exclude in this test.
        ' -----------------------------------
        ' These disposable types could throw an exception when disposed, however, are not considered a bug.
        Dim excludedTypeNames As String() = {
        }
 
        For Each assName As String In Fields.AssemblyNames
 
            Dim ass As Assembly = Assembly.Load(assName)
            Debug.WriteLine(String.Format("Testing Assembly '{0}.dll'...", assName))
            Debug.WriteLine(String.Empty)
 
            Dim excludedTypes As IEnumerable(Of Type) =
                From t As Type In ass.GetTypes()
                Where (t.GetInterfaces.Contains(GetType(IDisposable))) AndAlso (t.IsVisible)
                Where excludedTypeNames.Contains(String.Format("{0}.{1}", t.Namespace, t.Name))
                Order By String.Format("{0}.{1}", t.Namespace, t.Name)
 
            Dim includedTypes As IEnumerable(Of Type) =
                From t As Type In ass.GetTypes()
                Where (t.GetInterfaces.Contains(GetType(IDisposable))) AndAlso (t.IsVisible)
                Where Not excludedTypeNames.Contains(String.Format("{0}.{1}", t.Namespace, t.Name))
                Order By String.Format("{0}.{1}", t.Namespace, t.Name)
 
            If (excludedTypes.Count <> 0) Then
                Debug.WriteLine(String.Format("    Excluded Disposable Types:"))
                For Each t As Type In excludedTypes
                    Debug.WriteLine(String.Format("        '{0}.{1}')", t.Namespace, t.Name))
                Next t
                Debug.WriteLine(String.Empty)
            End If
 
            If (includedTypes.Count <> 0) Then
                For Each t As Type In includedTypes
                    Try
                        Me.EvaluateDisposableType(t)
 
                    Catch ex As TargetInvocationException When (TypeOf ex.InnerException Is FileNotFoundException)
                        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... IGNORED. MISSING ASSEMBLY REFERENCE.", t.Namespace, t.Name))
 
                    Catch ex As FileNotFoundException
                        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... IGNORED. MISSING ASSEMBLY REFERENCE.", t.Namespace, t.Name))
 
                    Catch ex As MissingMethodException
                        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... IGNORED. NO PARAMETERLESS CONSTRUCTOR.", t.Namespace, t.Name))
 
                    Catch ex As ArgumentException
                        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... IGNORED. GENERIC PARAMETER REQUIRED.", t.Namespace, t.Name))
 
                    Catch ex As Exception
                        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... ERROR. EXCEPTION THROWN.", t.Namespace, t.Name))
                        Debug.WriteLine("EXCEPTION MESSAGE:")
                        Debug.WriteLine(ex.Message)
                        Throw
 
                    End Try
                Next t
                Debug.WriteLine(String.Empty)
            End If
 
            If (testFailed) Then
                Throw testException
            End If
 
        Next assName
 
    End Sub
 
#End Region
 
#Region " Private Methods "
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Evaluates whether a disposable type throws an exception during instantiation and/or disposal operation. 
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <param name="t">
    ''' The source type.
    ''' </param>
    ''' ----------------------------------------------------------------------------------------------------
    Private Sub EvaluateDisposableType(ByVal t As Type)
 
        Dim instance As IDisposable = DirectCast(Activator.CreateInstance(t), IDisposable)
        instance.Dispose()
        instance = Nothing
 
        Debug.WriteLine(String.Format("    Testing Disposable Type '{0}.{1}'... Ok", t.Namespace, t.Name))
 
    End Sub
 
#End Region
 
End Class