Merge branch 'develop'

1 files changed, 153 insertions, 0 deletions

diff --git a/src/test/java/sevenUnits/unit/UnitTest.java b/src/test/java/sevenUnits/unit/UnitTest.java
new file mode 100644
index 0000000..a980054
--- /dev/null
+++ b/src/test/java/sevenUnits/unit/UnitTest.java
@@ -0,0 +1,153 @@
+/**
+ * Copyright (C) 2018 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.unit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.junit.jupiter.api.Test;
+
+import sevenUnits.unit.LinearUnit;
+import sevenUnits.unit.LinearUnitValue;
+import sevenUnits.unit.NameSymbol;
+import sevenUnits.unit.Metric;
+import sevenUnits.unit.Unit;
+import sevenUnits.unit.UnitValue;
+import sevenUnits.utils.DecimalComparison;
+
+/**
+ * Testing the various Unit classes. This is NOT part of this program's public
+ * API.
+ * 
+ * @author Adrien Hopkins
+ * @since 2018-12-22
+ * @since v0.1.0
+ */
+class UnitTest {
+	/** A random number generator */
+	private static final Random rng = ThreadLocalRandom.current();
+	
+	@Test
+	public void testAdditionAndSubtraction() {
+		final LinearUnit inch = Metric.METRE.times(0.0254)
+				.withName(NameSymbol.of("inch", "in"));
+		final LinearUnit foot = Metric.METRE.times(0.3048)
+				.withName(NameSymbol.of("foot", "ft"));
+		
+		assertEquals(inch.plus(foot), Metric.METRE.times(0.3302));
+		assertEquals(foot.minus(inch), Metric.METRE.times(0.2794));
+		
+		// test with LinearUnitValue
+		final LinearUnitValue value1 = LinearUnitValue.getExact(Metric.METRE, 15);
+		final LinearUnitValue value2 = LinearUnitValue.getExact(foot, 120);
+		final LinearUnitValue value3 = LinearUnitValue.getExact(Metric.METRE, 0.5);
+		final LinearUnitValue value4 = LinearUnitValue.getExact(Metric.KILOGRAM, 60);
+		
+		// make sure addition is done correctly
+		assertEquals(51.576, value1.plus(value2).getValueExact(), 0.001);
+		assertEquals(15.5, value1.plus(value3).getValueExact());
+		assertEquals(52.076, value1.plus(value2).plus(value3).getValueExact(),
+				0.001);
+		
+		// make sure addition uses the correct unit, and is still associative
+		// (ignoring floating-point rounding errors)
+		assertEquals(Metric.METRE, value1.plus(value2).getUnit());
+		assertEquals(Metric.METRE, value1.plus(value2).plus(value3).getUnit());
+		assertEquals(foot, value2.plus(value1).getUnit());
+		assertTrue(value1.plus(value2).equals(value2.plus(value1), true));
+		
+		// make sure errors happen when they should
+		assertThrows(IllegalArgumentException.class, () -> value1.plus(value4));
+	}
+	
+	@Test
+	public void testConversion() {
+		final LinearUnit metre = Metric.METRE;
+		final Unit inch = metre.times(0.0254);
+		
+		final UnitValue value = UnitValue.of(inch, 75);
+		
+		assertEquals(1.9, inch.convertTo(metre, 75), 0.01);
+		assertEquals(1.9, value.convertTo(metre).getValue(), 0.01);
+		
+		// try random stuff
+		for (int i = 0; i < 1000; i++) {
+			// initiate random values
+			final double conversionFactor = UnitTest.rng.nextDouble() * 1000000;
+			final double testValue = UnitTest.rng.nextDouble() * 1000000;
+			final double expected = testValue * conversionFactor;
+			
+			// test
+			final Unit unit = Metric.METRE.times(conversionFactor);
+			final double actual = unit.convertToBase(testValue);
+			
+			assertEquals(actual, expected,
+					expected * DecimalComparison.DOUBLE_EPSILON);
+		}
+	}
+	
+	@Test
+	public void testEquals() {
+		final LinearUnit metre = Metric.METRE;
+		final Unit meter = Metric.BaseUnits.METRE.asLinearUnit();
+		
+		assertEquals(metre, meter);
+	}
+	
+	@Test
+	public void testIsMetric() {
+		final Unit metre = Metric.METRE;
+		final Unit megasecond = Metric.SECOND.withPrefix(Metric.MEGA);
+		final Unit hour = Metric.HOUR;
+		
+		assertTrue(metre.isMetric());
+		assertTrue(megasecond.isMetric());
+		assertFalse(hour.isMetric());
+	}
+	
+	@Test
+	public void testMultiplicationAndDivision() {
+		// test unit-times-unit multiplication
+		final LinearUnit generatedJoule = Metric.KILOGRAM
+				.times(Metric.METRE.toExponent(2)).dividedBy(Metric.SECOND.toExponent(2));
+		final LinearUnit actualJoule = Metric.JOULE;
+		
+		assertEquals(generatedJoule, actualJoule);
+		
+		// test multiplication by conversion factors
+		final LinearUnit kilometre = Metric.METRE.times(1000);
+		final LinearUnit hour = Metric.SECOND.times(3600);
+		final LinearUnit generatedKPH = kilometre.dividedBy(hour);
+		
+		final LinearUnit actualKPH = Metric.METRE.dividedBy(Metric.SECOND).dividedBy(3.6);
+		
+		assertEquals(generatedKPH, actualKPH);
+	}
+	
+	@Test
+	public void testPrefixes() {
+		final LinearUnit generatedKilometre = Metric.METRE.withPrefix(Metric.KILO);
+		final LinearUnit actualKilometre = Metric.METRE.times(1000);
+		
+		assertEquals(generatedKilometre, actualKilometre);
+	}
+}