public void AsyncValueCommandCanExecuteChanged_Test()
{
// Arrange
var canCommandExecute = false;
var didCanExecuteChangeFire = false;
var command = new AsyncValueCommand(NoParameterTask, commandCanExecute);
command.CanExecuteChanged += handleCanExecuteChanged;
bool commandCanExecute(object parameter) => canCommandExecute;
Assert.False(command.CanExecute(null));
// Act
canCommandExecute = true;
// Assert
Assert.True(command.CanExecute(null));
Assert.False(didCanExecuteChangeFire);
// Act
command.RaiseCanExecuteChanged();
// Assert
Assert.True(didCanExecuteChangeFire);
Assert.True(command.CanExecute(null));
void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
}
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.IsTrue(command.CanExecute(null));
// Act
await IntParameterTask(Delay).ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(0, canExecuteChangedCount);
command.CanExecuteChanged -= handleCanExecuteChanged;
}
public void AsyncValueCommand_ChangeCanExecute_Test()
{
// Arrange
var canCommandExecute = false;
var didCanExecuteChangeFire = false;
var command = new AsyncValueCommand(NoParameterTask, commandCanExecute);
command.CanExecuteChanged += handleCanExecuteChanged;
bool commandCanExecute(object parameter) => canCommandExecute;
Assert.False(command.CanExecute(null));
// Act
canCommandExecute = true;
// Assert
Assert.True(command.CanExecute(null));
Assert.False(didCanExecuteChangeFire);
// Act
#pragma warning disable CS0618 // Type or member is obsolete
command.ChangeCanExecute();
#pragma warning restore CS0618 // Type or member is obsolete
// Assert
Assert.True(didCanExecuteChangeFire);
Assert.True(command.CanExecute(null));
void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
}
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.True(command.CanExecute(null));
// Act
await IntParameterTask(Delay);
await IntParameterTask(Delay);
// Assert
Assert.True(command.CanExecute(null));
Assert.Equal(0, canExecuteChangedCount);
}
public async Task AsyncValueCommand_NoParameter_CanExecuteChanged_AllowsMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
var command = new AsyncValueCommand(() => IntParameterTask(Delay));
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object?sender, EventArgs e) => canExecuteChangedCount++;
Assert.IsTrue(command.AllowsMultipleExecutions);
// Act
var asyncCommandTask = command.ExecuteAsync();
// Assert
Assert.IsTrue(command.IsExecuting);
Assert.IsTrue(command.CanExecute(null));
// Act
await asyncCommandTask.ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(0, canExecuteChangedCount);
command.CanExecuteChanged -= handleCanExecuteChanged;
}
public async Task AsyncValueCommand_NoParameter_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
var command = new AsyncValueCommand(() => IntParameterTask(Delay), allowsMultipleExecutions: false);
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object sender, EventArgs e) => canExecuteChangedCount++;
Assert.False(command.AllowsMultipleExecutions);
// Act
var asyncCommandTask = command.ExecuteAsync();
// Assert
Assert.True(command.IsExecuting);
Assert.False(command.CanExecute(null));
// Act
await asyncCommandTask;
// Assert
Assert.True(command.CanExecute(null));
Assert.Equal(2, canExecuteChangedCount);
}
public void ICommand_Parameter_CanExecuteTrue_Test()
{
//Arrange
ICommand command = new AsyncValueCommand <int>(IntParameterTask, CanExecuteTrue);
//Act
//Assert
Assert.True(command.CanExecute(null));
}
public async Task AsyncValueCommandExecuteAsync_StringParameter_Test(string parameter)
{
//Arrange
AsyncValueCommand <string> command = new AsyncValueCommand <string>(StringParameterTask);
//Act
await command.ExecuteAsync(parameter);
//Assert
}
public void AsyncValueCommandNoParameter_CanExecuteTrue_Test()
{
// Arrange
var command = new AsyncValueCommand(NoParameterTask, parameter => CanExecuteTrue(parameter));
// Act
// Assert
Assert.True(command.CanExecute(null));
}
public void IAsyncCommand_CanExecute_InvalidValueTypeParameter()
{
// Arrange
IAsyncValueCommand <int, string> command = new AsyncValueCommand <int, string>(IntParameterTask, CanExecuteTrue);
// Act
// Assert
Assert.Throws <InvalidCommandParameterException>(() => command.CanExecute(true));
}
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 AsyncValueCommandNoParameter_CanExecuteFalseNoParameter_Test()
{
// Arrange
var command = new AsyncValueCommand(NoParameterTask, () => CanExecuteFalse());
// Act
// Assert
Assert.False(command.CanExecute(null));
}
public void ICommand_Parameter_CanExecuteFalse_NoParameter_Test()
{
// Arrange
ICommand command = new AsyncValueCommand <int>(IntParameterTask, () => CanExecuteFalse());
// Act
// Assert
Assert.False(command.CanExecute(null));
}
public void AsyncValueCommandNoParameter_CanExecuteTrue_Test()
{
//Arrange
AsyncValueCommand command = new AsyncValueCommand(NoParameterTask, CanExecuteTrue);
//Act
//Assert
Assert.IsTrue(command.CanExecute(null));
}
public void AsyncValueCommandParameter_CanExecuteFalse_Test()
{
//Arrange
AsyncValueCommand <int> command = new AsyncValueCommand <int>(IntParameterTask, CanExecuteFalse);
//Act
//Assert
Assert.False(command.CanExecute(null));
}
public void ICommand_NoParameter_CanExecuteFalse_Test()
{
//Arrange
ICommand command = new AsyncValueCommand(NoParameterTask, CanExecuteFalse);
//Act
//Assert
Assert.False(command.CanExecute(null));
}
public void IAsyncValueCommand_NoParameter_CanExecuteTrue_NoParameter_Test()
{
// Arrange
IAsyncValueCommand command = new AsyncValueCommand(NoParameterTask, () => CanExecuteTrue());
// Act
// Assert
Assert.True(command.CanExecute(null));
}
public async Task AsyncValueCommandExecuteAsync_IntParameter_Test(int parameter)
{
//Arrange
AsyncValueCommand <int> command = new AsyncValueCommand <int>(IntParameterTask);
//Act
await command.ExecuteAsync(parameter);
//Assert
}
public async Task ICommand_Execute_StringParameter_Test(string parameter)
{
//Arrange
ICommand command = new AsyncValueCommand <string>(StringParameterTask);
//Act
command.Execute(parameter);
await NoParameterTask();
//Assert
}
public void ICommand_Parameter_CanExecuteChanged_Test()
{
//Arrange
ICommand command = new AsyncValueCommand <int>(IntParameterTask, CanExecuteDynamic);
//Act
//Assert
Assert.True(command.CanExecute(true));
Assert.False(command.CanExecute(false));
}
public async Task ICommand_Execute_IntParameter_Test(int parameter)
{
//Arrange
ICommand command = new AsyncValueCommand <int>(IntParameterTask);
//Act
command.Execute(parameter);
await NoParameterTask();
//Assert
}
public void AsyncValueCommandNoParameter_NoCanExecute_Test()
{
// Arrange
Func <bool> canExecute = null;
var command = new AsyncValueCommand(NoParameterTask, canExecute);
// Act
// Assert
Assert.True(command.CanExecute(null));
}
public void AsyncValueCommandParameter_CanExecuteFalse_Test()
{
// Arrange
var command = new AsyncValueCommand <int>(IntParameterTask, parameter => CanExecuteFalse(parameter));
var command2 = new AsyncValueCommand <int, string>(IntParameterTask, CanExecuteFalse);
// Act
// Assert
Assert.False(command.CanExecute(null));
Assert.False(command2.CanExecute("Hello World"));
}
public void IAsyncValueCommand_Parameter_CanExecuteFalse_NoParameter_Test()
{
// Arrange
IAsyncValueCommand <int> command = new AsyncValueCommand <int>(IntParameterTask, () => CanExecuteFalse());
IAsyncValueCommand <int, bool> command2 = new AsyncValueCommand <int, bool>(IntParameterTask, CanExecuteFalse);
// Act
// Assert
Assert.False(command.CanExecute(null));
Assert.False(command2.CanExecute(true));
}
public void IAsyncValueCommand_Parameter_CanExecuteTrue_Test()
{
// Arrange
IAsyncValueCommand <int> command = new AsyncValueCommand <int>(IntParameterTask, parameter => CanExecuteTrue(parameter));
IAsyncValueCommand <int, string> command2 = new AsyncValueCommand <int, string>(IntParameterTask, CanExecuteTrue);
// Act
// Assert
Assert.True(command.CanExecute(null));
Assert.True(command.CanExecute("Hello World"));
}
public void AsyncValueCommandParameter_CanExecuteTrue_NoParameterTest()
{
// Arrange
var command = new AsyncValueCommand <int>(IntParameterTask, () => CanExecuteTrue());
var command2 = new AsyncValueCommand <int, bool>(IntParameterTask, CanExecuteTrue);
// Act
// Assert
Assert.True(command.CanExecute(null));
Assert.True(command2.CanExecute(true));
}
public async Task AsyncValueCommandExecuteAsync_StringParameter_Test(string parameter)
{
// Arrange
var command = new AsyncValueCommand <string>(StringParameterTask);
var command2 = new AsyncValueCommand <string, bool>(StringParameterTask, CanExecuteTrue);
// Act
await command.ExecuteAsync(parameter);
await command2.ExecuteAsync(parameter);
// Assert
}
public async Task AsyncValueCommandExecuteAsync_IntParameter_Test(int parameter)
{
// Arrange
var command = new AsyncValueCommand <int>(IntParameterTask);
var command2 = new AsyncValueCommand <int, string>(IntParameterTask, CanExecuteTrue);
// Act
await command.ExecuteAsync(parameter);
await command2.ExecuteAsync(parameter);
// Assert
}
public async Task AsyncValueCommand_ExecuteAsync_StringParameter_Test(string parameter)
{
// Arrange
IAsyncValueCommand <string> command = new AsyncValueCommand <string>(StringParameterTask);
IAsyncValueCommand <string, int> command2 = new AsyncValueCommand <string, int>(StringParameterTask);
// Act
await command.ExecuteAsync(parameter).ConfigureAwait(false);
await command2.ExecuteAsync(parameter).ConfigureAwait(false);
// Assert
}
