Added comments to unit tests

Author: Sergio0694

UnitTests/UnitTests.Shared/Mvvm/Test_AsyncRelayCommand.cs

@@ -126,22 +126,33 @@ public async Task Test_AsyncRelayCommand_WithCancellation()
         {
             TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
 
+            // We need to test the cancellation support here, so we use the overload with an input
+            // parameter, which is a cancellation token. The token is the one that is internally managed
+            // by the AsyncRelayCommand instance, and canceled when using IAsyncRelayCommand.Cancel().
             var command = new AsyncRelayCommand(token => tcs.Task);
 
             List<PropertyChangedEventArgs> args = new List<PropertyChangedEventArgs>();
 
             command.PropertyChanged += (s, e) => args.Add(e);
 
+            // We have no canExecute parameter, so the command can always be invoked
             Assert.IsTrue(command.CanExecute(null));
             Assert.IsTrue(command.CanExecute(new object()));
 
+            // The command isn't running, so it can't be canceled yet
             Assert.IsFalse(command.CanBeCanceled);
             Assert.IsFalse(command.IsCancellationRequested);
 
+            // Start the command, which will return the token from our task completion source.
+            // We can use that to easily keep the command running while we do our tests, and then
+            // stop the processing by completing the source when we need (see below).
             command.Execute(null);
 
+            // The command is running, so it can be canceled, as we used the token overload
             Assert.IsTrue(command.CanBeCanceled);
             Assert.IsFalse(command.IsCancellationRequested);
+
+            // Validate the various event args for all the properties that were updated when executing the command
             Assert.AreEqual(args.Count, 4);
             Assert.AreEqual(args[0].PropertyName, nameof(IAsyncRelayCommand.IsCancellationRequested));
             Assert.AreEqual(args[1].PropertyName, nameof(IAsyncRelayCommand.ExecutionTask));
@@ -150,16 +161,21 @@ public async Task Test_AsyncRelayCommand_WithCancellation()
 
             command.Cancel();
 
+            // Verify that these two properties raised notifications correctly when canceling the command too.
+            // We need to ensure all command properties support notifications so that users can bind to them.
             Assert.AreEqual(args.Count, 6);
             Assert.AreEqual(args[4].PropertyName, nameof(IAsyncRelayCommand.IsCancellationRequested));
             Assert.AreEqual(args[5].PropertyName, nameof(IAsyncRelayCommand.CanBeCanceled));
 
             Assert.IsTrue(command.IsCancellationRequested);
 
+            // Complete the source, which will mark the command as completed too (as it returned the same task)
             tcs.SetResult(null);
 
             await command.ExecutionTask!;
 
+            // Verify that the command can no longer be canceled, and that the cancellation is
+            // instead still true, as that's reset when executing a command and not on completion.
             Assert.IsFalse(command.CanBeCanceled);
             Assert.IsTrue(command.IsCancellationRequested);
         }

UnitTests/UnitTests.Shared/Mvvm/Test_ObservableValidator.cs

@@ -27,6 +27,9 @@ public void Test_ObservableValidator_HasErrors()
 
             model.Name = "No";
 
+            // Verify that errors were correctly reported as changed, and that all the relevant
+            // properties were broadcast as well (both the changed property and HasErrors). We need
+            // this last one to raise notifications too so that users can bind to that in the UI.
             Assert.IsTrue(model.HasErrors);
             Assert.AreEqual(args.Count, 2);
             Assert.AreEqual(args[0].PropertyName, nameof(INotifyDataErrorInfo.HasErrors));