Made BaseUnit a subclass of LinearUnit and made an expression parser

2 files changed, 116 insertions, 0 deletions

diff --git a/src/test/java/ExpressionParserTest.java b/src/test/java/ExpressionParserTest.java
new file mode 100644
index 0000000..e81ca40
--- /dev/null
+++ b/src/test/java/ExpressionParserTest.java
@@ -0,0 +1,50 @@
+/**
+ * Copyright (C) 2019 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 test.java;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.unitConverter.math.ExpressionParser;
+
+/**
+ * @author Adrien Hopkins
+ * @since 2019-03-22
+ */
+public class ExpressionParserTest {
+	private static final ExpressionParser<Integer> numberParser = new ExpressionParser.Builder<>(Integer::parseInt)
+			.addBinaryOperator("+", (o1, o2) -> o1 + o2, 0).addBinaryOperator("-", (o1, o2) -> o1 - o2, 0)
+			.addBinaryOperator("*", (o1, o2) -> o1 * o2, 1).addBinaryOperator("/", (o1, o2) -> o1 / o2, 1)
+			.addBinaryOperator("^", (o1, o2) -> (int) Math.pow(o1, o2), 2).build();
+
+	/**
+	 * Test method for {@link org.unitConverter.math.ExpressionParser#parseExpression(java.lang.String)}.
+	 */
+	@Test
+	public void testParseExpression() {
+		// test parsing of expressions
+		assertEquals((int) numberParser.parseExpression("1 + 2 ^ 5 * 3"), 97);
+		assertEquals((int) numberParser.parseExpression("(1 + 2) ^ 5 * 3"), 729);
+
+		// ensure it normally goes left to right
+		assertEquals((int) numberParser.parseExpression("1 + 2 + 3 + 4"), 10);
+		assertEquals((int) numberParser.parseExpression("12 - 4 - 3"), 5);
+		assertEquals((int) numberParser.parseExpression("12 - (4 - 3)"), 11);
+		assertEquals((int) numberParser.parseExpression("1 / 2 + 3"), 3);
+	}
+
+}
diff --git a/src/test/java/UnitTest.java b/src/test/java/UnitTest.java
index 45f890f..79bc3d1 100755
--- a/src/test/java/UnitTest.java
+++ b/src/test/java/UnitTest.java
@@ -18,10 +18,16 @@ package test.java;
 
 import static org.junit.Assert.assertEquals;
 
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
 import org.junit.Test;
 import org.unitConverter.dimension.StandardDimensions;
+import org.unitConverter.math.DecimalComparison;
 import org.unitConverter.unit.BaseUnit;
+import org.unitConverter.unit.LinearUnit;
 import org.unitConverter.unit.SI;
+import org.unitConverter.unit.SIPrefix;
 import org.unitConverter.unit.Unit;
 
 /**
@@ -31,12 +37,46 @@ import org.unitConverter.unit.Unit;
  * @since 2018-12-22
  */
 public class UnitTest {
+	/** A random number generator */
+	private static final Random rng = ThreadLocalRandom.current();
+
+	@Test
+	public void testAdditionAndSubtraction() {
+		final LinearUnit inch = SI.METRE.times(0.0254);
+		final LinearUnit foot = SI.METRE.times(0.3048);
+
+		assertEquals(inch.plus(foot), SI.METRE.times(0.3302));
+		assertEquals(foot.minus(inch), SI.METRE.times(0.2794));
+	}
+
+	@Test
+	public void testBaseUnitExclusives() {
+		// this test should have a compile error if I am doing something wrong
+		final BaseUnit metrePerSecondSquared = SI.METRE.dividedBy(SI.SECOND.toExponent(2));
+
+		assertEquals(metrePerSecondSquared, SI.SI.getBaseUnit(StandardDimensions.ACCELERATION));
+	}
+
 	@Test
 	public void testConversion() {
 		final BaseUnit metre = SI.METRE;
 		final Unit inch = metre.times(0.0254);
 
 		assertEquals(1.9, inch.convertToBase(75), 0.01);
+
+		// try random stuff
+		for (int i = 0; i < 1000; i++) {
+			// initiate random values
+			final double conversionFactor = rng.nextDouble() * 1000000;
+			final double testValue = rng.nextDouble() * 1000000;
+			final double expected = testValue * conversionFactor;
+
+			// test
+			final Unit unit = SI.METRE.times(conversionFactor);
+			final double actual = unit.convertToBase(testValue);
+
+			assertEquals(actual, expected, expected * DecimalComparison.DOUBLE_EPSILON);
+		}
 	}
 
 	@Test
@@ -46,4 +86,30 @@ public class UnitTest {
 
 		assertEquals(metre, meter);
 	}
+
+	@Test
+	public void testMultiplicationAndDivision() {
+		// test unit-times-unit multiplication
+		final LinearUnit generatedJoule = SI.KILOGRAM.times(SI.METRE.toExponent(2)).dividedBy(SI.SECOND.toExponent(2));
+		final LinearUnit actualJoule = SI.SI.getBaseUnit(StandardDimensions.ENERGY);
+
+		assertEquals(generatedJoule, actualJoule);
+
+		// test multiplication by conversion factors
+		final LinearUnit kilometre = SI.METRE.times(1000);
+		final LinearUnit hour = SI.SECOND.times(3600);
+		final LinearUnit generatedKPH = kilometre.dividedBy(hour);
+
+		final LinearUnit actualKPH = SI.SI.getBaseUnit(StandardDimensions.VELOCITY).dividedBy(3.6);
+
+		assertEquals(generatedKPH, actualKPH);
+	}
+
+	@Test
+	public void testPrefixes() {
+		final LinearUnit generatedKilometre = SI.METRE.withPrefix(SIPrefix.KILO);
+		final LinearUnit actualKilometre = SI.METRE.times(1000);
+
+		assertEquals(generatedKilometre, actualKilometre);
+	}
 }