Don't use '[ExpectedException]' in MVVM tests

Sergio0694 · Sergio0694 · commit b3f11944168f · 2025-11-07T12:18:48.000-08:00
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroup.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroup.cs
@@ -118,39 +118,34 @@ public void Test_ObservableGroup_IReadOnlyObservableGroup_ShouldReturnExpectedVa
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroup_Ctor_NullKey()
     {
-        _ = new ObservableGroup<string, int>((string)null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>((string)null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroup_Ctor_NullGroup()
     {
-        _ = new ObservableGroup<string, int>((IGrouping<string, int>)null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>((IGrouping<string, int>)null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroup_Ctor_NullKeyWithNotNullElements()
     {
-        _ = new ObservableGroup<string, int>(null!, new int[0]);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>(null!, []));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroup_Ctor_NotNullKeyWithNullElements()
     {
-        _ = new ObservableGroup<string, int>("A", null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>("A", null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroup_Ctor_NullKeySetter()
     {
         ObservableGroup<string, int> group = new("A");
 
-        group.Key = null!;
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => group.Key = null!);
     }
 }
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroupedCollection.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroupedCollection.cs
@@ -41,9 +41,8 @@ public void Test_ObservableGroupedCollection_Ctor_WithGroups_ShouldHaveExpectedV
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ObservableGroupedCollection_Ctor_NullCollection()
     {
-        _ = new ObservableGroupedCollection<string, int>(null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroupedCollection<string, int>(null!));
     }
 }
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroupedCollectionExtensions.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ObservableGroupedCollectionExtensions.cs
@@ -29,14 +29,13 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup
     }
 
     [TestMethod]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupDoesNotExist_ShouldThrow()
     {
         ObservableGroupedCollection<string, int> groupedCollection = new();
 
         _ = groupedCollection.AddGroup("A", new[] { 23 });
 
-        _ = groupedCollection.FirstGroupByKey("I do not exist");
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() => _ = groupedCollection.FirstGroupByKey("I do not exist"));
     }
 
     [TestMethod]
@@ -84,7 +83,6 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup
     [TestMethod]
     [DataRow(-1)]
     [DataRow(3)]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExistsAndIndexOutOfRange_ShouldReturnThrow(int index)
     {
         ObservableGroupedCollection<string, int> groupedCollection = new();
@@ -93,7 +91,7 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup
         _ = groupedCollection.AddGroup("B", new[] { 10, 11, 12 });
         _ = groupedCollection.AddGroup("B", new[] { 42 });
 
-        _ = groupedCollection.FirstGroupByKey("B")[index];
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = groupedCollection.FirstGroupByKey("B")[index]);
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ReadOnlyObservableGroup.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ReadOnlyObservableGroup.cs
@@ -131,23 +131,20 @@ public void Test_ReadOnlyObservableGroup_IReadOnlyObservableGroup_ShouldReturnEx
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ReadOnlyObservableGroup_Ctor_NullKeyWithNotNullElements()
     {
-        _ = new ReadOnlyObservableGroup<string, int>(null!, new ObservableCollection<int>());
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>(null!, new ObservableCollection<int>()));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ReadOnlyObservableGroup_Ctor_NotNullKeyWithNullElements()
     {
-        _ = new ReadOnlyObservableGroup<string, int>("A", null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>("A", null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ReadOnlyObservableGroup_Ctor_NullGroup()
     {
-        _ = new ReadOnlyObservableGroup<string, int>(null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>(null!));
     }
 }
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ReadOnlyObservableGroupedCollection.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Collections/Test_ReadOnlyObservableGroupedCollection.cs
@@ -470,16 +470,14 @@ private static bool IsReplaceEventValid(NotifyCollectionChangedEventArgs args, I
     private static bool IsResetEventValid(NotifyCollectionChangedEventArgs args) => args.Action == NotifyCollectionChangedAction.Reset && args.NewItems == null && args.OldItems == null;
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ReadOnlyObservableGroupedCollection_Ctor_NullCollectionWithObservableGroups()
     {
-        _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ObservableGroup<string, int>>)null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ObservableGroup<string, int>>)null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_ReadOnlyObservableGroupedCollection_Ctor_NullCollectionWithReadOnlyObservableGroups()
     {
-        _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ReadOnlyObservableGroup<string, int>>)null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ReadOnlyObservableGroup<string, int>>)null!));
     }
 }
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Test_Messenger.Observables.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Test_Messenger.Observables.cs
@@ -80,23 +80,20 @@ public void Test_Messenger_CreateObservable_WithToken(Type type)
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_Messenger_CreateObservable_NullMessenger()
     {
-        _ = IMessengerExtensions.CreateObservable<MessageA>(null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA>(null!));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_Messenger_CreateObservable_WithToken_NullMessenger()
     {
-        _ = IMessengerExtensions.CreateObservable<MessageA, string>(null!, "Hello");
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA, string>(null!, "Hello"));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
     public void Test_Messenger_CreateObservable_WithToken_NullToken()
     {
-        _ = IMessengerExtensions.CreateObservable<MessageA, string>(new WeakReferenceMessenger(), null!);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA, string>(new WeakReferenceMessenger(), null!));
     }
 }
diff --git a/tests/CommunityToolkit.Mvvm.UnitTests/Test_Messenger.Request.cs b/tests/CommunityToolkit.Mvvm.UnitTests/Test_Messenger.Request.cs
@@ -45,7 +45,6 @@ void Receive(object recipient, NumberRequestMessage m)
     [TestMethod]
     [DataRow(typeof(StrongReferenceMessenger))]
     [DataRow(typeof(WeakReferenceMessenger))]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_Messenger_RequestMessage_Fail_NoReply(Type type)
     {
         IMessenger? messenger = (IMessenger)Activator.CreateInstance(type)!;
@@ -54,13 +53,12 @@ public void Test_Messenger_RequestMessage_Fail_NoReply(Type type)
 
         Assert.IsFalse(message.HasReceivedResponse);
 
-        _ = message.Response;
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() => _ = message.Response);
     }
 
     [TestMethod]
     [DataRow(typeof(StrongReferenceMessenger))]
     [DataRow(typeof(WeakReferenceMessenger))]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_Messenger_RequestMessage_Fail_MultipleReplies(Type type)
     {
         IMessenger? messenger = (IMessenger)Activator.CreateInstance(type)!;
@@ -74,7 +72,7 @@ static void Receive(object recipient, NumberRequestMessage m)
 
         messenger.Register<NumberRequestMessage>(recipient, Receive);
 
-        int result = messenger.Send<NumberRequestMessage>();
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() => _ = messenger.Send<NumberRequestMessage>());
 
         GC.KeepAlive(recipient);
     }
@@ -145,7 +143,6 @@ void Receive(object recipient, AsyncNumberRequestMessage m)
     [TestMethod]
     [DataRow(typeof(StrongReferenceMessenger))]
     [DataRow(typeof(WeakReferenceMessenger))]
-    [ExpectedException(typeof(InvalidOperationException))]
     public async Task Test_Messenger_AsyncRequestMessage_Fail_NoReply(Type type)
     {
         IMessenger? messenger = (IMessenger)Activator.CreateInstance(type)!;
@@ -154,13 +151,12 @@ public async Task Test_Messenger_AsyncRequestMessage_Fail_NoReply(Type type)
 
         Assert.IsFalse(message.HasReceivedResponse);
 
-        _ = await message.Response;
+        _ = await Assert.ThrowsExactlyAsync<InvalidOperationException>(async () => _ = await message.Response);
     }
 
     [TestMethod]
     [DataRow(typeof(StrongReferenceMessenger))]
     [DataRow(typeof(WeakReferenceMessenger))]
-    [ExpectedException(typeof(InvalidOperationException))]
     public async Task Test_Messenger_AsyncRequestMessage_Fail_MultipleReplies(Type type)
     {
         IMessenger? messenger = (IMessenger)Activator.CreateInstance(type)!;
@@ -174,9 +170,12 @@ static void Receive(object recipient, AsyncNumberRequestMessage m)
 
         messenger.Register<AsyncNumberRequestMessage>(recipient, Receive);
 
-        int result = await messenger.Send<AsyncNumberRequestMessage>();
+        _ = Assert.ThrowsExactly<InvalidOperationException>(async () =>
+        {
+            _ = await messenger.Send<AsyncNumberRequestMessage>();
 
-        GC.KeepAlive(recipient);
+            GC.KeepAlive(recipient);
+        });
     }
 
     public class AsyncNumberRequestMessage : AsyncRequestMessage<int>

Original file line number	Diff line number	Diff line change
`@@ -118,39 +118,34 @@ public void Test_ObservableGroup_IReadOnlyObservableGroup_ShouldReturnExpectedVa`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`[TestMethod]`
`121`		`- [ExpectedException(typeof(ArgumentNullException))]`
`122`	`121`	`public void Test_ObservableGroup_Ctor_NullKey()`
`123`	`122`	`{`
`124`		`- _ = new ObservableGroup<string, int>((string)null!);`
	`123`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>((string)null!));`
`125`	`124`	`}`
`126`	`125`
`127`	`126`	`[TestMethod]`
`128`		`- [ExpectedException(typeof(ArgumentNullException))]`
`129`	`127`	`public void Test_ObservableGroup_Ctor_NullGroup()`
`130`	`128`	`{`
`131`		`- _ = new ObservableGroup<string, int>((IGrouping<string, int>)null!);`
	`129`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>((IGrouping<string, int>)null!));`
`132`	`130`	`}`
`133`	`131`
`134`	`132`	`[TestMethod]`
`135`		`- [ExpectedException(typeof(ArgumentNullException))]`
`136`	`133`	`public void Test_ObservableGroup_Ctor_NullKeyWithNotNullElements()`
`137`	`134`	`{`
`138`		`- _ = new ObservableGroup<string, int>(null!, new int[0]);`
	`135`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>(null!, []));`
`139`	`136`	`}`
`140`	`137`
`141`	`138`	`[TestMethod]`
`142`		`- [ExpectedException(typeof(ArgumentNullException))]`
`143`	`139`	`public void Test_ObservableGroup_Ctor_NotNullKeyWithNullElements()`
`144`	`140`	`{`
`145`		`- _ = new ObservableGroup<string, int>("A", null!);`
	`141`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroup<string, int>("A", null!));`
`146`	`142`	`}`
`147`	`143`
`148`	`144`	`[TestMethod]`
`149`		`- [ExpectedException(typeof(ArgumentNullException))]`
`150`	`145`	`public void Test_ObservableGroup_Ctor_NullKeySetter()`
`151`	`146`	`{`
`152`	`147`	`ObservableGroup<string, int> group = new("A");`
`153`	`148`
`154`		`- group.Key = null!;`
	`149`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => group.Key = null!);`
`155`	`150`	`}`
`156`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,8 @@ public void Test_ObservableGroupedCollection_Ctor_WithGroups_ShouldHaveExpectedV`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[TestMethod]`
`44`		`- [ExpectedException(typeof(ArgumentNullException))]`
`45`	`44`	`public void Test_ObservableGroupedCollection_Ctor_NullCollection()`
`46`	`45`	`{`
`47`		`- _ = new ObservableGroupedCollection<string, int>(null!);`
	`46`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ObservableGroupedCollection<string, int>(null!));`
`48`	`47`	`}`
`49`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,14 +29,13 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`[TestMethod]`
`32`		`- [ExpectedException(typeof(InvalidOperationException))]`
`33`	`32`	`public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupDoesNotExist_ShouldThrow()`
`34`	`33`	`{`
`35`	`34`	`ObservableGroupedCollection<string, int> groupedCollection = new();`
`36`	`35`
`37`	`36`	`_ = groupedCollection.AddGroup("A", new[] { 23 });`
`38`	`37`
`39`		`- _ = groupedCollection.FirstGroupByKey("I do not exist");`
	`38`	`+ _ = Assert.ThrowsExactly<InvalidOperationException>(() => _ = groupedCollection.FirstGroupByKey("I do not exist"));`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`[TestMethod]`
`@@ -84,7 +83,6 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup`
`84`	`83`	`[TestMethod]`
`85`	`84`	`[DataRow(-1)]`
`86`	`85`	`[DataRow(3)]`
`87`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`88`	`86`	`public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExistsAndIndexOutOfRange_ShouldReturnThrow(int index)`
`89`	`87`	`{`
`90`	`88`	`ObservableGroupedCollection<string, int> groupedCollection = new();`
`@@ -93,7 +91,7 @@ public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroup`
`93`	`91`	`_ = groupedCollection.AddGroup("B", new[] { 10, 11, 12 });`
`94`	`92`	`_ = groupedCollection.AddGroup("B", new[] { 42 });`
`95`	`93`
`96`		`- _ = groupedCollection.FirstGroupByKey("B")[index];`
	`94`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = groupedCollection.FirstGroupByKey("B")[index]);`
`97`	`95`	`}`
`98`	`96`
`99`	`97`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -131,23 +131,20 @@ public void Test_ReadOnlyObservableGroup_IReadOnlyObservableGroup_ShouldReturnEx`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`[TestMethod]`
`134`		`- [ExpectedException(typeof(ArgumentNullException))]`
`135`	`134`	`public void Test_ReadOnlyObservableGroup_Ctor_NullKeyWithNotNullElements()`
`136`	`135`	`{`
`137`		`- _ = new ReadOnlyObservableGroup<string, int>(null!, new ObservableCollection<int>());`
	`136`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>(null!, new ObservableCollection<int>()));`
`138`	`137`	`}`
`139`	`138`
`140`	`139`	`[TestMethod]`
`141`		`- [ExpectedException(typeof(ArgumentNullException))]`
`142`	`140`	`public void Test_ReadOnlyObservableGroup_Ctor_NotNullKeyWithNullElements()`
`143`	`141`	`{`
`144`		`- _ = new ReadOnlyObservableGroup<string, int>("A", null!);`
	`142`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>("A", null!));`
`145`	`143`	`}`
`146`	`144`
`147`	`145`	`[TestMethod]`
`148`		`- [ExpectedException(typeof(ArgumentNullException))]`
`149`	`146`	`public void Test_ReadOnlyObservableGroup_Ctor_NullGroup()`
`150`	`147`	`{`
`151`		`- _ = new ReadOnlyObservableGroup<string, int>(null!);`
	`148`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroup<string, int>(null!));`
`152`	`149`	`}`
`153`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -470,16 +470,14 @@ private static bool IsReplaceEventValid(NotifyCollectionChangedEventArgs args, I`
`470`	`470`	`private static bool IsResetEventValid(NotifyCollectionChangedEventArgs args) => args.Action == NotifyCollectionChangedAction.Reset && args.NewItems == null && args.OldItems == null;`
`471`	`471`
`472`	`472`	`[TestMethod]`
`473`		`- [ExpectedException(typeof(ArgumentNullException))]`
`474`	`473`	`public void Test_ReadOnlyObservableGroupedCollection_Ctor_NullCollectionWithObservableGroups()`
`475`	`474`	`{`
`476`		`- _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ObservableGroup<string, int>>)null!);`
	`475`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ObservableGroup<string, int>>)null!));`
`477`	`476`	`}`
`478`	`477`
`479`	`478`	`[TestMethod]`
`480`		`- [ExpectedException(typeof(ArgumentNullException))]`
`481`	`479`	`public void Test_ReadOnlyObservableGroupedCollection_Ctor_NullCollectionWithReadOnlyObservableGroups()`
`482`	`480`	`{`
`483`		`- _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ReadOnlyObservableGroup<string, int>>)null!);`
	`481`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new ReadOnlyObservableGroupedCollection<string, int>((ObservableCollection<ReadOnlyObservableGroup<string, int>>)null!));`
`484`	`482`	`}`
`485`	`483`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,23 +80,20 @@ public void Test_Messenger_CreateObservable_WithToken(Type type)`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`[TestMethod]`
`83`		`- [ExpectedException(typeof(ArgumentNullException))]`
`84`	`83`	`public void Test_Messenger_CreateObservable_NullMessenger()`
`85`	`84`	`{`
`86`		`- _ = IMessengerExtensions.CreateObservable<MessageA>(null!);`
	`85`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA>(null!));`
`87`	`86`	`}`
`88`	`87`
`89`	`88`	`[TestMethod]`
`90`		`- [ExpectedException(typeof(ArgumentNullException))]`
`91`	`89`	`public void Test_Messenger_CreateObservable_WithToken_NullMessenger()`
`92`	`90`	`{`
`93`		`- _ = IMessengerExtensions.CreateObservable<MessageA, string>(null!, "Hello");`
	`91`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA, string>(null!, "Hello"));`
`94`	`92`	`}`
`95`	`93`
`96`	`94`	`[TestMethod]`
`97`		`- [ExpectedException(typeof(ArgumentNullException))]`
`98`	`95`	`public void Test_Messenger_CreateObservable_WithToken_NullToken()`
`99`	`96`	`{`
`100`		`- _ = IMessengerExtensions.CreateObservable<MessageA, string>(new WeakReferenceMessenger(), null!);`
	`97`	`+ _ = Assert.ThrowsExactly<ArgumentNullException>(() => _ = IMessengerExtensions.CreateObservable<MessageA, string>(new WeakReferenceMessenger(), null!));`
`101`	`98`	`}`
`102`	`99`	`}`