Add Assert.IsInstanceOfType<T>

src/TestFramework/MSTest.Core/Assertions/Assert.IsInstanceOfType.cs

@@ -35,6 +35,16 @@ public static void IsInstanceOfType(object value, Type expectedType)
         IsInstanceOfType(value, expectedType, string.Empty, null);
     }
 
+    /// <summary>
+    /// Tests whether the specified object is an instance of the generic
+    /// type and throws an exception if the generictype is not in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsInstanceOfType<T>(object value)
+    {
+        IsInstanceOfType(value, typeof(T), string.Empty, null);
+    }
+
     /// <summary>
     /// Tests whether the specified object is an instance of the expected
     /// type and throws an exception if the expected type is not in the
@@ -61,6 +71,16 @@ public static void IsInstanceOfType(object value, Type expectedType, string mess
         IsInstanceOfType(value, expectedType, message, null);
     }
 
+    /// <summary>
+    /// Tests whether the specified object is an instance of the generic
+    /// type and throws an exception if the generictype is not in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsInstanceOfType<T>(object value, string message)
+    {
+        IsInstanceOfType(value, typeof(T), message, null);
+    }
+
     /// <summary>
     /// Tests whether the specified object is an instance of the expected
     /// type and throws an exception if the expected type is not in the
@@ -107,6 +127,16 @@ public static void IsInstanceOfType(object value, Type expectedType, string mess
         }
     }
 
+    /// <summary>
+    /// Tests whether the specified object is an instance of the generic
+    /// type and throws an exception if the generictype is not in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsInstanceOfType<T>(object value, string message, params object[] parameters)
+    {
+        IsInstanceOfType(value, typeof(T), message, parameters);
+    }
+
     /// <summary>
     /// Tests whether the specified object is not an instance of the wrong
     /// type and throws an exception if the specified type is in the
@@ -128,6 +158,16 @@ public static void IsNotInstanceOfType(object value, Type wrongType)
         IsNotInstanceOfType(value, wrongType, string.Empty, null);
     }
 
+    /// <summary>
+    /// Tests whether the specified object is not an instance of the wrong generic
+    /// type and throws an exception if the specified type is in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsNotInstanceOfType<T>(object value)
+    {
+        IsNotInstanceOfType(value, typeof(T), string.Empty, null);
+    }
+
     /// <summary>
     /// Tests whether the specified object is not an instance of the wrong
     /// type and throws an exception if the specified type is in the
@@ -154,6 +194,16 @@ public static void IsNotInstanceOfType(object value, Type wrongType, string mess
         IsNotInstanceOfType(value, wrongType, message, null);
     }
 
+    /// <summary>
+    /// Tests whether the specified object is not an instance of the wrong generic
+    /// type and throws an exception if the specified type is in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsNotInstanceOfType<T>(object value, string message)
+    {
+        IsNotInstanceOfType(value, typeof(T), message, null);
+    }
+
     /// <summary>
     /// Tests whether the specified object is not an instance of the wrong
     /// type and throws an exception if the specified type is in the
@@ -205,4 +255,14 @@ public static void IsNotInstanceOfType(object value, Type wrongType, string mess
             ThrowAssertFailed("Assert.IsNotInstanceOfType", finalMessage);
         }
     }
+
+    /// <summary>
+    /// Tests whether the specified object is not an instance of the wrong generic
+    /// type and throws an exception if the specified type is in the
+    /// inheritance hierarchy of the object.
+    /// </summary>
+    public static void IsNotInstanceOfType<T>(object value, string message, params object[] parameters)
+    {
+        IsNotInstanceOfType(value, typeof(T), message, parameters);
+    }
 }

test/UnitTests/MSTest.Core.Unit.Tests/Assertions/AssertTests.IsInstanceOfTypeTests.cs

@@ -20,53 +20,90 @@ namespace Microsoft.VisualStudio.TestPlatform.TestFramework.UnitTests;
 public partial class AssertTests
 {
     [TestMethod]
-    public void InstanceOfTypeShouldFailWhenValueIsNull()
+    public void IsInstanceOfType_WhenValueIsNull_Fails()
     {
         static void action() => TestFrameworkV2.Assert.IsInstanceOfType(null, typeof(AssertTests));
         ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(TestFrameworkV2.AssertFailedException));
     }
 
     [TestMethod]
-    public void InstanceOfTypeShouldFailWhenTypeIsNull()
+    public void IsInstanceOfType_WhenTypeIsNull_Fails()
     {
         static void action() => TestFrameworkV2.Assert.IsInstanceOfType(5, null);
         ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(TestFrameworkV2.AssertFailedException));
     }
 
     [TestMethod]
-    public void InstanceOfTypeShouldPassOnSameInstance()
+    public void IsInstanceOfType_OnSameInstance_DoesNotThrow()
     {
         TestFrameworkV2.Assert.IsInstanceOfType(5, typeof(int));
     }
 
     [TestMethod]
-    public void InstanceOfTypeShouldPassOnHigherInstance()
+    public void IsInstanceOfType_OnHigherInstance_DoesNotThrow()
     {
         TestFrameworkV2.Assert.IsInstanceOfType(5, typeof(object));
     }
 
     [TestMethod]
-    public void InstanceNotOfTypeShouldFailWhenValueIsNull()
+    public void IsNotInstanceOfType_WhenValueIsNull_DoesNotThrow()
     {
-        Action action = () => TestFrameworkV2.Assert.IsNotInstanceOfType(null, typeof(AssertTests));
+        TestFrameworkV2.Assert.IsNotInstanceOfType(null, typeof(object));
     }
 
     [TestMethod]
-    public void InstanceNotOfTypeShouldFailWhenTypeIsNull()
+    public void IsNotInstanceOfType_WhenTypeIsNull_Fails()
     {
         static void action() => TestFrameworkV2.Assert.IsNotInstanceOfType(5, null);
         ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(TestFrameworkV2.AssertFailedException));
     }
 
     [TestMethod]
-    public void InstanceNotOfTypeShouldPassOnWrongInstance()
+    public void IsNotInstanceOfType_OnWrongInstance_DoesNotThrow()
     {
         TestFrameworkV2.Assert.IsNotInstanceOfType(5L, typeof(int));
     }
 
     [TestMethod]
-    public void InstanceNotOfTypeShouldPassOnSubInstance()
+    public void IsNotInstanceOfType_OnSubInstance_DoesNotThrow()
     {
         TestFrameworkV2.Assert.IsNotInstanceOfType(new object(), typeof(int));
     }
+
+    [TestMethod]
+    public void IsInstanceOfTypeUsingGenericType_WhenValueIsNull_Fails()
+    {
+        static void action() => TestFrameworkV2.Assert.IsInstanceOfType<AssertTests>(null);
+        ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(TestFrameworkV2.AssertFailedException));
+    }
+
+    [TestMethod]
+    public void IsInstanceOfTypeUsingGenericType_OnSameInstance_DoesNotThrow()
+    {
+        TestFrameworkV2.Assert.IsInstanceOfType<int>(5);
+    }
+
+    [TestMethod]
+    public void IsInstanceOfTypeUsingGenericType_OnHigherInstance_DoesNotThrow()
+    {
+        TestFrameworkV2.Assert.IsInstanceOfType<object>(5);
+    }
+
+    [TestMethod]
+    public void IsNotInstanceOfTypeUsingGenericType_WhenValueIsNull_DoesNotThrow()
+    {
+        TestFrameworkV2.Assert.IsNotInstanceOfType<object>(null);
+    }
+
+    [TestMethod]
+    public void IsNotInstanceOfType_OnWrongInstanceUsingGenericType_DoesNotThrow()
+    {
+        TestFrameworkV2.Assert.IsNotInstanceOfType<int>(5L);
+    }
+
+    [TestMethod]
+    public void IsNotInstanceOfTypeUsingGenericType_OnSubInstance_DoesNotThrow()
+    {
+        TestFrameworkV2.Assert.IsNotInstanceOfType<int>(new object());
+    }
 }

test/UnitTests/MSTest.CoreAdapter.TestUtilities/ActionUtility.cs

@@ -32,7 +32,8 @@ public static void ActionShouldThrowExceptionOfType(Action action, Type type)
         }
         catch (Exception ex)
         {
-            TestFramework.Assert.AreEqual(type, ex.GetType());
+            var t = ex.GetType();
+            TestFramework.Assert.AreEqual(type, t);
         }
     }