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)); }