public async Task ICommand_NoParameter_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
ICommand command = new AsyncValueCommand(() => IntParameterTask(Delay), allowsMultipleExecutions: false);
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object sender, EventArgs e) => canExecuteChangedCount++;
// Act
command.Execute(null);
// Assert
Assert.False(command.CanExecute(null));
// Act
await IntParameterTask(Delay);
await IntParameterTask(Delay);
// Assert
Assert.True(command.CanExecute(null));
Assert.Equal(2, canExecuteChangedCount);
}
public async Task ICommand_ExecuteAsync_ValueTypeParameter_Test()
{
//Arrange
InvalidCommandParameterException?actualInvalidCommandParameterException = null;
InvalidCommandParameterException expectedInvalidCommandParameterException = new InvalidCommandParameterException(typeof(int));
ICommand command = new AsyncValueCommand <int>(IntParameterTask);
//Act
try
{
command.Execute(null);
await NoParameterTask();
await NoParameterTask();
}
catch (InvalidCommandParameterException e)
{
actualInvalidCommandParameterException = e;
}
//Assert
Assert.IsNotNull(actualInvalidCommandParameterException);
Assert.AreEqual(expectedInvalidCommandParameterException.Message, actualInvalidCommandParameterException?.Message);
}
public async Task ICommand_NoParameter_CanExecuteChanged_AllowsMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
ICommand command = new AsyncValueCommand(() => IntParameterTask(Delay));
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object?sender, EventArgs e) => canExecuteChangedCount++;
// Act
command.Execute(null);
// Assert
Assert.IsTrue(command.CanExecute(null));
// Act
await IntParameterTask(Delay).ConfigureAwait(false);
await IntParameterTask(Delay).ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(0, canExecuteChangedCount);
command.CanExecuteChanged -= handleCanExecuteChanged;
}
public void IAsyncCommand_Execute_InvalidReferenceParameter()
{
// Arrange
IAsyncValueCommand <int, bool> command = new AsyncValueCommand <int, bool>(IntParameterTask, CanExecuteTrue);
// Act
// Assert
Assert.Throws <InvalidCommandParameterException>(() => command.Execute("Hello World"));
}
public void IAsyncCommand_Execute_InvalidValueTypeParameter()
{
// Arrange
IAsyncValueCommand <string, bool> command = new AsyncValueCommand <string, bool>(StringParameterTask, CanExecuteTrue);
// Act
// Assert
Assert.Throws <InvalidCommandParameterException>(() => command.Execute(true));
}
public async Task ICommand_Execute_StringParameter_Test(string parameter)
{
//Arrange
ICommand command = new AsyncValueCommand <string>(StringParameterTask);
//Act
command.Execute(parameter);
await NoParameterTask();
//Assert
}
public async Task ICommand_Execute_IntParameter_Test(int parameter)
{
//Arrange
ICommand command = new AsyncValueCommand <int>(IntParameterTask);
//Act
command.Execute(parameter);
await NoParameterTask();
//Assert
}
public async Task ICommand_NoParameter_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
{
// Arrange
var semaphoreSlim = new SemaphoreSlim(1, 1);
var canExecuteChangedCount = 0;
var handleCanExecuteChangedTCS = new TaskCompletionSource <int>();
ICommand command = new AsyncValueCommand(() => IntParameterTask(Delay), allowsMultipleExecutions: false);
command.CanExecuteChanged += handleCanExecuteChanged;
async void handleCanExecuteChanged(object?sender, EventArgs e)
{
await semaphoreSlim.WaitAsync().ConfigureAwait(false);
try
{
if (++canExecuteChangedCount is 2)
{
command.CanExecuteChanged -= handleCanExecuteChanged;
handleCanExecuteChangedTCS.SetResult(canExecuteChangedCount);
}
}
finally
{
semaphoreSlim.Release();
}
}
// Act
command.Execute(null);
// Assert
Assert.False(command.CanExecute(null));
// Act
var handleCanExecuteChangedResult = await handleCanExecuteChangedTCS.Task.ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(2, canExecuteChangedCount);
Assert.AreEqual(canExecuteChangedCount, handleCanExecuteChangedResult);
}
public async Task ICommand_Execute_InvalidReferenceTypeParameter_Test()
{
// Arrange
InvalidCommandParameterException actualInvalidCommandParameterException = null;
var expectedInvalidCommandParameterException = new InvalidCommandParameterException(typeof(int), typeof(string));
ICommand command = new AsyncValueCommand <int>(IntParameterTask);
// Act
try
{
command.Execute("Hello World");
await NoParameterTask();
await NoParameterTask();
}
catch (InvalidCommandParameterException e)
{
actualInvalidCommandParameterException = e;
}
// Assert
Assert.NotNull(actualInvalidCommandParameterException);
Assert.Equal(expectedInvalidCommandParameterException.Message, actualInvalidCommandParameterException?.Message);
}
public async Task ICommand_Parameter_CanExecuteChanged_AllowsMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
ICommand command = new AsyncValueCommand <int>(IntParameterTask);
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object sender, EventArgs e) => canExecuteChangedCount++;
// Act
command.Execute(Delay);
// Assert
Assert.True(command.CanExecute(null));
// Act
await IntParameterTask(Delay);
// Assert
Assert.True(command.CanExecute(null));
Assert.Equal(0, canExecuteChangedCount);
}
public async Task ICommand_Execute_InvalidValueTypeParameter_Test()
{
// Arrange
InvalidCommandParameterException?actualInvalidCommandParameterException = null;
var expectedInvalidCommandParameterException = new InvalidCommandParameterException(typeof(string), typeof(int));
ICommand command = new AsyncValueCommand <string>(StringParameterTask);
// Act
try
{
command.Execute(Delay);
await NoParameterTask().ConfigureAwait(false);
await NoParameterTask().ConfigureAwait(false);
}
catch (InvalidCommandParameterException e)
{
actualInvalidCommandParameterException = e;
}
// Assert
Assert.IsNotNull(actualInvalidCommandParameterException);
Assert.AreEqual(expectedInvalidCommandParameterException.Message, actualInvalidCommandParameterException?.Message);
}