Improve handling of Assert.Inconclusive (#277)

* Improve handling of Assert.Inconclusive

* Improved namign in new unit tests for Assert.Inconclusive.

Author: jessehouwing

src/Adapter/MSTest.CoreAdapter/Execution/TestMethodInfo.cs

@@ -231,7 +231,7 @@ private TestResult ExecuteInternal(object[] arguments)
 
                     if (result.Outcome != TestTools.UnitTesting.UnitTestOutcome.Passed)
                     {
-                        if (ex.InnerException != null && ex.InnerException is AssertInconclusiveException)
+                        if (ex is UTF.AssertInconclusiveException || ex.InnerException is UTF.AssertInconclusiveException)
                         {
                             result.Outcome = TestTools.UnitTesting.UnitTestOutcome.Inconclusive;
                         }
@@ -317,7 +317,7 @@ private bool IsExpectedException(Exception ex, TestResult result)
                 // attribute's Verify method) is an AssertInconclusiveException. If so, set
                 // the test outcome to Inconclusive.
                 result.TestFailureException = new TestFailedException(
-                    exceptionFromVerify is AssertInconclusiveException ? UnitTestOutcome.Inconclusive : UnitTestOutcome.Failed,
+                    exceptionFromVerify is UTF.AssertInconclusiveException ? UnitTestOutcome.Inconclusive : UnitTestOutcome.Failed,
                                               exceptionFromVerify.TryGetMessage(),
                                               realException.TryGetStackTraceInformation());
                 return false;

test/UnitTests/MSTest.CoreAdapter.Unit.Tests/Execution/TestMethodInfoTests.cs

@@ -130,6 +130,70 @@ public void TestMethodInfoInvokeShouldWaitForAsyncTestMethodsToComplete()
             Assert.AreEqual(UTF.UnitTestOutcome.Passed, result.Outcome);
         }
 
+        [TestMethodV1]
+        public void TestMethodInfoInvokeAsyncShouldHandleThrowAssertInconclusive()
+        {
+            DummyTestClass.DummyAsyncTestMethodBody = () => Task.Run(() => { throw new UTF.AssertInconclusiveException(); });
+            var asyncMethodInfo = typeof(DummyTestClass).GetMethod("DummyAsyncTestMethod");
+
+            var method = new TestMethodInfo(
+                asyncMethodInfo,
+                this.testClassInfo,
+                this.testMethodOptions);
+
+            var result = method.Invoke(null);
+
+            Assert.AreEqual(UTF.UnitTestOutcome.Inconclusive, result.Outcome);
+        }
+
+        [TestMethodV1]
+        public void TestMethodInfoInvokeAsyncShouldHandleAssertInconclusive()
+        {
+            DummyTestClass.DummyAsyncTestMethodBody = () => Task.Run(() => { UTF.Assert.Inconclusive(); });
+            var asyncMethodInfo = typeof(DummyTestClass).GetMethod("DummyAsyncTestMethod");
+
+            var method = new TestMethodInfo(
+                asyncMethodInfo,
+                this.testClassInfo,
+                this.testMethodOptions);
+
+            var result = method.Invoke(null);
+
+            Assert.AreEqual(UTF.UnitTestOutcome.Inconclusive, result.Outcome);
+        }
+
+        [TestMethodV1]
+        public void TestMethodInfoInvokeShouldHandleThrowAssertInconclusive()
+        {
+            DummyTestClass.TestMethodBody = (d) => { throw new UTF.AssertInconclusiveException(); };
+            var dummyMethodInfo = typeof(DummyTestClass).GetMethod("DummyTestMethod");
+
+            var method = new TestMethodInfo(
+                dummyMethodInfo,
+                this.testClassInfo,
+                this.testMethodOptions);
+
+            var result = method.Invoke(null);
+
+            Assert.AreEqual(UTF.UnitTestOutcome.Inconclusive, result.Outcome);
+        }
+
+        [TestMethodV1]
+        public void TestMethodInfoInvokeShouldHandleAssertInconclusive()
+        {
+            DummyTestClass.TestMethodBody = (d) => { UTF.Assert.Inconclusive(); };
+            var dummyMethodInfo = typeof(DummyTestClass).GetMethod("DummyTestMethod");
+
+            var method = new TestMethodInfo(
+                dummyMethodInfo,
+                this.testClassInfo,
+                this.testMethodOptions);
+
+            var result = method.Invoke(null);
+
+            Assert.AreEqual(UTF.UnitTestOutcome.Inconclusive, result.Outcome);
+        }
+
         [TestMethodV1]
         public void TestMethodInfoInvokeShouldListenForDebugAndTraceLogsWhenEnabled()
         {