Add VerifyThrowsT

microsoft · Sep 14, 2024 · ee4e46b · ee4e46b
1 parent 2a26a70
commit ee4e46b
Show file tree

Hide file tree

Showing 24 changed files with 198 additions and 484 deletions.
diff --git a/test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/FileOperationsTests.cs b/test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/FileOperationsTests.cs
@@ -19,24 +19,15 @@ public void LoadAssemblyShouldThrowExceptionIfTheFileNameHasInvalidCharacters()
         string filePath = "temp<>txt";
         void A() => _fileOperations.LoadAssembly(filePath, false);
 
-        Type expectedException;
 #if NETCOREAPP
-        expectedException = typeof(FileNotFoundException);
+        VerifyThrows<FileNotFoundException>(A);
 #else
-        expectedException = typeof(ArgumentException);
+        VerifyThrows<ArgumentException>(A);
 #endif
-
-        Exception ex = VerifyThrows(A);
-        Verify(ex.GetType() == expectedException);
     }
 
-    public void LoadAssemblyShouldThrowExceptionIfFileIsNotFound()
-    {
-        string filePath = "temptxt";
-        void A() => _fileOperations.LoadAssembly(filePath, false);
-        Exception ex = VerifyThrows(A);
-        Verify(ex is FileNotFoundException);
-    }
+    public void LoadAssemblyShouldThrowExceptionIfFileIsNotFound() =>
+        VerifyThrows<FileNotFoundException>(() => _fileOperations.LoadAssembly("temptxt", false));
 
     public void LoadAssemblyShouldLoadAssemblyInCurrentContext()
     {

diff --git a/...UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/MSTestAdapterSettingsTests.cs b/...UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/MSTestAdapterSettingsTests.cs
@@ -224,8 +224,7 @@ public void ToSettingsShouldThrowExceptionWhenRunSettingsXmlIsWrong()
 
         void ShouldThrowException() => MSTestAdapterSettings.ToSettings(reader);
 
-        Exception ex = VerifyThrows(ShouldThrowException);
-        Verify(ex is SettingsException);
+        VerifyThrows<SettingsException>(ShouldThrowException);
     }
 
     #endregion

diff --git a/...nitTests/MSTestAdapter.PlatformServices.UnitTests/Services/MSTestSettingsProviderTests.cs b/...nitTests/MSTestAdapter.PlatformServices.UnitTests/Services/MSTestSettingsProviderTests.cs
@@ -55,11 +55,8 @@ public void SettingsShouldReturnInitializedSettings()
         Verify(!MSTestSettingsProvider.Settings.DeploymentEnabled);
     }
 
-    public void LoadShouldThrowIfReaderIsNull()
-    {
-        Exception exception = VerifyThrows(() => _settingsProvider.Load(null));
-        Verify(exception is ArgumentNullException);
-    }
+    public void LoadShouldThrowIfReaderIsNull() =>
+        VerifyThrows<ArgumentNullException>(() => _settingsProvider.Load(null));
 
     public void LoadShouldReadAndFillInSettings()
     {

diff --git a/...Tests/MSTestAdapter.PlatformServices.UnitTests/Services/TestContextImplementationTests.cs b/...Tests/MSTestAdapter.PlatformServices.UnitTests/Services/TestContextImplementationTests.cs
@@ -140,21 +140,15 @@ public void AddResultFileShouldThrowIfFileNameIsNull()
     {
         _testContextImplementation = new TestContextImplementation(_testMethod.Object, new ThreadSafeStringWriter(null, "test"), _properties);
 
-        Exception exception =
-            VerifyThrows(() => _testContextImplementation.AddResultFile(null));
-
-        Verify(typeof(ArgumentException) == exception.GetType());
+        ArgumentException exception = VerifyThrows<ArgumentException>(() => _testContextImplementation.AddResultFile(null));
         Verify(exception.Message.Contains(Resource.Common_CannotBeNullOrEmpty));
     }
 
     public void AddResultFileShouldThrowIfFileNameIsEmpty()
     {
         _testContextImplementation = new TestContextImplementation(_testMethod.Object, new ThreadSafeStringWriter(null, "test"), _properties);
 
-        Exception exception =
-            VerifyThrows(() => _testContextImplementation.AddResultFile(string.Empty));
-
-        Verify(typeof(ArgumentException) == exception.GetType());
+        ArgumentException exception = VerifyThrows<ArgumentException>(() => _testContextImplementation.AddResultFile(string.Empty));
         Verify(exception.Message.Contains(Resource.Common_CannotBeNullOrEmpty));
     }
 

diff --git a/.../UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/TraceListenerManagerTests.cs b/.../UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/TraceListenerManagerTests.cs
@@ -57,9 +57,7 @@ public void DisposeShouldCallDisposeOnCorrespondingTraceListener()
         traceListenerManager.Dispose(traceListener);
 
         // Trying to write after closing textWriter should throw exception
-        void ShouldThrowException() => writer.WriteLine("Try to write something");
-        Exception ex = VerifyThrows(ShouldThrowException);
-        Verify(ex is ObjectDisposedException);
+        VerifyThrows<ObjectDisposedException>(() => writer.WriteLine("Try to write something"));
     }
 }
 

diff --git a/test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/TraceListenerTests.cs b/test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/TraceListenerTests.cs
@@ -30,8 +30,7 @@ public void DisposeShouldDisposeCorrespondingTextWriter()
 
         // Trying to write after disposing textWriter should throw exception
         void ShouldThrowException() => writer.WriteLine("Try to write something");
-        Exception ex = VerifyThrows(ShouldThrowException);
-        Verify(ex is ObjectDisposedException);
+        VerifyThrows<ObjectDisposedException>(ShouldThrowException);
     }
 }
 

diff --git a/test/UnitTests/MSTestAdapter.UnitTests/Execution/TestAssemblyInfoTests.cs b/test/UnitTests/MSTestAdapter.UnitTests/Execution/TestAssemblyInfoTests.cs
@@ -42,8 +42,7 @@ void Action()
             _testAssemblyInfo.AssemblyInitializeMethod = _dummyMethodInfo;
         }
 
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(TypeInspectionException));
+        VerifyThrows<TypeInspectionException>(Action);
     }
 
     public void TestAssemblyInfoAssemblyCleanupMethodThrowsForMultipleAssemblyCleanupMethods()
@@ -54,8 +53,7 @@ void Action()
             _testAssemblyInfo.AssemblyCleanupMethod = _dummyMethodInfo;
         }
 
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(TypeInspectionException));
+        VerifyThrows<TypeInspectionException>(Action);
     }
 
     public void TestAssemblyHasExecutableCleanupMethodShouldReturnFalseIfAssemblyHasNoCleanupMethod() => Verify(!_testAssemblyInfo.HasExecutableCleanupMethod);
@@ -97,8 +95,7 @@ public void RunAssemblyInitializeShouldThrowIfTestContextIsNull()
 
         void Action() => _testAssemblyInfo.RunAssemblyInitialize(null);
 
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(NullReferenceException));
+        VerifyThrows<NullReferenceException>(Action);
     }
 
     public void RunAssemblyInitializeShouldNotExecuteAssemblyInitializeIfItHasAlreadyExecuted()
@@ -151,9 +148,7 @@ public void RunAssemblyInitializeShouldThrowTestFailedExceptionOnAssertionFailur
         DummyTestClass.AssemblyInitializeMethodBody = tc => UTF.Assert.Fail("Test failure");
         _testAssemblyInfo.AssemblyInitializeMethod = typeof(DummyTestClass).GetMethod("AssemblyInitializeMethod");
 
-        var exception = VerifyThrows(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext)) as TestFailedException;
-
-        Verify(exception is not null);
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext));
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -169,9 +164,7 @@ public void RunAssemblyInitializeShouldThrowTestFailedExceptionWithInconclusiveO
         DummyTestClass.AssemblyInitializeMethodBody = tc => UTF.Assert.Inconclusive("Test Inconclusive");
         _testAssemblyInfo.AssemblyInitializeMethod = typeof(DummyTestClass).GetMethod("AssemblyInitializeMethod");
 
-        var exception = VerifyThrows(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext)) as TestFailedException;
-
-        Verify(exception is not null);
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext));
         Verify(exception.Outcome == UnitTestOutcome.Inconclusive);
         Verify(
             exception.Message
@@ -187,9 +180,8 @@ public void RunAssemblyInitializeShouldThrowTestFailedExceptionWithNonAssertExce
         DummyTestClass.AssemblyInitializeMethodBody = tc => throw new ArgumentException("Some actualErrorMessage message", new InvalidOperationException("Inner actualErrorMessage message"));
         _testAssemblyInfo.AssemblyInitializeMethod = typeof(DummyTestClass).GetMethod("AssemblyInitializeMethod");
 
-        var exception = VerifyThrows(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext)) as TestFailedException;
+        var exception = VerifyThrows<TestFailedException>(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -210,9 +202,8 @@ public void RunAssemblyInitializeShouldThrowTheInnerMostExceptionWhenThereAreMul
             FailingStaticHelper.DoWork();
         _testAssemblyInfo.AssemblyInitializeMethod = typeof(DummyTestClass).GetMethod("AssemblyInitializeMethod");
 
-        var exception = VerifyThrows(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext)) as TestFailedException;
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -230,9 +221,7 @@ public void RunAssemblyInitializeShouldThrowForAlreadyExecutedTestAssemblyInitWi
         _testAssemblyInfo.AssemblyInitializeMethod = typeof(DummyTestClass).GetMethod("AssemblyInitializeMethod");
         _testAssemblyInfo.AssemblyInitializationException = new TestFailedException(UnitTestOutcome.Failed, "Cached Test failure");
 
-        var exception = VerifyThrows(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext)) as TestFailedException;
-
-        Verify(exception is not null);
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testAssemblyInfo.RunAssemblyInitialize(_testContext));
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(exception.Message == "Cached Test failure");
     }

diff --git a/test/UnitTests/MSTestAdapter.UnitTests/Execution/TestClassInfoTests.cs b/test/UnitTests/MSTestAdapter.UnitTests/Execution/TestClassInfoTests.cs
@@ -81,8 +81,7 @@ void Action()
             _testClassInfo.ClassInitializeMethod = _testClassType.GetMethods().First();
         }
 
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(TypeInspectionException));
+        VerifyThrows<TypeInspectionException>(Action);
     }
 
     public void TestClassInfoClassCleanupMethodSetShouldThrowForMultipleClassCleanupMethods()
@@ -93,8 +92,7 @@ void Action()
             _testClassInfo.ClassCleanupMethod = _testClassType.GetMethods().First();
         }
 
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(TypeInspectionException));
+        VerifyThrows<TypeInspectionException>(Action);
     }
 
     public void TestClassInfoClassCleanupMethodShouldNotInvokeWhenNoTestClassInitializedIsCalled()
@@ -174,10 +172,7 @@ public void RunClassInitializeShouldThrowIfTestContextIsNull()
 
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
 
-        void Action() => _testClassInfo.RunClassInitialize(null);
-
-        Exception ex = VerifyThrows(Action);
-        Verify(ex.GetType() == typeof(NullReferenceException));
+        VerifyThrows<NullReferenceException>(() => _testClassInfo.RunClassInitialize(null));
     }
 
     public void RunClassInitializeShouldNotExecuteClassInitializeIfItHasAlreadyExecuted()
@@ -309,9 +304,8 @@ public void RunClassInitializeShouldThrowTestFailedExceptionOnBaseInitializeMeth
 
         _testClassInfo.BaseClassInitMethods.Add(typeof(DummyBaseTestClass).GetMethod("InitBaseClassMethod"));
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -328,9 +322,8 @@ public void RunClassInitializeShouldThrowTestFailedExceptionOnAssertionFailure()
         DummyTestClass.ClassInitializeMethodBody = tc => UTF.Assert.Fail("Test failure");
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -346,9 +339,8 @@ public void RunClassInitializeShouldThrowTestFailedExceptionWithInconclusiveOnAs
         DummyTestClass.ClassInitializeMethodBody = tc => UTF.Assert.Inconclusive("Test Inconclusive");
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Inconclusive);
         Verify(
             exception.Message
@@ -364,9 +356,8 @@ public void RunClassInitializeShouldThrowTestFailedExceptionWithNonAssertExcepti
         DummyTestClass.ClassInitializeMethodBody = tc => throw new ArgumentException("Argument exception");
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message
@@ -382,9 +373,7 @@ public void RunClassInitializeShouldThrowForAlreadyExecutedTestClassInitWithExce
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
         _testClassInfo.ClassInitializationException = new TestFailedException(UnitTestOutcome.Failed, "Cached Test failure");
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
-
-        Verify(exception is not null);
+        TestFailedException exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(exception.Message == "Cached Test failure");
     }
@@ -406,9 +395,8 @@ public void RunClassInitializeShouldThrowTheInnerMostExceptionWhenThereAreMultip
             FailingStaticHelper.DoWork();
         _testClassInfo.ClassInitializeMethod = typeof(DummyTestClass).GetMethod("ClassInitializeMethod");
 
-        var exception = VerifyThrows(() => _testClassInfo.RunClassInitialize(_testContext)) as TestFailedException;
+        var exception = VerifyThrows<TestFailedException>(() => _testClassInfo.RunClassInitialize(_testContext));
 
-        Verify(exception is not null);
         Verify(exception.Outcome == UnitTestOutcome.Failed);
         Verify(
             exception.Message