Minor bug fixes, add more unit tests

Author: Sergio0694

CommunityToolkit.Mvvm/Input/AsyncRelayCommand.cs

@@ -292,8 +292,6 @@ public Task ExecuteAsync(object? parameter)
 
                 CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
 
-                PropertyChanged?.Invoke(this, IsCancellationRequestedChangedEventArgs);
-
                 // Invoke the cancelable command delegate with a new linked token
                 executionTask = ExecutionTask = this.cancelableExecute!(cancellationTokenSource.Token);
             }

CommunityToolkit.Mvvm/Input/AsyncRelayCommand{T}.cs

@@ -295,8 +295,6 @@ public Task ExecuteAsync(T? parameter)
 
                 CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
 
-                PropertyChanged?.Invoke(this, AsyncRelayCommand.IsCancellationRequestedChangedEventArgs);
-
                 // Invoke the cancelable command delegate with a new linked token
                 executionTask = ExecutionTask = this.cancelableExecute!(parameter, cancellationTokenSource.Token);
             }

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand{T}.cs

@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
+using System.ComponentModel;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.Input;
 using CommunityToolkit.Mvvm.UnitTests.Helpers;
@@ -134,6 +136,50 @@ public void Test_AsyncRelayCommandOfT_NullWithValueType()
         _ = Assert.ThrowsException<NullReferenceException>(() => command.Execute(null));
     }
 
+    [TestMethod]
+    public async Task Test_AsyncRelayCommandOfT_WithCancellation()
+    {
+        // See comments in Test_AsyncRelayCommand_WithCancellation for the logic below
+        TaskCompletionSource<object?> tcs = new();
+        AsyncRelayCommand<string> command = new((s, token) => tcs.Task);
+
+        List<PropertyChangedEventArgs> args = new();
+
+        command.PropertyChanged += (s, e) => args.Add(e);
+
+        Assert.IsTrue(command.CanExecute(null));
+        Assert.IsTrue(command.CanExecute("Hello"));
+
+        Assert.IsFalse(command.CanBeCanceled);
+        Assert.IsFalse(command.IsCancellationRequested);
+
+        command.Execute(null);
+
+        Assert.IsTrue(command.CanBeCanceled);
+        Assert.IsFalse(command.IsCancellationRequested);
+
+        Assert.AreEqual(args.Count, 4);
+        Assert.AreEqual(args[0].PropertyName, nameof(IAsyncRelayCommand.ExecutionTask));
+        Assert.AreEqual(args[1].PropertyName, nameof(IAsyncRelayCommand.IsRunning));
+        Assert.AreEqual(args[2].PropertyName, nameof(IAsyncRelayCommand.CanBeCanceled));
+        Assert.AreEqual(args[3].PropertyName, nameof(IAsyncRelayCommand.IsCancellationRequested));
+
+        command.Cancel();
+
+        Assert.AreEqual(args.Count, 6);
+        Assert.AreEqual(args[4].PropertyName, nameof(IAsyncRelayCommand.CanBeCanceled));
+        Assert.AreEqual(args[5].PropertyName, nameof(IAsyncRelayCommand.IsCancellationRequested));
+
+        Assert.IsTrue(command.IsCancellationRequested);
+
+        tcs.SetResult(null);
+
+        await command.ExecutionTask!;
+
+        Assert.IsFalse(command.CanBeCanceled);
+        Assert.IsTrue(command.IsCancellationRequested);
+    }
+
     [TestMethod]
     public async Task Test_AsyncRelayCommandOfT_AllowConcurrentExecutions_Disabled()
     {