Added a full suite of tests for the UncertainDouble

1 files changed, 90 insertions, 0 deletions

diff --git a/src/test/java/sevenUnits/utils/UncertainDoubleTest.java b/src/test/java/sevenUnits/utils/UncertainDoubleTest.java
new file mode 100644
index 0000000..c891f20
--- /dev/null
+++ b/src/test/java/sevenUnits/utils/UncertainDoubleTest.java
@@ -0,0 +1,90 @@
+/**
+ * Copyright (C) 2021 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 sevenUnits.utils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static sevenUnits.utils.UncertainDouble.fromString;
+import static sevenUnits.utils.UncertainDouble.of;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for the UncertainDouble
+ *
+ * @author Adrien Hopkins
+ * @since 2021-11-29
+ */
+class UncertainDoubleTest {
+	@Test
+	final void testCompareTo() {
+		assertTrue(of(2.0, 0.5).compareTo(of(2.0, 0.1)) == 0);
+		assertTrue(of(2.0, 0.5).compareTo(of(1.0, 0.1)) > 0);
+		assertTrue(of(2.0, 0.5).compareTo(of(3.0, 0.1)) < 0);
+	}
+	
+	@Test
+	final void testExactOperations() {
+		final UncertainDouble x = UncertainDouble.of(Math.PI, 0.1);
+		
+		// slightly different because roundoff errors
+		final UncertainDouble x1 = UncertainDouble.of(Math.PI + Math.E - Math.E,
+				0.1);
+		final UncertainDouble x2 = UncertainDouble.of(Math.PI * Math.E / Math.E,
+				0.1);
+		
+		// get results
+		final UncertainDouble result1 = x.plusExact(Math.E).minusExact(Math.E);
+		final UncertainDouble result2 = x.timesExact(Math.E)
+				.dividedByExact(Math.E);
+		
+		// test that these operations work & don't change uncertainty
+		assertEquals(x1, result1);
+		assertTrue(x.equivalent(result1));
+		assertEquals(x2, result2);
+		assertTrue(x.equivalent(result2));
+		
+		// exponents are different
+		assertEquals(Math.pow(Math.PI, Math.E),
+				x.toExponentExact(Math.E).value());
+	}
+	
+	@Test
+	final void testFromString() {
+		// valid strings
+		assertEquals(of(2.0, 0.5), fromString("2.0 ± 0.5"));
+		assertEquals(of(2.0, 0.5), fromString("2.0 +- 0.5"));
+		assertEquals(of(2.0, 0.0), fromString("2.0"));
+		
+		// invalid strings
+		for (final String s : List.of("2.A", "A", "2.0 ± .", "± 3.5")) {
+			assertThrows(IllegalArgumentException.class, () -> fromString(s));
+		}
+		
+		// back and forth
+		assertEquals("2.0 ± 0.5", of(2.0, 0.5).toString());
+		assertEquals("2.0", of(2.0, 0).toString());
+	}
+	
+	@Test
+	final void testHashCode() {
+		assertEquals(of(2.0, 0.5).hashCode(), fromString("2.0 ± 0.5").hashCode());
+	}
+}