Update test structure for exception handling

src/Radical.Tests/ChangeArgsTests.cs

@@ -26,25 +26,29 @@ public void changeArgs_generic_ctor_normal_should_correctly_set_values()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         public void changeArgs_ctor_using_null_reference_entity_should_raise_ArgumentNullException()
         {
-            object entity = null;
-            var cachedValue = new GenericParameterHelper();
-            var iChange = A.Dummy<IChange>();
-
-            var target = new ChangeEventArgs<GenericParameterHelper>(entity, cachedValue, iChange);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                object entity = null;
+                var cachedValue = new GenericParameterHelper();
+                var iChange = A.Dummy<IChange>();
+
+                var target = new ChangeEventArgs<GenericParameterHelper>(entity, cachedValue, iChange);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         public void changeArgs_ctor_using_null_reference_iChange_should_raise_ArgumentNullException()
         {
-            var entity = new object();
-            var cachedValue = new GenericParameterHelper();
-            IChange iChange = null;
-
-            var target = new ChangeEventArgs<GenericParameterHelper>(entity, cachedValue, iChange);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var entity = new object();
+                var cachedValue = new GenericParameterHelper();
+                IChange iChange = null;
+
+                var target = new ChangeEventArgs<GenericParameterHelper>(entity, cachedValue, iChange);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/AdvisedActionTests.cs

@@ -23,27 +23,33 @@ public void advisedAction_ctor()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void advisedAction_ctor_null_reference_target()
         {
-            AdvisedAction actual = new AdvisedAction(null, ProposedActions.Delete);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                AdvisedAction actual = new AdvisedAction(null, ProposedActions.Delete);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(NotSupportedException))]
         [TestCategory("ChangeTracking")]
         public void advisedAction_ctor_not_supported_proposed_action()
         {
-            AdvisedAction actual = new AdvisedAction(new object(), ProposedActions.None);
+            Assert.ThrowsExactly<NotSupportedException>(() =>
+            {
+                AdvisedAction actual = new AdvisedAction(new object(), ProposedActions.None);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(EnumValueOutOfRangeException))]
         [TestCategory("ChangeTracking")]
         public void advisedAction_ctor_invalid_proposed_action()
         {
-            AdvisedAction actual = new AdvisedAction(new object(), (ProposedActions)1000);
+            Assert.ThrowsExactly<EnumValueOutOfRangeException>(() =>
+            {
+                AdvisedAction actual = new AdvisedAction(new object(), (ProposedActions)1000);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/AdvisoryBuilderTests.cs

@@ -19,29 +19,35 @@ public void advisoryBuilder_ctor()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void advisoryBuilder_ctor_null_visitor()
         {
-            var actual = new AdvisoryBuilder(null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var actual = new AdvisoryBuilder(null);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void advisoryBuilder_generateAdvisory_null_service_reference()
         {
-            var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
-            actual.GenerateAdvisory(null, null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
+                actual.GenerateAdvisory(null, null);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void advisoryBuilder_generateAdvisory_null_changeSet_reference()
         {
-            var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
-            actual.GenerateAdvisory(new ChangeTrackingService(), null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
+                actual.GenerateAdvisory(new ChangeTrackingService(), null);
+            });
         }
 
         [TestMethod]
@@ -213,25 +219,27 @@ public void advisoryBuilder_generateAdvisory_for_non_transient_and_deleted_entit
         }
 
         [TestMethod]
-        [ExpectedException(typeof(NotSupportedException))]
         [TestCategory("ChangeTracking")]
         public void advisoryBuilder_generateAdvisory_unsupported_proposedActions_value()
         {
-            var entity = new object();
-            var entityState = EntityTrackingStates.HasBackwardChanges;
+            Assert.ThrowsExactly<NotSupportedException>(() =>
+            {
+                var entity = new object();
+                var entityState = EntityTrackingStates.HasBackwardChanges;
 
-            var c1 = A.Fake<IChange>();
-            A.CallTo(() => c1.GetChangedEntities()).Returns(new object[] { entity });
-            A.CallTo(() => c1.GetAdvisedAction(entity)).Returns(ProposedActions.None);
+                var c1 = A.Fake<IChange>();
+                A.CallTo(() => c1.GetChangedEntities()).Returns(new object[] { entity });
+                A.CallTo(() => c1.GetAdvisedAction(entity)).Returns(ProposedActions.None);
 
-            var cSet = new ChangeSet(new IChange[] { c1 });
+                var cSet = new ChangeSet(new IChange[] { c1 });
 
-            var svc = A.Fake<IChangeTrackingService>();
-            A.CallTo(() => svc.GetEntityState(entity)).Returns(entityState);
-            A.CallTo(() => svc.GetEntities(EntityTrackingStates.IsTransient, true)).Returns(new object[0]);
+                var svc = A.Fake<IChangeTrackingService>();
+                A.CallTo(() => svc.GetEntityState(entity)).Returns(entityState);
+                A.CallTo(() => svc.GetEntities(EntityTrackingStates.IsTransient, true)).Returns(new object[0]);
 
-            var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
-            IAdvisory advisory = actual.GenerateAdvisory(svc, cSet);
+                var actual = new AdvisoryBuilder(new ChangeSetDistinctVisitor());
+                IAdvisory advisory = actual.GenerateAdvisory(svc, cSet);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/AdvisoryTests.cs

@@ -28,11 +28,13 @@ public void advisory_ctor()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void advisory_ctor_null_reference()
         {
-            var actual = new Advisory(null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var actual = new Advisory(null);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/BookmarkTests.cs

@@ -44,11 +44,13 @@ public class BookmarkTests
         //}
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void bookmark_null_owner__null_change_null_transientEntities_iChangeTrackingService_ctor_raise_argumentNullException_on_owner()
         {
-            Bookmark bmk = new Bookmark((IChangeTrackingService)null, (IChange)null, (IEnumerable<object>)null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                Bookmark bmk = new Bookmark((IChangeTrackingService)null, (IChange)null, (IEnumerable<object>)null);
+            });
         }
 
         //[TestMethod]

src/Radical.Tests/ChangeTracking/ChangeSetDistinctVisitorTest.cs

@@ -32,12 +32,14 @@ public void changeSetDistinctVisitor_visit()
         }
 
         [TestMethod()]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void changeSetDistinctVisitor_visit_null_changeSet_reference()
         {
-            ChangeSetDistinctVisitor target = new ChangeSetDistinctVisitor();
-            target.Visit(null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                ChangeSetDistinctVisitor target = new ChangeSetDistinctVisitor();
+                target.Visit(null);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/ChangeSetTests.cs

@@ -28,11 +28,13 @@ public void changeSet_ctor()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void changeSet_ctor_null_reference()
         {
-            var actual = new ChangeSet(null);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var actual = new ChangeSet(null);
+            });
         }
     }
 }

src/Radical.Tests/ChangeTracking/ChangeTest.cs

@@ -66,11 +66,13 @@ public void generic_iChange_null_commitCallback()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_ctor_null_owner_argumentNullException()
         {
-            var target = new ChangeMock<string>(null, "Foo", null, null, string.Empty);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var target = new ChangeMock<string>(null, "Foo", null, null, string.Empty);
+            });
         }
 
         [TestMethod]
@@ -115,43 +117,49 @@ public void generic_iChange_rejectCallback_is_invoked_with_expected_values()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_reject_invoked_with_invalid_rejectReason()
         {
-            var owner = new object();
-            var value = "Foo";
-            RejectCallback<string> rc = e => { };
-            CommitCallback<string> cc = null;
-            var description = string.Empty;
-            var reason = RejectReason.None;
-
-            var target = new ChangeMock<string>(owner, value, rc, cc, description);
-            target.Reject(reason);
+            Assert.ThrowsExactly<ArgumentException>(() =>
+            {
+                var owner = new object();
+                var value = "Foo";
+                RejectCallback<string> rc = e => { };
+                CommitCallback<string> cc = null;
+                var description = string.Empty;
+                var reason = RejectReason.None;
+
+                var target = new ChangeMock<string>(owner, value, rc, cc, description);
+                target.Reject(reason);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(EnumValueOutOfRangeException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_reject_invoked_with_outOfRange_rejectReason()
         {
-            var owner = new object();
-            var value = "Foo";
-            RejectCallback<string> rc = e => { };
-            CommitCallback<string> cc = null;
-            var description = string.Empty;
-            var reason = (RejectReason)1000;
-
-            var target = new ChangeMock<string>(owner, value, rc, cc, description);
-            target.Reject(reason);
+            Assert.ThrowsExactly<EnumValueOutOfRangeException>(() =>
+            {
+                var owner = new object();
+                var value = "Foo";
+                RejectCallback<string> rc = e => { };
+                CommitCallback<string> cc = null;
+                var description = string.Empty;
+                var reason = (RejectReason)1000;
+
+                var target = new ChangeMock<string>(owner, value, rc, cc, description);
+                target.Reject(reason);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_ctor_null_rejectCallback_argumentNullException()
         {
-            var target = new ChangeMock<string>(new object(), "Foo", null, null, string.Empty);
+            Assert.ThrowsExactly<ArgumentNullException>(() =>
+            {
+                var target = new ChangeMock<string>(new object(), "Foo", null, null, string.Empty);
+            });
         }
 
         [TestMethod]
@@ -197,35 +205,39 @@ public void generic_iChange_committed_fired()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_commit_invoked_with_invalid_rejectReason()
         {
-            var owner = new object();
-            var value = "Foo";
-            RejectCallback<string> rc = e => { };
-            CommitCallback<string> cc = e => { };
-            var description = string.Empty;
-            var reason = CommitReason.None;
-
-            var target = new ChangeMock<string>(owner, value, rc, cc, description);
-            target.Commit(reason);
+            Assert.ThrowsExactly<ArgumentException>(() =>
+            {
+                var owner = new object();
+                var value = "Foo";
+                RejectCallback<string> rc = e => { };
+                CommitCallback<string> cc = e => { };
+                var description = string.Empty;
+                var reason = CommitReason.None;
+
+                var target = new ChangeMock<string>(owner, value, rc, cc, description);
+                target.Commit(reason);
+            });
         }
 
         [TestMethod]
-        [ExpectedException(typeof(EnumValueOutOfRangeException))]
         [TestCategory("ChangeTracking")]
         public void generic_iChange_commit_invoked_with_outOfRange_rejectReason()
         {
-            var owner = new object();
-            var value = "Foo";
-            RejectCallback<string> rc = e => { };
-            CommitCallback<string> cc = e => { };
-            var description = string.Empty;
-            var reason = (CommitReason)1000;
-
-            var target = new ChangeMock<string>(owner, value, rc, cc, description);
-            target.Commit(reason);
+            Assert.ThrowsExactly<EnumValueOutOfRangeException>(() =>
+            {
+                var owner = new object();
+                var value = "Foo";
+                RejectCallback<string> rc = e => { };
+                CommitCallback<string> cc = e => { };
+                var description = string.Empty;
+                var reason = (CommitReason)1000;
+
+                var target = new ChangeMock<string>(owner, value, rc, cc, description);
+                target.Commit(reason);
+            });
         }
 
         [TestMethod]