[Refactor ] to use Assert.That

Author: samatstariongroup

SysML2.NET.Tests/Extend/AcceptActionUsageExtensionsTestFixture.cs

@@ -32,19 +32,19 @@ public class AcceptActionUsageExtensionsTestFixture
         [Test]
         public void ComputePayloadArgument_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAcceptActionUsage)null).ComputePayloadArgument());
+            Assert.That(() => ((IAcceptActionUsage)null).ComputePayloadArgument(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputePayloadParameter_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAcceptActionUsage)null).ComputePayloadParameter());
+            Assert.That(() => ((IAcceptActionUsage)null).ComputePayloadParameter(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeReceiverArgument_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAcceptActionUsage)null).ComputeReceiverArgument());
+            Assert.That(() => ((IAcceptActionUsage)null).ComputeReceiverArgument(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/ActionDefinitionExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class ActionDefinitionExtensionsTestFixture
         [Test]
         public void ComputeAction_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IActionDefinition)null).ComputeAction());
+            Assert.That(() => ((IActionDefinition)null).ComputeAction(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/ActionUsageExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class ActionUsageExtensionsTestFixture
         [Test]
         public void ComputeActionDefinition_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IActionUsage)null).ComputeActionDefinition());
+            Assert.That(() => ((IActionUsage)null).ComputeActionDefinition(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/ActorMembershipExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class ActorMembershipExtensionsTestFixture
         [Test]
         public void ComputeOwnedActorParameter_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IActorMembership)null).ComputeOwnedActorParameter());
+            Assert.That(() => ((IActorMembership)null).ComputeOwnedActorParameter(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AllocationDefinitionExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class AllocationDefinitionExtensionsTestFixture
         [Test]
         public void ComputeAllocation_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAllocationDefinition)null).ComputeAllocation());
+            Assert.That(() => ((IAllocationDefinition)null).ComputeAllocation(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AllocationUsageExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class AllocationUsageExtensionsTestFixture
         [Test]
         public void ComputeAllocationDefinition_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAllocationUsage)null).ComputeAllocationDefinition());
+            Assert.That(() => ((IAllocationUsage)null).ComputeAllocationDefinition(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AnalysisCaseDefinitionExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class AnalysisCaseDefinitionExtensionsTestFixture
         [Test]
         public void ComputeResultExpression_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnalysisCaseDefinition)null).ComputeResultExpression());
+            Assert.That(() => ((IAnalysisCaseDefinition)null).ComputeResultExpression(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AnalysisCaseUsageExtensionsTestFixture.cs

@@ -32,13 +32,13 @@ public class AnalysisCaseUsageExtensionsTestFixture
         [Test]
         public void ComputeAnalysisCaseDefinition_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnalysisCaseUsage)null).ComputeAnalysisCaseDefinition());
+            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeAnalysisCaseDefinition(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeResultExpression_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnalysisCaseUsage)null).ComputeResultExpression());
+            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeResultExpression(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AnnotatingElementExtensionsTestFixture.cs

@@ -32,25 +32,25 @@ public class AnnotatingElementExtensionsTestFixture
         [Test]
         public void ComputeAnnotatedElement_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotatingElement)null).ComputeAnnotatedElement());
+            Assert.That(() => ((IAnnotatingElement)null).ComputeAnnotatedElement(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeAnnotation_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotatingElement)null).ComputeAnnotation());
+            Assert.That(() => ((IAnnotatingElement)null).ComputeAnnotation(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeOwnedAnnotatingRelationship_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotatingElement)null).ComputeOwnedAnnotatingRelationship());
+            Assert.That(() => ((IAnnotatingElement)null).ComputeOwnedAnnotatingRelationship(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeOwningAnnotatingRelationship_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotatingElement)null).ComputeOwningAnnotatingRelationship());
+            Assert.That(() => ((IAnnotatingElement)null).ComputeOwningAnnotatingRelationship(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }

SysML2.NET.Tests/Extend/AnnotationExtensionsTestFixture.cs

@@ -32,25 +32,25 @@ public class AnnotationExtensionsTestFixture
         [Test]
         public void ComputeAnnotatingElement_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotation)null).ComputeAnnotatingElement());
+            Assert.That(() => ((IAnnotation)null).ComputeAnnotatingElement(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeOwnedAnnotatingElement_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotation)null).ComputeOwnedAnnotatingElement());
+            Assert.That(() => ((IAnnotation)null).ComputeOwnedAnnotatingElement(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeOwningAnnotatedElement_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotation)null).ComputeOwningAnnotatedElement());
+            Assert.That(() => ((IAnnotation)null).ComputeOwningAnnotatedElement(), Throws.TypeOf<NotSupportedException>());
         }
 
         [Test]
         public void ComputeOwningAnnotatingElement_ThrowsNotSupportedException()
         {
-            Assert.Throws<NotSupportedException>(() => ((IAnnotation)null).ComputeOwningAnnotatingElement());
+            Assert.That(() => ((IAnnotation)null).ComputeOwningAnnotatingElement(), Throws.TypeOf<NotSupportedException>());
         }
     }
 }