Added tests for the new rounding rules

1 files changed, 253 insertions, 0 deletions

diff --git a/src/test/java/sevenUnitsGUI/RoundingTest.java b/src/test/java/sevenUnitsGUI/RoundingTest.java
new file mode 100644
index 0000000..d5cd669
--- /dev/null
+++ b/src/test/java/sevenUnitsGUI/RoundingTest.java
@@ -0,0 +1,253 @@
+/**
+ * Copyright (C) 2022 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package sevenUnitsGUI;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static sevenUnitsGUI.StandardDisplayRules.fixedDecimals;
+import static sevenUnitsGUI.StandardDisplayRules.fixedPrecision;
+import static sevenUnitsGUI.StandardDisplayRules.uncertaintyBased;
+
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import sevenUnits.utils.UncertainDouble;
+import sevenUnitsGUI.StandardDisplayRules.FixedDecimals;
+import sevenUnitsGUI.StandardDisplayRules.FixedPrecision;
+import sevenUnitsGUI.StandardDisplayRules.UncertaintyBased;
+
+/**
+ * Tests that ensure the rounding rules work as intended.
+ *
+ * @since v0.4.0
+ * @since 2022-07-17
+ */
+class RoundingTest {
+	// rounding rules to test
+	private static final FixedDecimals ZERO_DECIMALS = fixedDecimals(0);
+	private static final FixedDecimals TWO_DECIMALS = fixedDecimals(2);
+	private static final FixedDecimals SIX_DECIMALS = fixedDecimals(6);
+	
+	private static final FixedPrecision ONE_SIG_FIG = fixedPrecision(1);
+	private static final FixedPrecision THREE_SIG_FIGS = fixedPrecision(3);
+	private static final FixedPrecision TWELVE_SIG_FIGS = fixedPrecision(12);
+	
+	private static final UncertaintyBased UNCERTAINTY_BASED = uncertaintyBased();
+	
+	// numbers to test rounding with
+	private static final UncertainDouble INPUT1 = UncertainDouble.of(12.3456789,
+			0.0);
+	private static final UncertainDouble INPUT2 = UncertainDouble.of(300.9,
+			0.005);
+	private static final UncertainDouble INPUT3 = UncertainDouble.of(12345432.1,
+			0.0);
+	private static final UncertainDouble INPUT4 = UncertainDouble.of(0.00001234,
+			0.000001);
+	
+	/**
+	 * @return arguments for
+	 *         {@link #testFixedDecimalRounding(UncertainDouble, String, String, String)}
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	private static final Stream<Arguments> fixedDecimalRoundingExamples() {
+		// input, zero decimal string, two decimal string, six decimal string
+		return Stream.of(Arguments.of(INPUT1, "12", "12.35", "12.345679"),
+				Arguments.of(INPUT2, "301", "300.90", "300.900000"),
+				Arguments.of(INPUT3, "12345432", "12345432.10", "12345432.100000"),
+				Arguments.of(INPUT4, "0", "0.00", "0.000012"));
+	}
+	
+	/**
+	 * @return arguments for
+	 *         {@link #testFixedPrecisionRounding(UncertainDouble, String, String, String)}
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	private static final Stream<Arguments> fixedPrecisionRoundingExamples() {
+		// input, one sig fig string, three s.f. string, six s.f. string
+		return Stream.of(Arguments.of(INPUT1, "1E+1", "12.3", "12.3456789000"),
+				Arguments.of(INPUT2, "3E+2", "301", "300.900000000"),
+				Arguments.of(INPUT3, "1E+7", "1.23E+7", "12345432.1000"),
+				Arguments.of(INPUT4, "0.00001", "0.0000123", "0.0000123400000000"));
+	}
+	
+	/**
+	 * @return arguments for
+	 *         {@link #testUncertaintyRounding(UncertainDouble, String)}
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	private static final Stream<Arguments> uncertaintyRoundingExamples() {
+		// input, uncertainty rounding string
+		return Stream.of(Arguments.of(INPUT1, "12.3456789"),
+				Arguments.of(INPUT2, "300.900"),
+				Arguments.of(INPUT3, "1.23454321E7"),
+				Arguments.of(INPUT4, "0.0000123"));
+	}
+	
+	/**
+	 * Test for {@link FixedDecimals#decimalPlaces()} and
+	 * {@link FixedPrecision#significantFigures()}.
+	 *
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	@Test
+	void testDataMethods() {
+		// ensure # of decimal places can be accessed
+		assertEquals(0, ZERO_DECIMALS.decimalPlaces(),
+				"ZERO_DECIMALS has " + ZERO_DECIMALS.decimalPlaces() + " decimals");
+		assertEquals(2, TWO_DECIMALS.decimalPlaces(),
+				"TWO_DECIMALS has " + TWO_DECIMALS.decimalPlaces() + " decimals");
+		assertEquals(6, SIX_DECIMALS.decimalPlaces(),
+				"SIX_DECIMALS has " + SIX_DECIMALS.decimalPlaces() + " decimals");
+		
+		// ensure # of sig figs can be accessed
+		assertEquals(1, ONE_SIG_FIG.significantFigures(), "ONE_SIG_FIG has "
+				+ ONE_SIG_FIG.significantFigures() + " significant figures");
+		assertEquals(3, THREE_SIG_FIGS.significantFigures(), "THREE_SIG_FIGS has "
+				+ THREE_SIG_FIGS.significantFigures() + " significant figures");
+		assertEquals(12, TWELVE_SIG_FIGS.significantFigures(),
+				"TWELVE_SIG_FIGS has " + TWELVE_SIG_FIGS.significantFigures()
+						+ " significant figures");
+	}
+	
+	/**
+	 * Tests that the rounding methods' equals() methods work.
+	 * 
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	@Test
+	void testEquals() {
+		// basic equals tests
+		assertTrue(ZERO_DECIMALS.equals(ZERO_DECIMALS),
+				"ZERO_DECIMALS does not equal itself");
+		assertFalse(TWO_DECIMALS.equals(SIX_DECIMALS),
+				"TWO_DECIMALS == SIX_DECIMALS");
+		assertTrue(Objects.equals(fixedDecimals(0), fixedDecimals(0)),
+				"FixedDecimals.equals() depends on something other than decimal places.");
+		
+		assertTrue(ONE_SIG_FIG.equals(ONE_SIG_FIG),
+				"ONE_SIG_FIG does not equal itself");
+		assertFalse(THREE_SIG_FIGS.equals(TWELVE_SIG_FIGS),
+				"THREE_SIG_FIGS == TWELVE_SIG_FIGS");
+		assertTrue(Objects.equals(fixedPrecision(1), fixedPrecision(1)),
+				"FixedPrecision.equals() depends on something other than significant figures.");
+		
+		// test that FixedDecimals is never equal to FixedPrecision
+		// this unlikely argument is the test - the equals should return false!
+		@SuppressWarnings("unlikely-arg-type")
+		final boolean differentRulesEqual = Objects.equals(fixedDecimals(4),
+				fixedPrecision(4));
+		assertFalse(differentRulesEqual, "fixedDecimals(4) == fixedPrecision(4)");
+	}
+	
+	/**
+	 * Ensures that fixed decimal rounding works as expected
+	 *
+	 * @param input             number to test
+	 * @param zeroDecimalString expected string for zero decimal places
+	 * @param twoDecimalString  expected string for two decimal places
+	 * @param sixDecimalString  expected string for six decimal places
+	 * @since 2022-07-17
+	 */
+	@ParameterizedTest
+	@MethodSource("fixedDecimalRoundingExamples")
+	void testFixedDecimalRounding(UncertainDouble input,
+			String zeroDecimalString, String twoDecimalString,
+			String sixDecimalString) {
+		// test the three rounding rules against the provided strings
+		assertEquals(zeroDecimalString, ZERO_DECIMALS.apply(input),
+				"ZERO_DECIMALS rounded " + input + " as "
+						+ ZERO_DECIMALS.apply(input) + " (should be "
+						+ zeroDecimalString + ")");
+		assertEquals(twoDecimalString, TWO_DECIMALS.apply(input),
+				"TWO_DECIMALS rounded " + input + " as " + TWO_DECIMALS.apply(input)
+						+ " (should be " + twoDecimalString + ")");
+		assertEquals(sixDecimalString, SIX_DECIMALS.apply(input),
+				"TWO_DECIMALS rounded " + input + " as " + SIX_DECIMALS.apply(input)
+						+ " (should be " + sixDecimalString + ")");
+	}
+	
+	/**
+	 * Ensures that fixed precision rounding works as expected
+	 *
+	 * @param input              number to test
+	 * @param oneSigFigString    expected string for one significant figure
+	 * @param threeSigFigString  expected string for three significant figures
+	 * @param twelveSigFigString expected string for twelve significant figures
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	@ParameterizedTest
+	@MethodSource("fixedPrecisionRoundingExamples")
+	void testFixedPrecisionRounding(UncertainDouble input,
+			String oneSigFigString, String threeSigFigString,
+			String twelveSigFigString) {
+		// test the three rounding rules against the provided strings
+		assertEquals(oneSigFigString, ONE_SIG_FIG.apply(input),
+				"ONE_SIG_FIG rounded " + input + " as " + ONE_SIG_FIG.apply(input)
+						+ " (should be " + oneSigFigString + ")");
+		assertEquals(threeSigFigString, THREE_SIG_FIGS.apply(input),
+				"THREE_SIG_FIGS rounded " + input + " as "
+						+ THREE_SIG_FIGS.apply(input) + " (should be "
+						+ threeSigFigString + ")");
+		assertEquals(twelveSigFigString, TWELVE_SIG_FIGS.apply(input),
+				"TWELVE_SIG_FIGS rounded " + input + " as "
+						+ TWELVE_SIG_FIGS.apply(input) + " (should be "
+						+ twelveSigFigString + ")");
+	}
+	
+	/**
+	 * Tests that the {@code toString()} methods of the three rounding rule
+	 * classes work correctly.
+	 * 
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	@Test
+	void testToString() {
+		assertEquals("Round to 0 decimal places", ZERO_DECIMALS.toString());
+		assertEquals("Round to 3 significant figures", THREE_SIG_FIGS.toString());
+		assertEquals("Uncertainty-Based Rounding", UNCERTAINTY_BASED.toString());
+	}
+	
+	/**
+	 * Tests that Uncertainty Rounding works as expected
+	 *
+	 * @param input  input number
+	 * @param output expected output string
+	 * @since v0.4.0
+	 * @since 2022-07-17
+	 */
+	@ParameterizedTest
+	@MethodSource("uncertaintyRoundingExamples")
+	void testUncertaintyRounding(UncertainDouble input, String output) {
+		assertEquals(output, UNCERTAINTY_BASED.apply(input),
+				String.format(
+						"Uncertainty Rounding rounded %s as %s (should be %s)", input,
+						UNCERTAINTY_BASED.apply(input), output));
+	}
+}