From 56d8291abfb44a078fe2befb0782dc2014e50f59 Mon Sep 17 00:00:00 2001 From: Joshua Kitchen Date: Thu, 7 Feb 2019 20:43:29 +0000 Subject: [PATCH] Add OptionalDoubleAssert.hasValueCloseTo percentage. Fixes #1422 --- .../api/AbstractOptionalDoubleAssert.java | 41 +++- ...alDoubleShouldHaveValueCloseToOffset.java} | 22 +- ...oubleShouldHaveValueCloseToPercentage.java | 72 ++++++ ...bleAssert_hasValueCloseToOffset_Test.java} | 12 +- ...Assert_hasValueCloseToPercentage_Test.java | 207 ++++++++++++++++++ ...ldHaveValueCloseToOffset_create_Test.java} | 8 +- ...aveValueCloseToPercentage_create_Test.java | 44 ++++ 7 files changed, 383 insertions(+), 23 deletions(-) rename src/main/java/org/assertj/core/error/{OptionalDoubleShouldHaveValueCloseTo.java => OptionalDoubleShouldHaveValueCloseToOffset.java} (70%) create mode 100644 src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage.java rename src/test/java/org/assertj/core/api/optionaldouble/{OptionalDoubleAssert_hasValueCloseTo_Test.java => OptionalDoubleAssert_hasValueCloseToOffset_Test.java} (89%) create mode 100644 src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToPercentage_Test.java rename src/test/java/org/assertj/core/error/{OptionalDoubleShouldHaveValueCloseTo_create_Test.java => OptionalDoubleShouldHaveValueCloseToOffset_create_Test.java} (84%) create mode 100644 src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage_create_Test.java diff --git a/src/main/java/org/assertj/core/api/AbstractOptionalDoubleAssert.java b/src/main/java/org/assertj/core/api/AbstractOptionalDoubleAssert.java index c1ffd1d05e..0be455aeb8 100644 --- a/src/main/java/org/assertj/core/api/AbstractOptionalDoubleAssert.java +++ b/src/main/java/org/assertj/core/api/AbstractOptionalDoubleAssert.java @@ -13,7 +13,8 @@ package org.assertj.core.api; import static java.lang.Math.abs; -import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseTo.shouldHaveValueCloseTo; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToOffset.shouldHaveValueCloseToOffset; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToPercentage.shouldHaveValueCloseToPercentage; import static org.assertj.core.error.OptionalShouldBeEmpty.shouldBeEmpty; import static org.assertj.core.error.OptionalShouldBePresent.shouldBePresent; import static org.assertj.core.error.OptionalShouldContain.shouldContain; @@ -21,6 +22,7 @@ import java.util.OptionalDouble; import org.assertj.core.data.Offset; +import org.assertj.core.data.Percentage; import org.assertj.core.internal.Doubles; import org.assertj.core.internal.Failures; import org.assertj.core.util.VisibleForTesting; @@ -163,12 +165,45 @@ public SELF hasValue(double expectedValue) { */ public SELF hasValueCloseTo(Double expectedValue, Offset offset) { isNotNull(); - if (!actual.isPresent()) throwAssertionError(shouldHaveValueCloseTo(expectedValue)); + if (!actual.isPresent()) throwAssertionError(shouldHaveValueCloseToOffset(expectedValue)); // Reuses doubles functionality, catches potential assertion error and throw correct one try { doubles.assertIsCloseTo(info, actual.getAsDouble(), expectedValue, offset); } catch (AssertionError assertionError) { - throwAssertionError(shouldHaveValueCloseTo(actual, expectedValue, offset, abs(expectedValue - actual.getAsDouble()))); + throwAssertionError(shouldHaveValueCloseToOffset(actual, expectedValue, offset, abs(expectedValue - actual.getAsDouble()))); + } + return myself; + } + + /** + * Verifies that the actual {@link java.util.OptionalDouble} has a value close to the expected value, within the given + * percentage.
+ * If the difference is equal to the percentage value, the assertion is considered valid. + * + * 
// The assertion will pass:
+   * assertThat(OptionalDouble.of(11)).hasValueCloseTo(10.0, withinPercentage(20));
+   *
+   * // If the difference is exactly equals to the computed offset (1.0), the assertion will pass:
+   * assertThat(OptionalDouble.of(11)).hasValueCloseTo(10.0, withinPercentage(10));
+   *
+   * // The assertions will fail:
+   * assertThat(OptionalDouble.of(11)).hasValueCloseTo(10.0, withinPercentage(5));
+   * assertThat(OptionalDouble.empty()).hasValueCloseTo(10.0, withinPercentage(5));
+ * + * @param expectedValue the expected value inside the {@link java.util.OptionalDouble} + * @param percentage the given positive percentage + * @return the assertion object + * @throws java.lang.AssertionError if actual value is empty + * @throws java.lang.AssertionError if actual is null + * @throws java.lang.AssertionError if the actual value is not close to the given one + */ + public SELF hasValueCloseTo(Double expectedValue, Percentage percentage) { + isNotNull(); + if (!actual.isPresent()) throwAssertionError(shouldHaveValueCloseToPercentage(expectedValue)); + try { + doubles.assertIsCloseToPercentage(info, actual.getAsDouble(), expectedValue, percentage); + } catch (AssertionError assertionError) { + throwAssertionError(shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, abs(expectedValue - actual.getAsDouble()))); } return myself; } diff --git a/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo.java b/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset.java similarity index 70% rename from src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo.java rename to src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset.java index 6ea600ac47..3a3166961a 100644 --- a/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo.java +++ b/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset.java @@ -22,17 +22,17 @@ * @author Jean-Christophe Gay * @author Alexander Bischof */ -public class OptionalDoubleShouldHaveValueCloseTo extends BasicErrorMessageFactory { +public class OptionalDoubleShouldHaveValueCloseToOffset extends BasicErrorMessageFactory { - private OptionalDoubleShouldHaveValueCloseTo(OptionalDouble actual, double expected, Offset offset, - double difference) { + private OptionalDoubleShouldHaveValueCloseToOffset(OptionalDouble actual, double expected, Offset offset, + double difference) { super("%nExpecting:%n <%s>%nto be close to:%n <%s>%n" + "by less than <%s> but difference was <%s>.%n" + "(a difference of exactly <%s> being considered valid)", actual, expected, offset.value, difference, offset.value); } - private OptionalDoubleShouldHaveValueCloseTo(double expected) { + private OptionalDoubleShouldHaveValueCloseToOffset(double expected) { super("%nExpecting an OptionalDouble with value:%n <%s>%nbut was empty.", expected); } @@ -45,11 +45,11 @@ private OptionalDoubleShouldHaveValueCloseTo(double expected) { * @param difference the effective difference between actual and expected. * @return a error message factory */ - public static OptionalDoubleShouldHaveValueCloseTo shouldHaveValueCloseTo(OptionalDouble optional, - double expectedValue, - Offset offset, - double difference) { - return new OptionalDoubleShouldHaveValueCloseTo(optional, expectedValue, offset, difference); + public static OptionalDoubleShouldHaveValueCloseToOffset shouldHaveValueCloseToOffset(OptionalDouble optional, + double expectedValue, + Offset offset, + double difference) { + return new OptionalDoubleShouldHaveValueCloseToOffset(optional, expectedValue, offset, difference); } /** @@ -58,7 +58,7 @@ public static OptionalDoubleShouldHaveValueCloseTo shouldHaveValueCloseTo(Option * @param expectedValue the value we expect to be in an {@link java.util.OptionalDouble}. * @return a error message factory. */ - public static OptionalDoubleShouldHaveValueCloseTo shouldHaveValueCloseTo(double expectedValue) { - return new OptionalDoubleShouldHaveValueCloseTo(expectedValue); + public static OptionalDoubleShouldHaveValueCloseToOffset shouldHaveValueCloseToOffset(double expectedValue) { + return new OptionalDoubleShouldHaveValueCloseToOffset(expectedValue); } } diff --git a/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage.java b/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage.java new file mode 100644 index 0000000000..3c68242b7b --- /dev/null +++ b/src/main/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage.java @@ -0,0 +1,72 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * Copyright 2012-2018 the original author or authors. + */ +package org.assertj.core.error; + +import org.assertj.core.data.Percentage; + +import java.util.OptionalDouble; + +/** + * Build error message when an {@link java.util.OptionalDouble} should be close to an expected value within a positive + * percentage. + * + * @author Joshua Kitchen + */ +public class OptionalDoubleShouldHaveValueCloseToPercentage extends BasicErrorMessageFactory { + + private OptionalDoubleShouldHaveValueCloseToPercentage(double expected) { + super("%nExpecting an OptionalDouble with value:%n" + + " <%s>%n" + + "but was empty.", + expected); + } + + private OptionalDoubleShouldHaveValueCloseToPercentage(OptionalDouble actual, double expected, Percentage percentage, + double expectedPercentage) { + super("%nExpecting:%n" + + " <%s>%n" + + "to be close to:%n" + + " <%s>%n" + + "by less than %s but difference was %s%%.%n" + + "(a difference of exactly %s being considered valid)", + actual, expected, percentage, expectedPercentage, percentage); + } + + /** + * Indicates that the provided {@link java.util.OptionalDouble} is empty so it doesn't have the expected value. + * + * @param expectedValue the value we expect to be in an {@link java.util.OptionalDouble}. + * @return a error message factory. + */ + public static OptionalDoubleShouldHaveValueCloseToPercentage shouldHaveValueCloseToPercentage(double expectedValue) { + return new OptionalDoubleShouldHaveValueCloseToPercentage(expectedValue); + } + + /** + * Indicates that the provided {@link java.util.OptionalDouble} has a value, but it is not within the given positive + * percentage. + * + * @param optional the {@link java.util.OptionalDouble} which has a value + * @param expectedValue the value we expect to be in the provided {@link java.util.OptionalDouble} + * @param percentage the given positive percentage + * @param difference the effective distance between actual and expected + * @return an error message factory + */ + public static OptionalDoubleShouldHaveValueCloseToPercentage shouldHaveValueCloseToPercentage(OptionalDouble optional, + double expectedValue, + Percentage percentage, + double difference) { + double actualPercentage = difference / expectedValue * 100d; + return new OptionalDoubleShouldHaveValueCloseToPercentage(optional, expectedValue, percentage, actualPercentage); + } +} diff --git a/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseTo_Test.java b/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToOffset_Test.java similarity index 89% rename from src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseTo_Test.java rename to src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToOffset_Test.java index 632c0b25e7..be78b53a72 100644 --- a/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseTo_Test.java +++ b/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToOffset_Test.java @@ -17,16 +17,17 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.assertj.core.api.Assertions.assertThatNullPointerException; import static org.assertj.core.api.Assertions.within; -import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseTo.shouldHaveValueCloseTo; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToOffset.shouldHaveValueCloseToOffset; import static org.assertj.core.util.FailureMessages.actualIsNull; import java.util.OptionalDouble; import org.assertj.core.api.BaseTest; import org.assertj.core.data.Offset; +import org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToOffset; import org.junit.jupiter.api.Test; -public class OptionalDoubleAssert_hasValueCloseTo_Test extends BaseTest { +public class OptionalDoubleAssert_hasValueCloseToOffset_Test extends BaseTest { @Test public void should_fail_when_optionaldouble_is_null() { @@ -39,7 +40,7 @@ public void should_fail_if_optionaldouble_is_empty() { double expectedValue = 10.0; assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(OptionalDouble.empty()).hasValueCloseTo(expectedValue, within(2.0))) - .withMessage(shouldHaveValueCloseTo(expectedValue).create()); + .withMessage(shouldHaveValueCloseToOffset(expectedValue).create()); } @Test @@ -50,14 +51,15 @@ public void should_fail_if_actual_is_not_close_enough_to_expected_value() { assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(actual).hasValueCloseTo(expectedValue, offset)) - .withMessage(shouldHaveValueCloseTo(actual, expectedValue, offset, + .withMessage(shouldHaveValueCloseToOffset(actual, expectedValue, offset, abs(expectedValue - actual.getAsDouble())).create()); } @Test public void should_fail_if_offset_is_null() { - assertThatNullPointerException().isThrownBy(() -> assertThat(OptionalDouble.of(10.0)).hasValueCloseTo(10.0, null)); + Offset offset = null; + assertThatNullPointerException().isThrownBy(() -> assertThat(OptionalDouble.of(10.0)).hasValueCloseTo(10.0, offset)); } @Test diff --git a/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToPercentage_Test.java b/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToPercentage_Test.java new file mode 100644 index 0000000000..99cdd3f6f1 --- /dev/null +++ b/src/test/java/org/assertj/core/api/optionaldouble/OptionalDoubleAssert_hasValueCloseToPercentage_Test.java @@ -0,0 +1,207 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * Copyright 2012-2018 the original author or authors. + */ +package org.assertj.core.api.optionaldouble; + +import static java.lang.Double.NEGATIVE_INFINITY; +import static java.lang.Double.NaN; +import static java.lang.Double.POSITIVE_INFINITY; +import static java.lang.Math.abs; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; +import static org.assertj.core.api.Assertions.assertThatNullPointerException; +import static org.assertj.core.api.Assertions.withinPercentage; +import static org.assertj.core.data.Percentage.withPercentage; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToPercentage.shouldHaveValueCloseToPercentage; +import static org.assertj.core.util.AssertionsUtil.assertThatAssertionErrorIsThrownBy; +import static org.assertj.core.util.FailureMessages.actualIsNull; + +import java.util.OptionalDouble; + +import org.assertj.core.api.BaseTest; +import org.assertj.core.api.ThrowableAssertAlternative; +import org.assertj.core.data.Percentage; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +public class OptionalDoubleAssert_hasValueCloseToPercentage_Test extends BaseTest { + + @Test + public void should_fail_when_actual_is_null() { + // GIVEN + OptionalDouble actual = null; + double expectedValue = 10; + Percentage percentage = withinPercentage(5); + // THEN + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(actualIsNull()); + } + + @Test + public void should_fail_when_actual_is_empty() { + // GIVEN + OptionalDouble actual = OptionalDouble.empty(); + double expectedValue = 10; + Percentage percentage = withinPercentage(5); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(expectedValue).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_fail_when_expected_is_null() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(5); + Double expectedValue = null; + Percentage percentage = withinPercentage(5); + // THEN + assertThatNullPointerException().isThrownBy(() -> assertThat(actual).hasValueCloseTo(expectedValue, percentage)); + } + + @Test + public void should_fail_when_percentage_is_null() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(5); + double expectedValue = 5; + Percentage percentage = null; + // THEN + assertThatNullPointerException().isThrownBy(() -> assertThat(actual).hasValueCloseTo(expectedValue, percentage)); + } + + @Test + public void should_fail_when_percentage_is_negative() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(5); + double expectedValue = 5; + // THEN + assertThatIllegalArgumentException().isThrownBy(() -> assertThat(actual).hasValueCloseTo(expectedValue, withPercentage(-5))); + } + + @ParameterizedTest + @CsvSource({ + "1, 1, 1", + "1, 2, 100", + "-1, -1, 1", + "-1, -2, 100", + "-1, 1, 200" + }) + public void should_pass_when_difference_is_less_than_given_percentage(Double value, Double other, Double percentage) { + assertThat(OptionalDouble.of(value)).hasValueCloseTo(other, withinPercentage(percentage)); + } + + @ParameterizedTest + @CsvSource({ + "1, 1, 0", + "2, 1, 100", + "1, 2, 50", + "-1, -1, 0", + "-2, -1, 100", + "-1, -2, 50" + }) + public void should_pass_when_difference_is_equal_to_given_percentage(Double value, Double other, Double percentage) { + assertThat(OptionalDouble.of(value)).hasValueCloseTo(other, withinPercentage(percentage)); + } + + @Test + public void should_fail_if_actual_is_not_close_enough_to_expected_value() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(1); + double expectedValue = 10; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_fail_if_actual_is_NaN_and_expected_is_not() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(NaN); + double expectedValue = 1; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_pass_if_actual_and_expected_are_NaN() { + assertThat(OptionalDouble.of(NaN)).hasValueCloseTo(NaN, withPercentage(10)); + } + + @Test + public void should_fail_if_actual_is_POSITIVE_INFINITY_and_expected_is_not() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(POSITIVE_INFINITY); + double expectedValue = 1; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_pass_if_actual_and_expected_are_POSITIVE_INFINITY() { + assertThat(OptionalDouble.of(POSITIVE_INFINITY)).hasValueCloseTo(POSITIVE_INFINITY, withPercentage(10)); + } + + @Test + public void should_fail_if_actual_is_NEGATIVE_INFINITY_and_expected_is_not() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(NEGATIVE_INFINITY); + double expectedValue = 1; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_pass_if_actual_and_expected_are_NEGATIVE_INFINITY() { + assertThat(OptionalDouble.of(NEGATIVE_INFINITY)).hasValueCloseTo(NEGATIVE_INFINITY, withPercentage(10)); + } + + @Test + public void should_fail_if_actual_is_POSITIVE_INFINITY_and_expected_is_NEGATIVE_INFINITY() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(POSITIVE_INFINITY); + double expectedValue = NEGATIVE_INFINITY; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + @Test + public void should_fail_if_actual_is_NEGATIVE_INFINITY_and_expected_is_POSITIVE_INFINITY() { + // GIVEN + OptionalDouble actual = OptionalDouble.of(NEGATIVE_INFINITY); + double expectedValue = POSITIVE_INFINITY; + Percentage percentage = withPercentage(10); + // THEN + String errorMessage = shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, + abs(expectedValue - actual.getAsDouble())).create(); + hasValueCloseToThrowsAssertionError(actual, expectedValue, percentage).withMessage(errorMessage); + } + + private static ThrowableAssertAlternative hasValueCloseToThrowsAssertionError(OptionalDouble actual, + double expectedValue, + Percentage percentage) { + return assertThatAssertionErrorIsThrownBy(() -> assertThat(actual).hasValueCloseTo(expectedValue, percentage)); + } + +} diff --git a/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo_create_Test.java b/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset_create_Test.java similarity index 84% rename from src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo_create_Test.java rename to src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset_create_Test.java index de0729b71d..6112de1a23 100644 --- a/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseTo_create_Test.java +++ b/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToOffset_create_Test.java @@ -19,13 +19,13 @@ import static java.lang.String.format; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.within; -import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseTo.shouldHaveValueCloseTo; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToOffset.shouldHaveValueCloseToOffset; -public class OptionalDoubleShouldHaveValueCloseTo_create_Test { +public class OptionalDoubleShouldHaveValueCloseToOffset_create_Test { @Test public void should_create_error_message_when_optionaldouble_is_empty() { - String errorMessage = shouldHaveValueCloseTo(10.0).create(); + String errorMessage = shouldHaveValueCloseToOffset(10.0).create(); assertThat(errorMessage).isEqualTo(format("%nExpecting an OptionalDouble with value:%n" + " <10.0>%n" + "but was empty.")); @@ -33,7 +33,7 @@ public void should_create_error_message_when_optionaldouble_is_empty() { @Test public void should_create_error_message() { - String errorMessage = shouldHaveValueCloseTo(OptionalDouble.of(20.0), 10.0, within(2.0), 3).create(); + String errorMessage = shouldHaveValueCloseToOffset(OptionalDouble.of(20.0), 10.0, within(2.0), 3).create(); assertThat(errorMessage).isEqualTo(format("%nExpecting:%n %nto be close to:%n <10.0>%n" + "by less than <2.0> but difference was <3.0>.%n" + "(a difference of exactly <2.0> being considered valid)")); diff --git a/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage_create_Test.java b/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage_create_Test.java new file mode 100644 index 0000000000..7b07f9d841 --- /dev/null +++ b/src/test/java/org/assertj/core/error/OptionalDoubleShouldHaveValueCloseToPercentage_create_Test.java @@ -0,0 +1,44 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * Copyright 2012-2018 the original author or authors. + */ +package org.assertj.core.error; + +import static java.lang.String.format; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.withinPercentage; +import static org.assertj.core.error.OptionalDoubleShouldHaveValueCloseToPercentage.shouldHaveValueCloseToPercentage; + +import java.util.OptionalDouble; + +import org.junit.jupiter.api.Test; + +public class OptionalDoubleShouldHaveValueCloseToPercentage_create_Test { + + @Test + public void should_create_error_message_when_optionaldouble_is_empty() { + String errorMessage = shouldHaveValueCloseToPercentage(10.0).create(); + assertThat(errorMessage).isEqualTo(format("%nExpecting an OptionalDouble with value:%n" + + " <10.0>%n" + + "but was empty.")); + } + + @Test + public void should_create_error_message_when_optionaldouble_value_is_not_close_enough_to_expected_value() { + String errorMessage = shouldHaveValueCloseToPercentage(OptionalDouble.of(20), 10, withinPercentage(2), 3).create(); + assertThat(errorMessage).isEqualTo(format("%nExpecting:%n %n" + + "to be close to:%n" + + " <10.0>%n" + + "by less than 2%% but difference was 30.0%%.%n" + + "(a difference of exactly 2%% being considered valid)")); + } +} +