public void SetActual_should_be_allowed_once()
{
Verifiable <int> expectation = Fake.Int();
expectation.SetActual(() => Fake.Int());
var ex = Assert.Throws <InvalidOperationException>(() => expectation.SetActual(() => Fake.Int()));
Assert.That(ex.Message, Is.EqualTo("Actual value has been already specified"));
ex = Assert.Throws <InvalidOperationException>(() => expectation.SetActual(Fake.Int()));
Assert.That(ex.Message, Is.EqualTo("Actual value has been already specified"));
}
private void Then_multiplying_X_by_Y_should_give_RESULT(int x, int y, Verifiable <int> result)
{
if (x < 0 || y < 0)
{
Assert.Inconclusive("Negative numbers are not supported yet");
}
result.SetActual(() => _calculator.Multiply(x, y));
}
private void Then_multiplying_X_by_Y_should_give_RESULT(int x, int y, Verifiable <int> result)
{
if (x < 0 || y < 0)
{
StepExecution.Current.IgnoreScenario("Negative numbers are not supported yet");
}
result.SetActual(() => _calculator.Multiply(x, y));
}
private void Evaluation_results_should_be(Verifiable <bool> expected)
{
var builder = new ExpressionEvaluator();
var lambda = builder.Evaluate <Device>(conditionExpression);
var actual = lambda(evaluationContext);
expected.SetActual(actual);
}
private void Evidence_should_produce_a_score(Verifiable <double> expected)
{
var evidence = conditionExpression.GetEvidence(evaluationContext);
StepExecution.Current.Comment($"Evidence\n{evidence.FormatObject()}\n");
var score = evidence.Average(e => e.Score);
expected.SetActual(score);
}
public void SetActual_should_verify_expectation_and_update_formatting(int expected, int actual, bool shouldMatch, string message)
{
Verifiable <int> expectation = expected;
expectation.SetActual(() => actual);
Assert.That(expectation.Status, Is.EqualTo(shouldMatch ? ParameterVerificationStatus.Success : ParameterVerificationStatus.Failure));
Assert.That(expectation.ToString(), Is.EqualTo(message));
}
public void It_should_initialize_instance_with_implicit_cast()
{
var value = Fake.Int();
Verifiable <int> verifiable = value;
Assert.That(verifiable.SetActual(value).Status, Is.EqualTo(ParameterVerificationStatus.Success));
Assert.That(verifiable.Expectation.ToString(), Is.EqualTo($"equals '{value}'"));
}
public void SetActualAsync_should_be_allowed_once()
{
Verifiable <int> expectation = RandomValue.Int();
expectation.SetActual(() => RandomValue.Int());
var ex = Assert.ThrowsAsync <InvalidOperationException>(() => expectation.SetActualAsync(() => Task.FromResult(RandomValue.Int())));
Assert.That(ex.Message, Is.EqualTo("Actual value has been already specified"));
}
public void SetActual_should_set_actual_value()
{
var actualValue = Fake.Int();
Verifiable <int> expectation = Fake.Int();
expectation.SetActual(actualValue);
Assert.That(expectation.Status, Is.Not.EqualTo(ParameterVerificationStatus.NotProvided));
Assert.That(expectation.GetActual(), Is.EqualTo(actualValue));
}
public void SetValueFormattingService_should_allow_using_custom_formatter()
{
var expected = Fake.Int();
var actualValue = expected + 1;
Verifiable <int> expectation = expected;
((IComplexParameter)expectation).SetValueFormattingService(new ValueFormattingServiceStub(CultureInfo.InvariantCulture, "--{0}--"));
expectation.SetActual(() => actualValue);
Assert.That(expectation.ToString(), Is.EqualTo($"expected: equals '--{expected}--', but got: '--{actualValue}--'"));
}
private void Filter_results_should_be(Verifiable <bool> expected)
{
var evidence = GetEvidence(whenCondition, evaluationContext);
if (evidence != null)
{
StepExecution.Current.Comment($"Evidence\n{evidence.FormatObject()}\n");
}
var actual = filter(evaluationContext);
expected.SetActual(actual);
}
private void Evaluation_results_should_be(Verifiable <bool> expected)
{
var builder = new ExpressionEvaluator();
bool actual = false;
if (evaluationContext is Location location)
{
var lambda = builder.Evaluate <Location>(conditionExpression);
actual = lambda(location);
}
else if (evaluationContext is Person person)
{
var lambda = builder.Evaluate <Person>(conditionExpression);
actual = lambda(person);
}
else
{
Assert.Fail($"context type '{evaluationContext.GetType().Name}' is not supported");
}
expected.SetActual(actual);
}
private void Evaluation_results_should_be(Verifiable <bool> expected)
{
var builder = new ExpressionEvaluator();
bool actual = false;
JArray evidence = null;
if (evaluationContext is Location location)
{
var lambda = builder.Evaluate <Location>(conditionExpression);
actual = lambda(location);
evidence = GetEvidence(conditionExpression, location);
}
else if (evaluationContext is Person person)
{
var lambda = builder.Evaluate <Person>(conditionExpression);
actual = lambda(person);
evidence = GetEvidence(conditionExpression, person);
}
else if (evaluationContext is TreeNode treeNode)
{
var lambda = builder.Evaluate <TreeNode>(conditionExpression);
actual = lambda(treeNode);
evidence = GetEvidence(conditionExpression, treeNode);
}
else
{
Assert.Fail($"context type '{evaluationContext.GetType().Name}' is not supported");
}
if (evidence != null)
{
StepExecution.Current.Comment($"Evidence\n{evidence.FormatObject()}\n");
}
expected.SetActual(actual);
}
private void Then_dividing_X_by_Y_should_give_RESULT(int x, int y, Verifiable <int> result)
{
result.SetActual(() => _calculator.Divide(x, y));
}
private void Then_adding_X_to_Y_should_give_RESULT(int x, int y, Verifiable <int> result)
{
result.SetActual(() => _calculator.Add(x, y));
}