Added a test to test loading unitfiles

1 files changed, 76 insertions, 10 deletions

diff --git a/src/test/java/sevenUnits/unit/UnitDatabaseTest.java b/src/test/java/sevenUnits/unit/UnitDatabaseTest.java
index 1d5e503..15bebcb 100644
--- a/src/test/java/sevenUnits/unit/UnitDatabaseTest.java
+++ b/src/test/java/sevenUnits/unit/UnitDatabaseTest.java
@@ -20,7 +20,10 @@ 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 static org.junit.jupiter.api.Assertions.fail;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
@@ -31,13 +34,6 @@ import java.util.Set;
 
 import org.junit.jupiter.api.Test;
 
-import sevenUnits.unit.LinearUnit;
-import sevenUnits.unit.NameSymbol;
-import sevenUnits.unit.Metric;
-import sevenUnits.unit.Unit;
-import sevenUnits.unit.UnitDatabase;
-import sevenUnits.unit.UnitPrefix;
-
 /**
  * A test for the {@link UnitDatabase} class. This is NOT part of this program's
  * public API.
@@ -54,12 +50,13 @@ class UnitDatabaseTest {
 	
 	// used for testing expressions
 	// J = U^2 * V / W^2
-	private static final LinearUnit J = Metric.KILOGRAM.times(Metric.METRE.toExponent(2))
+	private static final LinearUnit J = Metric.KILOGRAM
+			.times(Metric.METRE.toExponent(2))
 			.dividedBy(Metric.SECOND.toExponent(2));
 	private static final LinearUnit K = Metric.KELVIN;
 	
-	private static final Unit NONLINEAR = Unit
-			.fromConversionFunctions(Metric.METRE.getBase(), o -> o + 1, o -> o - 1);
+	private static final Unit NONLINEAR = Unit.fromConversionFunctions(
+			Metric.METRE.getBase(), o -> o + 1, o -> o - 1);
 	
 	// make the prefix values prime so I can tell which multiplications were made
 	private static final UnitPrefix A = UnitPrefix.valueOf(2)
@@ -72,6 +69,23 @@ class UnitDatabaseTest {
 	private static final UnitPrefix BC = UnitPrefix.valueOf(11);
 	
 	/**
+	 * Loads the unitfile at src/test/resources/[path] to the database
+	 * {@code loadTo}.
+	 *
+	 * @param loadTo database to load to
+	 * @param path   path of file to load
+	 * @since 2021-09-22
+	 */
+	private static void loadUnitsFile(UnitDatabase loadTo, String path) {
+		try (final InputStream testFile = UnitDatabaseTest.class
+				.getResourceAsStream(path)) {
+			loadTo.loadUnitsFromStream(testFile);
+		} catch (final IOException e) {
+			fail(e.getClass() + " occurred upon loading file \"" + path + "\".");
+		}
+	}
+	
+	/**
 	 * Confirms that operations that shouldn't function for infinite databases
 	 * throw an {@code IllegalStateException}.
 	 * 
@@ -98,6 +112,58 @@ class UnitDatabaseTest {
 	}
 	
 	/**
+	 * Tests loading a valid unitfile with some prefixes and no units.
+	 * 
+	 * @since 2021-09-22
+	 */
+	@Test
+	public void testLoadingValidPrefixes() {
+		final UnitDatabase database = new UnitDatabase();
+		
+		loadUnitsFile(database, "/test-unitsfile-valid2.txt");
+		assertEquals(7, database.getPrefix("A").getMultiplier());
+		assertEquals(11, database.getPrefix("B").getMultiplier());
+		assertEquals(13, database.getPrefix("C").getMultiplier());
+	}
+	
+	/**
+	 * Tests loading a valid unitfile with some units and preloaded prefixes
+	 * 
+	 * @since 2021-09-22
+	 */
+	@Test
+	public void testLoadingValidUnits() {
+		final UnitDatabase database = new UnitDatabase();
+		
+		database.addUnit("U", U);
+		database.addUnit("V", V);
+		database.addUnit("W", W);
+		database.addUnit("fj", J.times(5));
+		database.addUnit("ej", J.times(8));
+		
+		database.addPrefix("A", A);
+		database.addPrefix("B", B);
+		database.addPrefix("C", C);
+		
+		loadUnitsFile(database, "/test-unitsfile-valid1.txt");
+		
+		final Unit expected1 = ((LinearUnit) U).withPrefix(A).withPrefix(B)
+				.withPrefix(C);
+		final Unit actual1 = database.getUnit("test1");
+		assertEquals(expected1, actual1);
+		
+		final Unit expected2 = ((LinearUnit) W).withPrefix(B)
+				.times(((LinearUnit) V).withPrefix(C));
+		final Unit actual2 = database.getUnit("test2");
+		assertEquals(expected2, actual2);
+		
+		final Unit expected3 = ((LinearUnit) U)
+				.times(A.getMultiplier() + C.getMultiplier() - B.getMultiplier());
+		final Unit actual3 = database.getUnit("test3");
+		assertEquals(expected3, actual3);
+	}
+	
+	/**
 	 * Test that prefixes correctly apply to units.
 	 * 
 	 * @since 2019-04-14