diff --git a/tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs b/tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs
index 94268473b2..fdf47015cd 100644
--- a/tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs
+++ b/tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs
@@ -37,61 +37,61 @@ namespace ImageSharp.Tests.Colors
                { new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.One * 0x7FFF), typeof(Short4) },
            };
 
-        public static readonly TheoryData<object, object> NotEqualityDataNulls =
-            new TheoryData<object, object>()
+        public static readonly TheoryData<object, object, Type> NotEqualityDataNulls =
+            new TheoryData<object, object, Type>()
             {
                 // Valid object against null
-                { new Alpha8(.5F), null },
-                { new Argb(Vector4.One), null },
-                { new Bgr565(Vector3.One), null },
-                { new Bgra4444(Vector4.One), null },
-                { new Bgra5551(Vector4.One), null },
-                { new Byte4(Vector4.One * 255), null },
-                { new HalfSingle(-1F), null },
-                { new HalfVector2(0.1f, -0.3f), null },
-                { new HalfVector4(Vector4.One), null },
-                { new NormalizedByte2(-Vector2.One), null },
-                { new NormalizedByte4(Vector4.One), null },
-                { new NormalizedShort2(Vector2.One), null },
-                { new NormalizedShort4(Vector4.One), null },
-                { new Rg32(Vector2.One), null },
-                { new Rgba1010102(Vector4.One), null },
-                { new Rgba64(Vector4.One), null },
-                { new Short2(Vector2.One * 0x7FFF), null },
-                { new Short4(Vector4.One * 0x7FFF), null },
+                { new Alpha8(.5F), null, typeof(Alpha8) },
+                { new Argb(Vector4.One), null, typeof(Argb) },
+                { new Bgr565(Vector3.One), null, typeof(Bgr565) },
+                { new Bgra4444(Vector4.One), null, typeof(Bgra4444) },
+                { new Bgra5551(Vector4.One), null, typeof(Bgra5551) },
+                { new Byte4(Vector4.One * 255), null, typeof(Byte4) },
+                { new HalfSingle(-1F), null, typeof(HalfSingle) },
+                { new HalfVector2(0.1f, -0.3f), null, typeof(HalfVector2) },
+                { new HalfVector4(Vector4.One), null, typeof(HalfVector4) },
+                { new NormalizedByte2(-Vector2.One), null, typeof(NormalizedByte2) },
+                { new NormalizedByte4(Vector4.One), null, typeof(NormalizedByte4) },
+                { new NormalizedShort2(Vector2.One), null, typeof(NormalizedShort2) },
+                { new NormalizedShort4(Vector4.One), null, typeof(NormalizedShort4) },
+                { new Rg32(Vector2.One), null, typeof(Rg32) },
+                { new Rgba1010102(Vector4.One), null, typeof(Rgba1010102) },
+                { new Rgba64(Vector4.One), null, typeof(Rgba64) },
+                { new Short2(Vector2.One * 0x7FFF), null, typeof(Short2) },
+                { new Short4(Vector4.One * 0x7FFF), null, typeof(Short4) },
             };
 
-        public static readonly TheoryData<object, object> NotEqualityDataDifferentObjects =
-           new TheoryData<object, object>()
+        public static readonly TheoryData<object, object, Type> NotEqualityDataDifferentObjects =
+           new TheoryData<object, object, Type>()
            {
                 // Valid objects of different types but not equal
-                { new Alpha8(.5F), new Argb(Vector4.Zero) },
-                { new HalfSingle(-1F), new NormalizedShort2(Vector2.Zero) },
-                { new Rgba1010102(Vector4.One), new Bgra5551(Vector4.Zero) },
+                { new Alpha8(.5F), new Argb(Vector4.Zero), null },
+                { new HalfSingle(-1F), new NormalizedShort2(Vector2.Zero), null },
+                { new Rgba1010102(Vector4.One), new Bgra5551(Vector4.Zero), null },
            };
 
-        public static readonly TheoryData<object, object> NotEqualityData =
-           new TheoryData<object, object>()
+        public static readonly TheoryData<object, object, Type> NotEqualityData =
+           new TheoryData<object, object, Type>()
            {
                 // Valid objects of the same type but not equal
-                { new Alpha8(.5F), new Alpha8(.8F) },
-                { new Argb(Vector4.One), new Argb(Vector4.Zero) },
-                { new Bgr565(Vector3.One), new Bgr565(Vector3.Zero) },
-                { new Bgra4444(Vector4.One), new Bgra4444(Vector4.Zero) },
-                { new Bgra5551(Vector4.One), new Bgra5551(Vector4.Zero) },
-                { new Byte4(Vector4.One * 255), new Byte4(Vector4.Zero) },
-                { new HalfSingle(-1F), new HalfSingle(1F) },
-                { new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, 0.3f) },
-                { new HalfVector4(Vector4.One), new HalfVector4(Vector4.Zero) },
-                { new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.Zero) },
-                { new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.Zero) },
-                { new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.Zero) },
-                { new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.Zero) },
-                { new Rg32(Vector2.One), new Rg32(Vector2.Zero) },
-                { new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.Zero) },
-                { new Rgba64(Vector4.One), new Rgba64(Vector4.Zero) },
-                { new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.Zero) },
-                { new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.Zero) },
+                { new Alpha8(.5F), new Alpha8(.8F), typeof(Alpha8) },
+                { new Argb(Vector4.One), new Argb(Vector4.Zero), typeof(Argb) },
+                { new Bgr565(Vector3.One), new Bgr565(Vector3.Zero), typeof(Bgr565) },
+                { new Bgra4444(Vector4.One), new Bgra4444(Vector4.Zero), typeof(Bgra4444) },
+                { new Bgra5551(Vector4.One), new Bgra5551(Vector4.Zero), typeof(Bgra5551) },
+                { new Byte4(Vector4.One * 255), new Byte4(Vector4.Zero), typeof(Byte4) },
+                { new HalfSingle(-1F), new HalfSingle(1F), typeof(HalfSingle) },
+                { new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, 0.3f), typeof(HalfVector2) },
+                { new HalfVector4(Vector4.One), new HalfVector4(Vector4.Zero), typeof(HalfVector4) },
+                { new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.Zero), typeof(NormalizedByte2) },
+                { new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.Zero), typeof(NormalizedByte4) },
+                { new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.Zero), typeof(NormalizedShort2) },
+                { new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.Zero), typeof(NormalizedShort4) },
+                { new Rg32(Vector2.One), new Rg32(Vector2.Zero), typeof(Rg32) },
+                { new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.Zero), typeof(Rgba1010102) },
+                { new Rgba64(Vector4.One), new Rgba64(Vector4.Zero), typeof(Rgba64) },
+                { new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.Zero), typeof(Short2) },
+                { new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.Zero), typeof(Short4) },
            };
 
         [Theory]
@@ -109,7 +109,7 @@ namespace ImageSharp.Tests.Colors
         [MemberData(nameof(NotEqualityDataNulls))]
         [MemberData(nameof(NotEqualityDataDifferentObjects))]
         [MemberData(nameof(NotEqualityData))]
-        public void NotEquality(object first, object second)
+        public void NotEquality(object first, object second, Type type)
         {
             // Act
             var equal = first.Equals(second);
@@ -131,7 +131,7 @@ namespace ImageSharp.Tests.Colors
 
         [Theory]
         [MemberData(nameof(NotEqualityDataDifferentObjects))]
-        public void HashCodeNotEqual(object first, object second)
+        public void HashCodeNotEqual(object first, object second, Type type)
         {
             // Act
             var equal = first.GetHashCode() == second.GetHashCode();