Test_RelayCommandAttribute.cs

// 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.

usingSystem;
usingSystem.Collections.Generic;
usingSystem.ComponentModel.DataAnnotations;
usingSystem.Linq;
usingSystem.Reflection;
usingSystem.Text.Json.Serialization;
usingSystem.Threading;
usingSystem.Threading.Tasks;
usingSystem.Xml.Serialization;
usingCommunityToolkit.Mvvm.ComponentModel;
usingCommunityToolkit.Mvvm.Input;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

namespaceCommunityToolkit.Mvvm.UnitTests;

[TestClass]
publicpartialclassTest_RelayCommandAttribute
{
[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_RelayCommand()
{
MyViewModelmodel=new();

model.IncrementCounterCommand.Execute(null);

Assert.AreEqual(model.Counter,1);

model.IncrementCounterWithValueCommand.Execute(5);

Assert.AreEqual(model.Counter,6);

awaitmodel.DelayAndIncrementCounterCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,7);

awaitmodel.DelayAndIncrementCounterWithTokenCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,8);

awaitmodel.DelayAndIncrementCounterWithValueCommand.ExecuteAsync(5);

Assert.AreEqual(model.Counter,13);

awaitmodel.DelayAndIncrementCounterWithValueAndTokenCommand.ExecuteAsync(5);

Assert.AreEqual(model.Counter,18);

List<Task>tasks=new();

for(inti=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());

awaitTask.WhenAll(tasks);

model.Values.Clear();
tasks.Clear();

for(inti=0;i<10;i++)
{
if(model.AddValueToListAndDelayWithDefaultConcurrencyCommand.CanExecute(i))
{
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyCommand.ExecuteAsync(i));
}
}

model.Tcs.SetResult(null);

awaitTask.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(inti=0;i<10;i++)
{
// Ignore the checks
tasks.Add(model.AddValueToListAndDelayWithDefaultConcurrencyCommand.ExecuteAsync(i));
}

model.Tcs.SetResult(null);

awaitTask.WhenAll(tasks);

Assert.AreEqual(10,tasks.Count);

CollectionAssert.AreEqual(model.Values,Enumerable.Range(0,10).ToArray());

model.Values.Clear();
tasks.Clear();

for(inti=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(inti=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]
publicvoidTest_RelayCommandAttribute_CanExecute_NoParameters_Property()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_NoParameters_GeneratedProperty()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_WithParameter_Property()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_WithParameter_GeneratedProperty()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_NoParameters_MethodWithNoParameters()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_WithParameters_MethodWithNoParameters()
{
CanExecuteViewModelmodel=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]
publicvoidTest_RelayCommandAttribute_CanExecute_WithParameters_MethodWithMatchingParameter()
{
CanExecuteViewModelmodel=new();

model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.Execute(newUser{Name=nameof(CanExecuteViewModel)});

Assert.AreEqual(model.Counter,1);

Assert.IsFalse(model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.CanExecute(newUser()));

model.IncrementCounter_WithParameters_MethodWithMatchingParameterCommand.Execute(newUser());

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CanExecute_Async_NoParameters_Property()
{
CanExecuteViewModelmodel=new();

model.Flag=true;

awaitmodel.IncrementCounter_Async_NoParameters_PropertyCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,1);

model.Flag=false;

Assert.IsFalse(model.IncrementCounter_Async_NoParameters_PropertyCommand.CanExecute(null));

awaitmodel.IncrementCounter_Async_NoParameters_PropertyCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CanExecute_Async_WithParameter_Property()
{
CanExecuteViewModelmodel=new();

model.Flag=true;

awaitmodel.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,1);

model.Flag=false;

Assert.IsFalse(model.IncrementCounter_Async_WithParameter_PropertyCommand.CanExecute(null));

awaitmodel.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CanExecute_Async_NoParameters_MethodWithNoParameters()
{
CanExecuteViewModelmodel=new();

model.Flag=true;

awaitmodel.IncrementCounter_Async_NoParameters_MethodWithNoParametersCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,1);

model.Flag=false;

Assert.IsFalse(model.IncrementCounter_Async_WithParameter_PropertyCommand.CanExecute(null));

awaitmodel.IncrementCounter_Async_WithParameter_PropertyCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CanExecute_Async_WithParameters_MethodWithNoParameters()
{
CanExecuteViewModelmodel=new();

model.Flag=true;

awaitmodel.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,1);

model.Flag=false;

Assert.IsFalse(model.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.CanExecute(null));

awaitmodel.IncrementCounter_Async_WithParameters_MethodWithNoParametersCommand.ExecuteAsync(null);

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CanExecute_Async_WithParameters_MethodWithMatchingParameter()
{
CanExecuteViewModelmodel=new();

awaitmodel.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.ExecuteAsync(newUser{Name=nameof(CanExecuteViewModel)});

Assert.AreEqual(model.Counter,1);

Assert.IsFalse(model.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.CanExecute(newUser()));

awaitmodel.IncrementCounter_Async_WithParameters_MethodWithMatchingParameterCommand.ExecuteAsync(newUser());

Assert.AreEqual(model.Counter,2);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_ConcurrencyControl_AsyncRelayCommand()
{
TaskCompletionSource<object?>tcs=new();

MyViewModelmodel=new(){ExternalTask=tcs.Task};

Tasktask=model.AwaitForExternalTaskCommand.ExecuteAsync(null);

Assert.IsTrue(model.AwaitForExternalTaskCommand.IsRunning);
Assert.IsFalse(model.AwaitForExternalTaskCommand.CanExecute(null));

tcs.SetResult(null);

awaittask;

Assert.IsFalse(model.AwaitForExternalTaskCommand.IsRunning);
Assert.IsTrue(model.AwaitForExternalTaskCommand.CanExecute(null));
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_ConcurrencyControl_AsyncRelayCommandOfT()
{
MyViewModelmodel=new();

TaskCompletionSource<object?>tcs=new();

Tasktask=model.AwaitForInputTaskCommand.ExecuteAsync(tcs.Task);

Assert.IsTrue(model.AwaitForInputTaskCommand.IsRunning);
Assert.IsFalse(model.AwaitForInputTaskCommand.CanExecute(null));

tcs.SetResult(null);

awaittask;

Assert.IsFalse(model.AwaitForInputTaskCommand.IsRunning);
Assert.IsTrue(model.AwaitForInputTaskCommand.CanExecute(null));
}

// See https://github.com/CommunityToolkit/dotnet/issues/13
[TestMethod]
publicvoidTest_RelayCommandAttribute_ViewModelRightAfterRegion()
{
ViewModelForIssue13model=new();

Assert.IsNotNull(model.GreetCommand);
Assert.IsInstanceOfType((object)model.GreetCommand,typeof(RelayCommand));
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_CancelCommands()
{
CancelCommandViewModelmodel=new();

model.DoWorkCommand.Execute(null);

Assert.IsTrue(model.DoWorkCancelCommand.CanExecute(null));

model.DoWorkCancelCommand.Execute(null);

awaitTask.Yield();

Assert.IsTrue(model.Tcs1.Task.IsCanceled);
Assert.IsTrue(model.Result1isOperationCanceledException);

model.DoWorkWithParameterCommand.Execute(42);

Assert.IsTrue(model.DoWorkWithParameterCancelCommand.CanExecute(null));

model.DoWorkWithParameterCancelCommand.Execute(null);

awaitTask.Yield();

Assert.IsTrue(model.Tcs2.Task.IsCanceled);
Assert.IsTrue(model.Result2isOperationCanceledException);
}

[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_TaskOfTReturns()
{
GenericTaskCommandsmodel=new();

TaskgreetCommandTask=model.GreetCommand.ExecuteAsync(null);
TaskgreetWithTokenTask=model.GreetWithTokenCommand.ExecuteAsync(null);
TaskgreetWithParamTask=model.GreetWithParamCommand.ExecuteAsync(null);
TaskgreetWithParamAndCommandTask=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]
publicvoidTest_RelayCommandAttribute_CultureAwareCommandName()
{
ModelWithCultureAwareCommandNamemodel=new();

// This just needs to ensure it compiles, really
model.InitializeCommand.Execute(null);
}

// See https://github.com/CommunityToolkit/dotnet/issues/162
[TestMethod]
publicasyncTaskTest_RelayCommandAttribute_WithOnPrefixes()
{
ModelWithCommandMethodsWithOnPrefixesmodel=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);

awaitmodel.DownloadCommand.ExecuteAsync(null);

Assert.IsTrue(model.HasDownloadCommandRun);
}

// See https://github.com/CommunityToolkit/dotnet/issues/283
[TestMethod]
publicvoidTest_RelayCommandAttribute_VerifyNoWarningsForNullableValues()
{
ModelWithCommandsWithNullabilityAnnotationsmodel=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(newList<object?>());
model.TupleWithNullableElementsCommand.Execute((DateTime.Now,null,null,null));
model.TupleWithNullableElementsCommand.Execute((DateTime.Now,null,true,newList<string>()));
model.TupleWithNullableElementsCommand.Execute((null,"Hello",null,null));
model.TupleWithNullableElementsCommand.Execute((null,null,null,null));
}

[TestMethod]
publicvoidTest_RelayCommandAttribute_VerifyOptions()
{
ModelWithCommandsWithCustomOptionsmodel=new();

staticvoidAssertOptions(IAsyncRelayCommandcommand,AsyncRelayCommandOptionsoptions)
{
AsyncRelayCommandOptionscommandOptions=
(AsyncRelayCommandOptions)typeof(AsyncRelayCommand)
.GetField("options",BindingFlags.Instance|BindingFlags.NonPublic)!
.GetValue(command)!;

Assert.AreEqual(commandOptions,options);
}

staticvoidAssertOptionsOfT<T>(IAsyncRelayCommand<T>command,AsyncRelayCommandOptionsoptions)
{
AsyncRelayCommandOptionscommandOptions=
(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]
publicvoidTest_RelayCommandAttribute_CanExecuteWithNullabilityAnnotations()
{
ModelWithCommandWithNullableCanExecutemodel=new();

Assert.IsTrue(model.DoSomething1Command.CanExecute("Hello"));
Assert.IsTrue(model.DoSomething2Command.CanExecute("Hello"));
Assert.IsTrue(model.DoSomething3Command.CanExecute((0,"Hello")));
}

[TestMethod]
publicvoidTest_RelayCommandAttribute_WithExplicitAttributesForFieldAndProperty()
{
FieldInfofooField=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetField("fooCommand",BindingFlags.Instance|BindingFlags.NonPublic)!;

Assert.IsNotNull(fooField.GetCustomAttribute<RequiredAttribute>());
Assert.IsNotNull(fooField.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(fooField.GetCustomAttribute<MinLengthAttribute>()!.Length,1);
Assert.IsNotNull(fooField.GetCustomAttribute<MaxLengthAttribute>());
Assert.AreEqual(fooField.GetCustomAttribute<MaxLengthAttribute>()!.Length,100);

PropertyInfofooProperty=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetProperty("FooCommand")!;

Assert.IsNotNull(fooProperty.GetCustomAttribute<RequiredAttribute>());
Assert.IsNotNull(fooProperty.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(fooProperty.GetCustomAttribute<MinLengthAttribute>()!.Length,1);
Assert.IsNotNull(fooProperty.GetCustomAttribute<MaxLengthAttribute>());
Assert.AreEqual(fooProperty.GetCustomAttribute<MaxLengthAttribute>()!.Length,100);

PropertyInfobarProperty=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetProperty("BarCommand")!;

Assert.IsNotNull(barProperty.GetCustomAttribute<JsonPropertyNameAttribute>());
Assert.AreEqual(barProperty.GetCustomAttribute<JsonPropertyNameAttribute>()!.Name,"bar");
Assert.IsNotNull(barProperty.GetCustomAttribute<XmlIgnoreAttribute>());

PropertyInfobazProperty=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetProperty("BazCommand")!;

Assert.IsNotNull(bazProperty.GetCustomAttribute<Test_ObservablePropertyAttribute.TestAttribute>());

staticvoidValidateTestAttribute(TestValidationAttributetestAttribute)
{
Assert.IsNotNull(testAttribute);
Assert.IsNull(testAttribute.O);
Assert.AreEqual(testAttribute.T,typeof(MyViewModelWithExplicitFieldAndPropertyAttributes));
Assert.AreEqual(testAttribute.Flag,true);
Assert.AreEqual(testAttribute.D,6.28);
CollectionAssert.AreEqual(testAttribute.Names,new[]{"Bob","Ross"});

object[]?nestedArray=(object[]?)testAttribute.NestedArray;

Assert.IsNotNull(nestedArray);
Assert.AreEqual(nestedArray!.Length,3);
Assert.AreEqual(nestedArray[0],1);
Assert.AreEqual(nestedArray[1],"Hello");
Assert.IsTrue(nestedArray[2]isint[]);
CollectionAssert.AreEqual((int[])nestedArray[2],new[]{2,3,4});

Assert.AreEqual(testAttribute.Animal,Test_ObservablePropertyAttribute.Animal.Llama);
}

FieldInfofooBarField=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetField("fooBarCommand",BindingFlags.Instance|BindingFlags.NonPublic)!;

ValidateTestAttribute(fooBarField.GetCustomAttribute<TestValidationAttribute>()!);

PropertyInfofooBarProperty=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetProperty("FooBarCommand")!;

ValidateTestAttribute(fooBarProperty.GetCustomAttribute<TestValidationAttribute>()!);

FieldInfobarBazField=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetField("barBazCommand",BindingFlags.Instance|BindingFlags.NonPublic)!;

Assert.IsNotNull(barBazField.GetCustomAttribute<Test_ObservablePropertyAttribute.TestAttribute>());

PropertyInfobarBazCommand=typeof(MyViewModelWithExplicitFieldAndPropertyAttributes).GetProperty("BarBazCommand")!;

Assert.IsNotNull(barBazCommand.GetCustomAttribute<Test_ObservablePropertyAttribute.TestAttribute>());

Test_ObservablePropertyAttribute.PropertyInfoAttributetestAttribute2=barBazCommand.GetCustomAttribute<Test_ObservablePropertyAttribute.PropertyInfoAttribute>()!;

Assert.IsNotNull(testAttribute2);
Assert.IsNull(testAttribute2.O);
Assert.AreEqual(testAttribute2.T,typeof(MyViewModelWithExplicitFieldAndPropertyAttributes));
Assert.AreEqual(testAttribute2.Flag,true);
Assert.AreEqual(testAttribute2.D,6.28);
Assert.IsNotNull(testAttribute2.Objects);
Assert.IsTrue(testAttribute2.Objectsisobject[]);
Assert.AreEqual(((object[])testAttribute2.Objects).Length,1);
Assert.AreEqual(((object[])testAttribute2.Objects)[0],"Test");
CollectionAssert.AreEqual(testAttribute2.Names,new[]{"Bob","Ross"});

object[]?nestedArray2=(object[]?)testAttribute2.NestedArray;

Assert.IsNotNull(nestedArray2);
Assert.AreEqual(nestedArray2!.Length,4);
Assert.AreEqual(nestedArray2[0],1);
Assert.AreEqual(nestedArray2[1],"Hello");
Assert.AreEqual(nestedArray2[2],42);
Assert.IsNull(nestedArray2[3]);

Assert.AreEqual(testAttribute2.Animal,(Test_ObservablePropertyAttribute.Animal)67);
}

// See https://github.com/CommunityToolkit/dotnet/issues/632
[TestMethod]
publicvoidTest_RelayCommandAttribute_WithPartialCommandMethodDefinitions()
{
ModelWithPartialCommandMethodsmodel=new();

Assert.IsInstanceOfType<RelayCommand>(model.FooCommand);
Assert.IsInstanceOfType<RelayCommand<string>>(model.BarCommand);
Assert.IsInstanceOfType<RelayCommand>(model.BazCommand);
Assert.IsInstanceOfType<AsyncRelayCommand>(model.FooBarCommand);

FieldInfobazField=typeof(ModelWithPartialCommandMethods).GetField("bazCommand",BindingFlags.Instance|BindingFlags.NonPublic)!;

Assert.IsNotNull(bazField.GetCustomAttribute<RequiredAttribute>());
Assert.IsNotNull(bazField.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(bazField.GetCustomAttribute<MinLengthAttribute>()!.Length,1);

PropertyInfobazProperty=typeof(ModelWithPartialCommandMethods).GetProperty("BazCommand")!;

Assert.IsNotNull(bazProperty.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(bazProperty.GetCustomAttribute<MinLengthAttribute>()!.Length,2);
Assert.IsNotNull(bazProperty.GetCustomAttribute<XmlIgnoreAttribute>());

FieldInfofooBarField=typeof(ModelWithPartialCommandMethods).GetField("fooBarCommand",BindingFlags.Instance|BindingFlags.NonPublic)!;

Assert.IsNotNull(fooBarField.GetCustomAttribute<RequiredAttribute>());
Assert.IsNotNull(fooBarField.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(fooBarField.GetCustomAttribute<MinLengthAttribute>()!.Length,1);

PropertyInfofooBarProperty=typeof(ModelWithPartialCommandMethods).GetProperty("FooBarCommand")!;

Assert.IsNotNull(fooBarProperty.GetCustomAttribute<MinLengthAttribute>());
Assert.AreEqual(fooBarProperty.GetCustomAttribute<MinLengthAttribute>()!.Length,2);
Assert.IsNotNull(fooBarProperty.GetCustomAttribute<XmlIgnoreAttribute>());
}

 #region Region
publicclassRegion
{
}
 #endregion

publicpartialclassViewModelForIssue13
{
[RelayCommand]
privatevoidGreet()
{
}
}

publicsealedpartialclassMyViewModel
{
publicTask?ExternalTask{get;set;}

publicintCounter{get;privateset;}

publicList<int>Values{get;}=new();

publicTaskCompletionSource<object?>Tcs{get;privateset;}=new();

publicvoidResetTcs()=>Tcs=newTaskCompletionSource<object?>();

/// <summary>This is a single line summary.</summary>
[RelayCommand]
privatevoidIncrementCounter()
{
Counter++;
}

/// <summary>
/// This is a multiline summary
/// </summary>
[RelayCommand]
privatevoidIncrementCounterWithValue(intcount)
{
Counter+=count;
}

/// <summary>This is single line with also other stuff below</summary>
/// <returns>Foo bar baz</returns>
/// <returns>A task</returns>
[RelayCommand]
privateasyncTaskDelayAndIncrementCounterAsync()
{
awaitTask.Delay(50);

Counter+=1;
}

[RelayCommand(AllowConcurrentExecutions=true)]
privateasyncTaskAddValueToListAndDelayAsync(intvalue)
{
Values.Add(value);

awaitTask.Delay(100);
}

[RelayCommand]
privateasyncTaskAddValueToListAndDelayWithDefaultConcurrencyAsync(intvalue)
{
Values.Add(value);

_=awaitTcs.Task;
}

[RelayCommand(IncludeCancelCommand=true)]
privateasyncTaskAddValueToListAndDelayWithDefaultConcurrencyAsync_WithCancelCommand(intvalue,CancellationTokentoken)
{
Values.Add(value);

awaitTask.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]
privateasyncTaskDelayAndIncrementCounterWithTokenAsync(CancellationTokentoken)
{
awaitTask.Delay(50);

Counter+=1;
}

// This should not be ported over
[RelayCommand]
privateasyncTaskDelayAndIncrementCounterWithValueAsync(intcount)
{
awaitTask.Delay(50);

Counter+=count;
}

 #endregion

[RelayCommand]
privateasyncTaskDelayAndIncrementCounterWithValueAndTokenAsync(intcount,CancellationTokentoken)
{
awaitTask.Delay(50);

Counter+=count;
}

[RelayCommand(AllowConcurrentExecutions=false)]
privateasyncTaskAwaitForExternalTaskAsync()
{
awaitExternalTask!;
}

[RelayCommand(AllowConcurrentExecutions=false)]
privateasyncTaskAwaitForInputTaskAsync(Tasktask)
{
awaittask;
}
}

publicsealedpartialclassCanExecuteViewModel:ObservableObject
{
publicintCounter{get;privateset;}

publicboolFlag{get;set;}

publicvoidSetGeneratedFlag(boolflag)
{
GeneratedFlag=flag;
}

[ObservableProperty]
privateboolgeneratedFlag;

privateboolGetFlag1()=>Flag;

privateboolGetFlag2(Useruser)=>user.Name==nameof(CanExecuteViewModel);

[RelayCommand(CanExecute=nameof(Flag))]
privatevoidIncrementCounter_NoParameters_Property()
{
Counter++;
}

[RelayCommand(CanExecute=nameof(Flag))]
privatevoidIncrementCounter_WithParameter_Property(Useruser)
{
Counter++;
}

[RelayCommand(CanExecute=nameof(GeneratedFlag))]
privatevoidIncrementCounter_NoParameters_GeneratedProperty()
{
Counter++;
}

[RelayCommand(CanExecute=nameof(GeneratedFlag))]
privatevoidIncrementCounter_WithParameter_GeneratedProperty(Useruser)
{
Counter++;
}

[RelayCommand(CanExecute=nameof(GetFlag1))]
privatevoidIncrementCounter_NoParameters_MethodWithNoParameters()
{
Counter++;
}

[RelayCommand(CanExecute=nameof(GetFlag1))]
privatevoidIncrementCounter_WithParameters_MethodWithNoParameters(Useruser)
{
Counter++;
}

[RelayCommand(CanExecute=nameof(GetFlag2))]
privatevoidIncrementCounter_WithParameters_MethodWithMatchingParameter(Useruser)
{
Counter++;
}

[RelayCommand(CanExecute=nameof(Flag))]
privateasyncTaskIncrementCounter_Async_NoParameters_Property()
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(Flag))]
privateasyncTaskIncrementCounter_Async_WithParameter_Property(Useruser)
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(GeneratedFlag))]
privateasyncTaskIncrementCounter_Async_NoParameters_GeneratedProperty()
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(GeneratedFlag))]
privateasyncTaskIncrementCounter_Async_WithParameter_GeneratedProperty(Useruser)
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(GetFlag1))]
privateasyncTaskIncrementCounter_Async_NoParameters_MethodWithNoParameters()
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(GetFlag1))]
privateasyncTaskIncrementCounter_Async_WithParameters_MethodWithNoParameters(Useruser)
{
Counter++;

awaitTask.Delay(100);
}

[RelayCommand(CanExecute=nameof(GetFlag2))]
privateasyncTaskIncrementCounter_Async_WithParameters_MethodWithMatchingParameter(Useruser)
{
Counter++;

awaitTask.Delay(100);
}
}

publicsealedclassUser
{
publicstring?Name{get;set;}
}

publicpartialclassCancelCommandViewModel
{
publicTaskCompletionSource<object?>Tcs1{get;}=new();

publicobject?Result1{get;privateset;}

publicTaskCompletionSource<object?>Tcs2{get;}=new();

publicobject?Result2{get;privateset;}

[RelayCommand(IncludeCancelCommand=true)]
privateasyncTaskDoWorkAsync(CancellationTokentoken)
{
usingCancellationTokenRegistrationregistration=token.Register(static state =>((TaskCompletionSource<object?>)state!).TrySetCanceled(),Tcs1);

try
{
_=awaitTcs1.Task;

Result1=42;
}
catch(OperationCanceledExceptione)
{
Result1=e;
}
}

[RelayCommand(IncludeCancelCommand=true)]
privateasyncTaskDoWorkWithParameterAsync(intnumber,CancellationTokentoken)
{
usingCancellationTokenRegistrationregistration=token.Register(static state =>((TaskCompletionSource<object?>)state!).TrySetCanceled(),Tcs2);

try
{
_=awaitTcs2.Task;

Result2=42;
}
catch(OperationCanceledExceptione)
{
Result2=e;
}
}
}

publicpartialclassGenericTaskCommands
{
[RelayCommand]
privateasyncTask<string>GreetAsync()
{
awaitTask.Yield();

return"Hello world";
}

[RelayCommand]
privateasyncTask<string>GreetWithTokenAsync(CancellationTokentoken)