/**
* Test method for {@link DivisionExpression#receive(dEvaluableExpressionVisitor)}. Asserts that
* {@link EvaluableExpressionVisitor#visit(DivisionExpression)} is called.
*/
@Test
public void receive() {
final EvaluableExpressionVisitor mockVisitor = mock(EvaluableExpressionVisitor.class);
final DivisionExpression testedExpression =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getOne(), EVALUABLE_EXPRESSION_FACTORY.getOne());
assertThat(() -> testedExpression.receive(null), throwsException(NullPointerException.class));
testedExpression.receive(mockVisitor);
then(mockVisitor).should().visit(same(testedExpression));
}
/**
* Test method for {@link DivisionExpression#evaluate(EvaluableVariableAssignment)}. Asserts that:
*
* <ul>
* <li>The method passes the assignment to the inner expressions
* <li>It returns the quotients of its inner expressions.
* <li>{@code NaN} and infinity values are handled like specified in IEEE 754.
* <li>Passing {@code null} throws an exception.
* </ul>
*/
@Test
public void evaluate() {
final EvaluableExpression dividend = mock(EvaluableExpression.class);
final EvaluableExpression divisor = mock(EvaluableExpression.class);
final EvaluableVariableAssignment assignment = new EvaluableVariableAssignment();
final DivisionExpression testedExpression = new DivisionExpression(dividend, divisor);
assertThat(() -> testedExpression.evaluate(null), throwsException(NullPointerException.class));
given(dividend.evaluate(same(assignment))).willReturn(15d);
given(divisor.evaluate(same(assignment))).willReturn(3d);
assertThat(testedExpression.evaluate(assignment), is(5d));
given(dividend.evaluate(same(assignment))).willReturn(15d);
given(divisor.evaluate(same(assignment))).willReturn(0d);
assertThat(testedExpression.evaluate(assignment), is(Double.POSITIVE_INFINITY));
given(dividend.evaluate(same(assignment))).willReturn(-15d);
given(divisor.evaluate(same(assignment))).willReturn(0d);
assertThat(testedExpression.evaluate(assignment), is(Double.NEGATIVE_INFINITY));
given(dividend.evaluate(same(assignment))).willReturn(Double.POSITIVE_INFINITY);
given(divisor.evaluate(same(assignment))).willReturn(Double.POSITIVE_INFINITY);
assertThat(testedExpression.evaluate(assignment), is(Double.NaN));
given(dividend.evaluate(same(assignment))).willReturn(0d);
given(divisor.evaluate(same(assignment))).willReturn(0d);
assertThat(testedExpression.evaluate(assignment), is(Double.NaN));
}
/**
* Test method for {@link DivisionExpression#equals(java.lang.Object)} and {@link
* DivisionExpression#hashCode()}. Asserts that:
*
* <ul>
* <li>All and only expressions with equal divisor and dividend are equal
* <li>{@code hashCode} is implemented accordingly
* </ul>
*/
@Test
public void equalsAndHashCode() {
final DivisionExpression equalOne =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getAll()[0], EVALUABLE_EXPRESSION_FACTORY.getAll()[1]);
final DivisionExpression equalTwo =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getAll()[0], EVALUABLE_EXPRESSION_FACTORY.getAll()[1]);
final DivisionExpression differentDivident =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getAll()[2], EVALUABLE_EXPRESSION_FACTORY.getAll()[1]);
final DivisionExpression differentDivisor =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getAll()[0], EVALUABLE_EXPRESSION_FACTORY.getAll()[2]);
final DivisionExpression swapped =
new DivisionExpression(
EVALUABLE_EXPRESSION_FACTORY.getAll()[1], EVALUABLE_EXPRESSION_FACTORY.getAll()[0]);
assertThat(equalOne, hasDefaultEqualsProperties());
assertThat(
"expressions with equal divisor and divident should be equal",
equalOne,
is(equalTo(equalTwo)));
assertThat(equalOne.hashCode(), is(equalTwo.hashCode()));
assertThat(
"expressions with different dividents must not be equal",
equalOne,
is(not(equalTo(differentDivident))));
assertThat(
"expressions with different divisors must not be equal",
equalOne,
is(not(equalTo(differentDivisor))));
assertThat(
"expressions with different dividends and divisiors must not be equal",
equalOne,
is(not(equalTo(swapped))));
}
