1043 lines
31 KiB
C#
1043 lines
31 KiB
C#
// 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.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Input;
|
|
using CommunityToolkit.Mvvm.ComponentModel;
|
|
using CommunityToolkit.Mvvm.Input;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
namespace CommunityToolkit.Mvvm.UnitTests;
|
|
|
|
[TestClass]
|
|
public partial class Test_RelayCommandAttribute
|
|
{
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_RelayCommand()
|
|
{
|
|
MyViewModel model = new();
|
|
|
|
model.IncrementCounterCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.IncrementCounterWithValueCommand.Execute(5);
|
|
|
|
Assert.AreEqual(model.Counter, 6);
|
|
|
|
await model.DelayAndIncrementCounterCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 7);
|
|
|
|
await model.DelayAndIncrementCounterWithTokenCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 8);
|
|
|
|
await model.DelayAndIncrementCounterWithValueCommand.ExecuteAsync(5);
|
|
|
|
Assert.AreEqual(model.Counter, 13);
|
|
|
|
await model.DelayAndIncrementCounterWithValueAndTokenCommand.ExecuteAsync(5);
|
|
|
|
Assert.AreEqual(model.Counter, 18);
|
|
|
|
List<Task> tasks = new();
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
if (model.AddValueToListAndDelayCommand.CanExecute(i))
|
|
{
|
|
tasks.Add(model.AddValueToListAndDelayCommand.ExecuteAsync(i));
|
|
}
|
|
}
|
|
|
|
// All values should already be in the list, as commands are executed
|
|
// concurrently. Each invocation should still be pending here, but the
|
|
// values are added to the list before starting the delay.
|
|
CollectionAssert.AreEqual(model.Values, Enumerable.Range(0, 10).ToArray());
|
|
|
|
await Task.WhenAll(tasks);
|
|
|
|
model.Values.Clear();
|
|
tasks.Clear();
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
if (model.AddValueToListAndDelayWithDefaultConcurrencyCommand.CanExecute(i))
|
|
{
|
|
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyCommand.ExecuteAsync(i));
|
|
}
|
|
}
|
|
|
|
model.Tcs.SetResult(null);
|
|
|
|
await Task.WhenAll(tasks);
|
|
|
|
Assert.AreEqual(1, tasks.Count);
|
|
|
|
// Only the first item should have been added
|
|
CollectionAssert.AreEqual(model.Values, new[] { 0 });
|
|
|
|
model.ResetTcs();
|
|
model.Values.Clear();
|
|
tasks.Clear();
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
// Ignore the checks
|
|
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyCommand.ExecuteAsync(i));
|
|
}
|
|
|
|
model.Tcs.SetResult(null);
|
|
|
|
await Task.WhenAll(tasks);
|
|
|
|
Assert.AreEqual(10, tasks.Count);
|
|
|
|
CollectionAssert.AreEqual(model.Values, Enumerable.Range(0, 10).ToArray());
|
|
|
|
model.Values.Clear();
|
|
tasks.Clear();
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
if (model.AddValueToListAndDelayWithDefaultConcurrencyAsync_WithCancelCommandCommand.CanExecute(i))
|
|
{
|
|
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyAsync_WithCancelCommandCommand.ExecuteAsync(i));
|
|
}
|
|
}
|
|
|
|
Assert.AreEqual(1, tasks.Count);
|
|
|
|
// Same as above, only the first one is added
|
|
CollectionAssert.AreEqual(model.Values, new[] { 0 });
|
|
|
|
model.Values.Clear();
|
|
tasks.Clear();
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
// Ignore the checks
|
|
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyAsync_WithCancelCommandCommand.ExecuteAsync(i));
|
|
}
|
|
|
|
Assert.AreEqual(10, tasks.Count);
|
|
|
|
CollectionAssert.AreEqual(model.Values, Enumerable.Range(0, 10).ToArray());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_NoParameters_Property()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
model.IncrementCounter_NoParameters_PropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_NoParameters_PropertyCommand.CanExecute(null));
|
|
|
|
// This and all test above also verify the logic is unconditionally invoked if CanExecute is ignored
|
|
model.IncrementCounter_NoParameters_PropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_NoParameters_GeneratedProperty()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.SetGeneratedFlag(true);
|
|
|
|
model.IncrementCounter_NoParameters_GeneratedPropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.SetGeneratedFlag(false);
|
|
|
|
Assert.IsFalse(model.IncrementCounter_NoParameters_GeneratedPropertyCommand.CanExecute(null));
|
|
|
|
model.IncrementCounter_NoParameters_GeneratedPropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_WithParameter_Property()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
model.IncrementCounter_WithParameter_PropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_WithParameter_PropertyCommand.CanExecute(null));
|
|
|
|
model.IncrementCounter_WithParameter_PropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_WithParameter_GeneratedProperty()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.SetGeneratedFlag(true);
|
|
|
|
model.IncrementCounter_WithParameter_GeneratedPropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.SetGeneratedFlag(false);
|
|
|
|
Assert.IsFalse(model.IncrementCounter_WithParameter_GeneratedPropertyCommand.CanExecute(null));
|
|
|
|
model.IncrementCounter_WithParameter_GeneratedPropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_NoParameters_MethodWithNoParameters()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
model.IncrementCounter_NoParameters_MethodWithNoParametersCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_WithParameter_PropertyCommand.CanExecute(null));
|
|
|
|
model.IncrementCounter_WithParameter_PropertyCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_WithParameters_MethodWithNoParameters()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
model.IncrementCounter_WithParameters_MethodWithNoParametersCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_WithParameters_MethodWithNoParametersCommand.CanExecute(null));
|
|
|
|
model.IncrementCounter_WithParameters_MethodWithNoParametersCommand.Execute(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecute_WithParameters_MethodWithMatchingParameter()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.Execute(new User { Name = nameof(CanExecuteViewModel) });
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
Assert.IsFalse(model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.CanExecute(new User()));
|
|
|
|
model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.Execute(new User());
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CanExecute_Async_NoParameters_Property()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
await model.IncrementCounter_Async_NoParameters_PropertyCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_Async_NoParameters_PropertyCommand.CanExecute(null));
|
|
|
|
await model.IncrementCounter_Async_NoParameters_PropertyCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CanExecute_Async_WithParameter_Property()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
await model.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_Async_WithParameter_PropertyCommand.CanExecute(null));
|
|
|
|
await model.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CanExecute_Async_NoParameters_MethodWithNoParameters()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
await model.IncrementCounter_Async_NoParameters_MethodWithNoParametersCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_Async_WithParameter_PropertyCommand.CanExecute(null));
|
|
|
|
await model.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CanExecute_Async_WithParameters_MethodWithNoParameters()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
model.Flag = true;
|
|
|
|
await model.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
model.Flag = false;
|
|
|
|
Assert.IsFalse(model.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.CanExecute(null));
|
|
|
|
await model.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.ExecuteAsync(null);
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CanExecute_Async_WithParameters_MethodWithMatchingParameter()
|
|
{
|
|
CanExecuteViewModel model = new();
|
|
|
|
await model.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.ExecuteAsync(new User { Name = nameof(CanExecuteViewModel) });
|
|
|
|
Assert.AreEqual(model.Counter, 1);
|
|
|
|
Assert.IsFalse(model.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.CanExecute(new User()));
|
|
|
|
await model.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.ExecuteAsync(new User());
|
|
|
|
Assert.AreEqual(model.Counter, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_ConcurrencyControl_AsyncRelayCommand()
|
|
{
|
|
TaskCompletionSource<object?> tcs = new();
|
|
|
|
MyViewModel model = new() { ExternalTask = tcs.Task };
|
|
|
|
Task task = model.AwaitForExternalTaskCommand.ExecuteAsync(null);
|
|
|
|
Assert.IsTrue(model.AwaitForExternalTaskCommand.IsRunning);
|
|
Assert.IsFalse(model.AwaitForExternalTaskCommand.CanExecute(null));
|
|
|
|
tcs.SetResult(null);
|
|
|
|
await task;
|
|
|
|
Assert.IsFalse(model.AwaitForExternalTaskCommand.IsRunning);
|
|
Assert.IsTrue(model.AwaitForExternalTaskCommand.CanExecute(null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_ConcurrencyControl_AsyncRelayCommandOfT()
|
|
{
|
|
MyViewModel model = new();
|
|
|
|
TaskCompletionSource<object?> tcs = new();
|
|
|
|
Task task = model.AwaitForInputTaskCommand.ExecuteAsync(tcs.Task);
|
|
|
|
Assert.IsTrue(model.AwaitForInputTaskCommand.IsRunning);
|
|
Assert.IsFalse(model.AwaitForInputTaskCommand.CanExecute(null));
|
|
|
|
tcs.SetResult(null);
|
|
|
|
await task;
|
|
|
|
Assert.IsFalse(model.AwaitForInputTaskCommand.IsRunning);
|
|
Assert.IsTrue(model.AwaitForInputTaskCommand.CanExecute(null));
|
|
}
|
|
|
|
// See https://github.com/CommunityToolkit/dotnet/issues/13
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_ViewModelRightAfterRegion()
|
|
{
|
|
ViewModelForIssue13 model = new();
|
|
|
|
Assert.IsNotNull(model.GreetCommand);
|
|
Assert.IsInstanceOfType((object)model.GreetCommand, typeof(RelayCommand));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_CancelCommands()
|
|
{
|
|
CancelCommandViewModel model = new();
|
|
|
|
model.DoWorkCommand.Execute(null);
|
|
|
|
Assert.IsTrue(model.DoWorkCancelCommand.CanExecute(null));
|
|
|
|
model.DoWorkCancelCommand.Execute(null);
|
|
|
|
await Task.Yield();
|
|
|
|
Assert.IsTrue(model.Tcs1.Task.IsCanceled);
|
|
Assert.IsTrue(model.Result1 is OperationCanceledException);
|
|
|
|
model.DoWorkWithParameterCommand.Execute(42);
|
|
|
|
Assert.IsTrue(model.DoWorkWithParameterCancelCommand.CanExecute(null));
|
|
|
|
model.DoWorkWithParameterCancelCommand.Execute(null);
|
|
|
|
await Task.Yield();
|
|
|
|
Assert.IsTrue(model.Tcs2.Task.IsCanceled);
|
|
Assert.IsTrue(model.Result2 is OperationCanceledException);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_TaskOfTReturns()
|
|
{
|
|
GenericTaskCommands model = new();
|
|
|
|
Task greetCommandTask = model.GreetCommand.ExecuteAsync(null);
|
|
Task greetWithTokenTask = model.GreetWithTokenCommand.ExecuteAsync(null);
|
|
Task greetWithParamTask = model.GreetWithParamCommand.ExecuteAsync(null);
|
|
Task greetWithParamAndCommandTask = model.GreetWithParamAndTokenCommand.ExecuteAsync(null);
|
|
|
|
Assert.IsInstanceOfType(greetCommandTask, typeof(Task<string>));
|
|
Assert.IsInstanceOfType(greetWithTokenTask, typeof(Task<string>));
|
|
Assert.IsInstanceOfType(greetWithParamTask, typeof(Task<string>));
|
|
Assert.IsInstanceOfType(greetWithParamAndCommandTask, typeof(Task<string>));
|
|
|
|
Assert.AreEqual("Hello world", await (Task<string>)greetCommandTask);
|
|
Assert.AreEqual("Hello world", await (Task<string>)greetWithTokenTask);
|
|
Assert.AreEqual("Hello world", await (Task<string>)greetWithParamTask);
|
|
Assert.AreEqual("Hello world", await (Task<string>)greetWithParamAndCommandTask);
|
|
}
|
|
|
|
// See https://github.com/CommunityToolkit/dotnet/issues/230
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CultureAwareCommandName()
|
|
{
|
|
ModelWithCultureAwareCommandName model = new();
|
|
|
|
// This just needs to ensure it compiles, really
|
|
model.InitializeCommand.Execute(null);
|
|
}
|
|
|
|
// See https://github.com/CommunityToolkit/dotnet/issues/162
|
|
[TestMethod]
|
|
public async Task Test_RelayCommandAttribute_WithOnPrefixes()
|
|
{
|
|
ModelWithCommandMethodsWithOnPrefixes model = new();
|
|
|
|
Assert.IsFalse(model.HasOnCommandRun);
|
|
Assert.IsFalse(model.HasOnboardCommandRun);
|
|
Assert.IsFalse(model.HasSubmitCommandRun);
|
|
Assert.IsFalse(model.HasDownloadCommandRun);
|
|
|
|
model.OnCommand.Execute(null);
|
|
|
|
Assert.IsTrue(model.HasOnCommandRun);
|
|
|
|
model.OnboardCommand.Execute(null);
|
|
|
|
Assert.IsTrue(model.HasOnboardCommandRun);
|
|
|
|
model.SubmitCommand.Execute(null);
|
|
|
|
Assert.IsTrue(model.HasSubmitCommandRun);
|
|
|
|
await model.DownloadCommand.ExecuteAsync(null);
|
|
|
|
Assert.IsTrue(model.HasDownloadCommandRun);
|
|
}
|
|
|
|
// See https://github.com/CommunityToolkit/dotnet/issues/283
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_VerifyNoWarningsForNullableValues()
|
|
{
|
|
ModelWithCommandsWithNullabilityAnnotations model = new();
|
|
|
|
// Here we just need to verify we don't get any warnings.
|
|
// That is, that means the generated code has the right nullability annotations.
|
|
model.NullableObjectCommand.Execute(null);
|
|
model.ListWithNullableTypeCommand.Execute(null);
|
|
model.ListWithNullableTypeCommand.Execute(new List<object?>());
|
|
model.TupleWithNullableElementsCommand.Execute((DateTime.Now, null, null, null));
|
|
model.TupleWithNullableElementsCommand.Execute((DateTime.Now, null, true, new List<string>()));
|
|
model.TupleWithNullableElementsCommand.Execute((null, "Hello", null, null));
|
|
model.TupleWithNullableElementsCommand.Execute((null, null, null, null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_VerifyOptions()
|
|
{
|
|
ModelWithCommandsWithCustomOptions model = new();
|
|
|
|
static void AssertOptions(IAsyncRelayCommand command, AsyncRelayCommandOptions options)
|
|
{
|
|
AsyncRelayCommandOptions commandOptions =
|
|
(AsyncRelayCommandOptions)typeof(AsyncRelayCommand)
|
|
.GetField("options", BindingFlags.Instance | BindingFlags.NonPublic)!
|
|
.GetValue(command)!;
|
|
|
|
Assert.AreEqual(commandOptions, options);
|
|
}
|
|
|
|
static void AssertOptionsOfT<T>(IAsyncRelayCommand<T> command, AsyncRelayCommandOptions options)
|
|
{
|
|
AsyncRelayCommandOptions commandOptions =
|
|
(AsyncRelayCommandOptions)typeof(AsyncRelayCommand<T>)
|
|
.GetField("options", BindingFlags.Instance | BindingFlags.NonPublic)!
|
|
.GetValue(command)!;
|
|
|
|
Assert.AreEqual(commandOptions, options);
|
|
}
|
|
|
|
AssertOptions(model.DefaultCommand, AsyncRelayCommandOptions.None);
|
|
AssertOptions(model.AllowConcurrentExecutionsCommand, AsyncRelayCommandOptions.AllowConcurrentExecutions);
|
|
AssertOptions(model.FlowExceptionsToTaskSchedulerCommand, AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
|
|
AssertOptions(model.AllowConcurrentExecutionsAndFlowExceptionsToTaskSchedulerCommand, AsyncRelayCommandOptions.AllowConcurrentExecutions | AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
|
|
|
|
AssertOptionsOfT(model.OfTDefaultCommand, AsyncRelayCommandOptions.None);
|
|
AssertOptionsOfT(model.OfTAndAllowConcurrentExecutionsCommand, AsyncRelayCommandOptions.AllowConcurrentExecutions);
|
|
AssertOptionsOfT(model.OfTAndFlowExceptionsToTaskSchedulerCommand, AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
|
|
AssertOptionsOfT(model.OfTAndAllowConcurrentExecutionsAndFlowExceptionsToTaskSchedulerCommand, AsyncRelayCommandOptions.AllowConcurrentExecutions | AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
|
|
}
|
|
|
|
// See https://github.com/CommunityToolkit/dotnet/issues/294
|
|
[TestMethod]
|
|
public void Test_RelayCommandAttribute_CanExecuteWithNullabilityAnnotations()
|
|
{
|
|
ModelWithCommandWithNullableCanExecute model = new();
|
|
|
|
Assert.IsTrue(model.DoSomething1Command.CanExecute("Hello"));
|
|
Assert.IsTrue(model.DoSomething2Command.CanExecute("Hello"));
|
|
Assert.IsTrue(model.DoSomething3Command.CanExecute((0, "Hello")));
|
|
}
|
|
|
|
#region Region
|
|
public class Region
|
|
{
|
|
}
|
|
#endregion
|
|
|
|
public partial class ViewModelForIssue13
|
|
{
|
|
[RelayCommand]
|
|
private void Greet()
|
|
{
|
|
}
|
|
}
|
|
|
|
public sealed partial class MyViewModel
|
|
{
|
|
public Task? ExternalTask { get; set; }
|
|
|
|
public int Counter { get; private set; }
|
|
|
|
public List<int> Values { get; } = new();
|
|
|
|
public TaskCompletionSource<object?> Tcs { get; private set; } = new();
|
|
|
|
public void ResetTcs() => Tcs = new TaskCompletionSource<object?>();
|
|
|
|
/// <summary>This is a single line summary.</summary>
|
|
[RelayCommand]
|
|
private void IncrementCounter()
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is a multiline summary
|
|
/// </summary>
|
|
[RelayCommand]
|
|
private void IncrementCounterWithValue(int count)
|
|
{
|
|
Counter += count;
|
|
}
|
|
|
|
/// <summary>This is single line with also other stuff below</summary>
|
|
/// <returns>Foo bar baz</returns>
|
|
/// <returns>A task</returns>
|
|
[RelayCommand]
|
|
private async Task DelayAndIncrementCounterAsync()
|
|
{
|
|
await Task.Delay(50);
|
|
|
|
Counter += 1;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = true)]
|
|
private async Task AddValueToListAndDelayAsync(int value)
|
|
{
|
|
Values.Add(value);
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task AddValueToListAndDelayWithDefaultConcurrencyAsync(int value)
|
|
{
|
|
Values.Add(value);
|
|
|
|
_ = await Tcs.Task;
|
|
}
|
|
|
|
[RelayCommand(IncludeCancelCommand = true)]
|
|
private async Task AddValueToListAndDelayWithDefaultConcurrencyAsync_WithCancelCommand(int value, CancellationToken token)
|
|
{
|
|
Values.Add(value);
|
|
|
|
await Task.Delay(1000);
|
|
}
|
|
|
|
#region Test region
|
|
|
|
/// <summary>
|
|
/// This is multi line with also other stuff below
|
|
/// </summary>
|
|
/// <returns>Foo bar baz</returns>
|
|
/// <returns>A task</returns>
|
|
[RelayCommand]
|
|
private async Task DelayAndIncrementCounterWithTokenAsync(CancellationToken token)
|
|
{
|
|
await Task.Delay(50);
|
|
|
|
Counter += 1;
|
|
}
|
|
|
|
// This should not be ported over
|
|
[RelayCommand]
|
|
private async Task DelayAndIncrementCounterWithValueAsync(int count)
|
|
{
|
|
await Task.Delay(50);
|
|
|
|
Counter += count;
|
|
}
|
|
|
|
#endregion
|
|
|
|
[RelayCommand]
|
|
private async Task DelayAndIncrementCounterWithValueAndTokenAsync(int count, CancellationToken token)
|
|
{
|
|
await Task.Delay(50);
|
|
|
|
Counter += count;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = false)]
|
|
private async Task AwaitForExternalTaskAsync()
|
|
{
|
|
await ExternalTask!;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = false)]
|
|
private async Task AwaitForInputTaskAsync(Task task)
|
|
{
|
|
await task;
|
|
}
|
|
}
|
|
|
|
public sealed partial class CanExecuteViewModel : ObservableObject
|
|
{
|
|
public int Counter { get; private set; }
|
|
|
|
public bool Flag { get; set; }
|
|
|
|
public void SetGeneratedFlag(bool flag)
|
|
{
|
|
GeneratedFlag = flag;
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private bool generatedFlag;
|
|
|
|
private bool GetFlag1() => Flag;
|
|
|
|
private bool GetFlag2(User user) => user.Name == nameof(CanExecuteViewModel);
|
|
|
|
[RelayCommand(CanExecute = nameof(Flag))]
|
|
private void IncrementCounter_NoParameters_Property()
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(Flag))]
|
|
private void IncrementCounter_WithParameter_Property(User user)
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GeneratedFlag))]
|
|
private void IncrementCounter_NoParameters_GeneratedProperty()
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GeneratedFlag))]
|
|
private void IncrementCounter_WithParameter_GeneratedProperty(User user)
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag1))]
|
|
private void IncrementCounter_NoParameters_MethodWithNoParameters()
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag1))]
|
|
private void IncrementCounter_WithParameters_MethodWithNoParameters(User user)
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag2))]
|
|
private void IncrementCounter_WithParameters_MethodWithMatchingParameter(User user)
|
|
{
|
|
Counter++;
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(Flag))]
|
|
private async Task IncrementCounter_Async_NoParameters_Property()
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(Flag))]
|
|
private async Task IncrementCounter_Async_WithParameter_Property(User user)
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GeneratedFlag))]
|
|
private async Task IncrementCounter_Async_NoParameters_GeneratedProperty()
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GeneratedFlag))]
|
|
private async Task IncrementCounter_Async_WithParameter_GeneratedProperty(User user)
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag1))]
|
|
private async Task IncrementCounter_Async_NoParameters_MethodWithNoParameters()
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag1))]
|
|
private async Task IncrementCounter_Async_WithParameters_MethodWithNoParameters(User user)
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = nameof(GetFlag2))]
|
|
private async Task IncrementCounter_Async_WithParameters_MethodWithMatchingParameter(User user)
|
|
{
|
|
Counter++;
|
|
|
|
await Task.Delay(100);
|
|
}
|
|
}
|
|
|
|
public sealed class User
|
|
{
|
|
public string? Name { get; set; }
|
|
}
|
|
|
|
public partial class CancelCommandViewModel
|
|
{
|
|
public TaskCompletionSource<object?> Tcs1 { get; } = new();
|
|
|
|
public object? Result1 { get; private set; }
|
|
|
|
public TaskCompletionSource<object?> Tcs2 { get; } = new();
|
|
|
|
public object? Result2 { get; private set; }
|
|
|
|
[RelayCommand(IncludeCancelCommand = true)]
|
|
private async Task DoWorkAsync(CancellationToken token)
|
|
{
|
|
using CancellationTokenRegistration registration = token.Register(static state => ((TaskCompletionSource<object?>)state!).TrySetCanceled(), Tcs1);
|
|
|
|
try
|
|
{
|
|
_ = await Tcs1.Task;
|
|
|
|
Result1 = 42;
|
|
}
|
|
catch (OperationCanceledException e)
|
|
{
|
|
Result1 = e;
|
|
}
|
|
}
|
|
|
|
[RelayCommand(IncludeCancelCommand = true)]
|
|
private async Task DoWorkWithParameterAsync(int number, CancellationToken token)
|
|
{
|
|
using CancellationTokenRegistration registration = token.Register(static state => ((TaskCompletionSource<object?>)state!).TrySetCanceled(), Tcs2);
|
|
|
|
try
|
|
{
|
|
_ = await Tcs2.Task;
|
|
|
|
Result2 = 42;
|
|
}
|
|
catch (OperationCanceledException e)
|
|
{
|
|
Result2 = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
public partial class GenericTaskCommands
|
|
{
|
|
[RelayCommand]
|
|
private async Task<string> GreetAsync()
|
|
{
|
|
await Task.Yield();
|
|
|
|
return "Hello world";
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task<string> GreetWithTokenAsync(CancellationToken token)
|
|
{
|
|
await Task.Yield();
|
|
|
|
return "Hello world";
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task<string> GreetWithParamAsync(object _)
|
|
{
|
|
await Task.Yield();
|
|
|
|
return "Hello world";
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task<string> GreetWithParamAndTokenAsync(object _, CancellationToken token)
|
|
{
|
|
await Task.Yield();
|
|
|
|
return "Hello world";
|
|
}
|
|
}
|
|
|
|
partial class ModelWithCultureAwareCommandName
|
|
{
|
|
// This starts with "I" to ensure it's converted to lowercase using invariant culture
|
|
[RelayCommand]
|
|
private void Initialize()
|
|
{
|
|
}
|
|
}
|
|
|
|
partial class ModelWithCommandMethodsWithOnPrefixes
|
|
{
|
|
public bool HasOnCommandRun { get; private set; }
|
|
|
|
public bool HasOnboardCommandRun { get; private set; }
|
|
|
|
public bool HasSubmitCommandRun { get; private set; }
|
|
|
|
public bool HasDownloadCommandRun { get; private set; }
|
|
|
|
[RelayCommand]
|
|
private void On()
|
|
{
|
|
HasOnCommandRun = true;
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void Onboard()
|
|
{
|
|
HasOnboardCommandRun = true;
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void OnSubmit()
|
|
{
|
|
HasSubmitCommandRun = true;
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task OnDownloadAsync()
|
|
{
|
|
await Task.Delay(100);
|
|
|
|
HasDownloadCommandRun = true;
|
|
}
|
|
}
|
|
|
|
partial class ModelWithCommandsWithNullabilityAnnotations
|
|
{
|
|
[RelayCommand]
|
|
private void NullableObject(object? parameter)
|
|
{
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void ListWithNullableType(List<object?> parameter)
|
|
{
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void TupleWithNullableElements((DateTime? date, string? message, bool? shouldPrint, List<string>? stringList) parameter)
|
|
{
|
|
}
|
|
}
|
|
|
|
partial class ModelWithCommandsWithCustomOptions
|
|
{
|
|
[RelayCommand]
|
|
private Task Default()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand]
|
|
private Task OfTDefault(string obj)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = true)]
|
|
private Task AllowConcurrentExecutions()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = true)]
|
|
private Task OfTAndAllowConcurrentExecutions(string obj)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(FlowExceptionsToTaskScheduler = true)]
|
|
private Task FlowExceptionsToTaskScheduler()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(FlowExceptionsToTaskScheduler = true)]
|
|
private Task OfTAndFlowExceptionsToTaskScheduler(string obj)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = true, FlowExceptionsToTaskScheduler = true)]
|
|
private Task AllowConcurrentExecutionsAndFlowExceptionsToTaskScheduler()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[RelayCommand(AllowConcurrentExecutions = true, FlowExceptionsToTaskScheduler = true)]
|
|
private Task OfTAndAllowConcurrentExecutionsAndFlowExceptionsToTaskScheduler(string obj)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
partial class ModelWithCommandWithNullableCanExecute
|
|
{
|
|
bool CanDoSomething1(string? parameter)
|
|
{
|
|
return !string.IsNullOrEmpty(parameter);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = (nameof(CanDoSomething1)))]
|
|
private void DoSomething1(string? parameter)
|
|
{
|
|
}
|
|
|
|
bool CanDoSomething2(string parameter)
|
|
{
|
|
return !string.IsNullOrEmpty(parameter);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = (nameof(CanDoSomething2)))]
|
|
private void DoSomething2(string? parameter)
|
|
{
|
|
}
|
|
|
|
bool CanDoSomething3((int A, string? B) parameter)
|
|
{
|
|
return !string.IsNullOrEmpty(parameter.B);
|
|
}
|
|
|
|
[RelayCommand(CanExecute = (nameof(CanDoSomething3)))]
|
|
private void DoSomething3((int A, string? B) parameter)
|
|
{
|
|
}
|
|
}
|
|
}
|