Improved test coverage

Author: Sergio0694

UnitTests/UnitTests.Shared/Mvvm/Test_AsyncRelayCommand{T}.cs

@@ -0,0 +1,141 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Microsoft.Toolkit.Mvvm.Input;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests.Mvvm
+{
+    [TestClass]
+    [SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1649", Justification = "Generic type")]
+    public class Test_AsyncRelayCommandOfT
+    {
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        public async Task Test_AsyncRelayCommandOfT_AlwaysEnabled()
+        {
+            int ticks = 0;
+
+            var command = new AsyncRelayCommand<string>(async s =>
+            {
+                await Task.Delay(1000);
+                ticks = int.Parse(s);
+                await Task.Delay(1000);
+            });
+
+            Assert.IsTrue(command.CanExecute(null));
+            Assert.IsTrue(command.CanExecute("1"));
+
+            (object, EventArgs) args = default;
+
+            command.CanExecuteChanged += (s, e) => args = (s, e);
+
+            command.NotifyCanExecuteChanged();
+
+            Assert.AreSame(args.Item1, command);
+            Assert.AreSame(args.Item2, EventArgs.Empty);
+
+            Assert.IsNull(command.ExecutionTask);
+            Assert.IsFalse(command.IsRunning);
+
+            Task task = command.ExecuteAsync((object)"42");
+
+            Assert.IsNotNull(command.ExecutionTask);
+            Assert.AreSame(command.ExecutionTask, task);
+            Assert.IsTrue(command.IsRunning);
+
+            await task;
+
+            Assert.IsFalse(command.IsRunning);
+
+            Assert.AreEqual(ticks, 42);
+
+            command.Execute("2");
+
+            await command.ExecutionTask!;
+
+            Assert.AreEqual(ticks, 2);
+
+            Assert.ThrowsException<InvalidCastException>(() => command.Execute(new object()));
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        public void Test_AsyncRelayCommandOfT_WithCanExecuteFunctionTrue()
+        {
+            int ticks = 0;
+
+            var command = new AsyncRelayCommand<string>(
+                s =>
+            {
+                ticks = int.Parse(s);
+                return Task.CompletedTask;
+            }, s => true);
+
+            Assert.IsTrue(command.CanExecute(null));
+            Assert.IsTrue(command.CanExecute("1"));
+
+            command.Execute("42");
+
+            Assert.AreEqual(ticks, 42);
+
+            command.Execute("2");
+
+            Assert.AreEqual(ticks, 2);
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        public void Test_AsyncRelayCommandOfT_WithCanExecuteFunctionFalse()
+        {
+            int ticks = 0;
+
+            var command = new AsyncRelayCommand<string>(
+                s =>
+            {
+                ticks = int.Parse(s);
+                return Task.CompletedTask;
+            }, s => false);
+
+            Assert.IsFalse(command.CanExecute(null));
+            Assert.IsFalse(command.CanExecute("1"));
+
+            command.Execute("2");
+
+            Assert.AreEqual(ticks, 0);
+
+            command.Execute("42");
+
+            Assert.AreEqual(ticks, 0);
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        public void Test_AsyncRelayCommandOfT_NullWithValueType()
+        {
+            int n = 0;
+
+            var command = new AsyncRelayCommand<int>(i =>
+            {
+                n = i;
+                return Task.CompletedTask;
+            });
+
+            // Special case for null value types
+            Assert.IsTrue(command.CanExecute(null));
+
+            command = new AsyncRelayCommand<int>(
+                i =>
+            {
+                n = i;
+                return Task.CompletedTask;
+            }, i => i > 0);
+
+            Assert.ThrowsException<NullReferenceException>(() => command.CanExecute(null));
+        }
+    }
+}

UnitTests/UnitTests.Shared/Mvvm/Test_Messenger.cs

@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Linq;
+using System.Reflection;
 using Microsoft.Toolkit.Mvvm.Messaging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -390,13 +392,134 @@ void Test()
             Assert.AreEqual(!isWeak, weakRecipient.IsAlive);
         }
 
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        [DataRow(typeof(Messenger))]
+        [DataRow(typeof(WeakRefMessenger))]
+        public void Test_Messenger_Reset(Type type)
+        {
+            var messenger = (IMessenger)Activator.CreateInstance(type);
+            var recipient = new RecipientWithSomeMessages();
+
+            messenger.RegisterAll(recipient);
+
+            Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));
+            Assert.IsTrue(messenger.IsRegistered<MessageB>(recipient));
+
+            messenger.Reset();
+
+            Assert.IsFalse(messenger.IsRegistered<MessageA>(recipient));
+            Assert.IsFalse(messenger.IsRegistered<MessageB>(recipient));
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        [DataRow(typeof(Messenger))]
+        [DataRow(typeof(WeakRefMessenger))]
+        public void Test_Messenger_Default(Type type)
+        {
+            PropertyInfo defaultInfo = type.GetProperty("Default");
+
+            var default1 = defaultInfo!.GetValue(null);
+            var default2 = defaultInfo!.GetValue(null);
+
+            Assert.IsNotNull(default1);
+            Assert.IsNotNull(default2);
+            Assert.AreSame(default1, default2);
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        [DataRow(typeof(Messenger))]
+        [DataRow(typeof(WeakRefMessenger))]
+        public void Test_Messenger_Cleanup(Type type)
+        {
+            var messenger = (IMessenger)Activator.CreateInstance(type);
+            var recipient = new RecipientWithSomeMessages();
+
+            messenger.Register<MessageA>(recipient);
+
+            Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));
+
+            void Test()
+            {
+                var recipient2 = new RecipientWithSomeMessages();
+
+                messenger.Register<MessageB>(recipient2);
+
+                Assert.IsTrue(messenger.IsRegistered<MessageB>(recipient2));
+
+                GC.KeepAlive(recipient2);
+            }
+
+            Test();
+
+            GC.Collect();
+
+            // Here we just check that calling Cleanup doesn't alter the state
+            // of the messenger. This method shouldn't really do anything visible
+            // to consumers, it's just a way for messengers to compact their data.
+            messenger.Cleanup();
+
+            Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));
+        }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        [DataRow(typeof(Messenger))]
+        [DataRow(typeof(WeakRefMessenger))]
+        public void Test_Messenger_ManyRecipients(Type type)
+        {
+            var messenger = (IMessenger)Activator.CreateInstance(type);
+
+            void Test()
+            {
+                var recipients = Enumerable.Range(0, 512).Select(_ => new RecipientWithSomeMessages()).ToArray();
+
+                foreach (var recipient in recipients)
+                {
+                    messenger.RegisterAll(recipient);
+                }
+
+                foreach (var recipient in recipients)
+                {
+                    Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));
+                    Assert.IsTrue(messenger.IsRegistered<MessageB>(recipient));
+                }
+
+                messenger.Send<MessageA>();
+                messenger.Send<MessageB>();
+                messenger.Send<MessageB>();
+
+                foreach (var recipient in recipients)
+                {
+                    Assert.AreEqual(recipient.As, 1);
+                    Assert.AreEqual(recipient.Bs, 2);
+                }
+
+                foreach (ref var recipient in recipients.AsSpan())
+                {
+                    recipient = null;
+                }
+            }
+
+            Test();
+
+            GC.Collect();
+
+            // Just invoke a final cleanup to improve coverage, this is unrelated to this test in particular
+            messenger.Cleanup();
+        }
+
         public sealed class RecipientWithNoMessages
         {
             public int Number { get; set; }
         }
 
-        public sealed class RecipientWithSomeMessages
-             : IRecipient<MessageA>, ICloneable, IRecipient<MessageB>
+        public sealed class RecipientWithSomeMessages :
+            IRecipient<MessageA>,
+            IRecipient<MessageB>,
+            ICloneable
         {
             public int As { get; private set; }
 

UnitTests/UnitTests.Shared/Mvvm/Test_RelayCommand{T}.cs

@@ -35,7 +35,7 @@ public void Test_RelayCommandOfT_AlwaysEnabled()
             Assert.AreSame(args.Item1, command);
             Assert.AreSame(args.Item2, EventArgs.Empty);
 
-            command.Execute("Hello");
+            command.Execute((object)"Hello");
 
             Assert.AreEqual(text, "Hello");
 
@@ -57,13 +57,29 @@ public void Test_RelayCommand_WithCanExecuteFunction()
 
             Assert.ThrowsException<InvalidCastException>(() => command.CanExecute(new object()));
 
-            command.Execute("Hello");
+            command.Execute((object)"Hello");
 
             Assert.AreEqual(text, "Hello");
 
             command.Execute(null);
 
             Assert.AreEqual(text, "Hello");
         }
+
+        [TestCategory("Mvvm")]
+        [TestMethod]
+        public void Test_RelayCommand_NullWithValueType()
+        {
+            int n = 0;
+
+            var command = new RelayCommand<int>(i => n = i);
+
+            // Special case for null value types
+            Assert.IsTrue(command.CanExecute(null));
+
+            command = new RelayCommand<int>(i => n = i, i => i > 0);
+
+            Assert.ThrowsException<NullReferenceException>(() => command.CanExecute(null));
+        }
     }
 }

UnitTests/UnitTests.Shared/UnitTests.Shared.projitems

@@ -23,6 +23,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_TypeExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ValueTypeExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Mvvm\Test_AsyncRelayCommand{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mvvm\Test_Ioc.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mvvm\Test_Messenger.Request.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mvvm\Test_Messenger.cs" />