Added a full suite of frontend tests

(Added tests for the settings and unit/prefix viewer parts of the GUI, which are
not yet implemented)

1 files changed, 198 insertions, 12 deletions

diff --git a/src/test/java/sevenUnitsGUI/PresenterTest.java b/src/test/java/sevenUnitsGUI/PresenterTest.java
index 3fe7e47..85ebe09 100644
--- a/src/test/java/sevenUnitsGUI/PresenterTest.java
+++ b/src/test/java/sevenUnitsGUI/PresenterTest.java
@@ -17,20 +17,29 @@
 package sevenUnitsGUI;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import sevenUnits.unit.BaseDimension;
+import sevenUnits.unit.BritishImperial;
 import sevenUnits.unit.Metric;
 import sevenUnits.unit.Unit;
+import sevenUnits.unit.UnitType;
 import sevenUnits.unit.UnitValue;
+import sevenUnits.utils.NameSymbol;
 import sevenUnits.utils.Nameable;
 import sevenUnits.utils.ObjectProduct;
+import sevenUnits.utils.UncertainDouble;
 
 /**
  * @author Adrien Hopkins
@@ -38,12 +47,27 @@ import sevenUnits.utils.ObjectProduct;
  * @since 2022-02-10
  */
 public final class PresenterTest {
+	private static final Path TEST_SETTINGS = Path.of("src", "test", "resources",
+			"test-settings.txt");
 	static final Set<Unit> testUnits = Set.of(Metric.METRE, Metric.KILOMETRE,
 			Metric.METRE_PER_SECOND, Metric.KILOMETRE_PER_HOUR);
 	
 	static final Set<ObjectProduct<BaseDimension>> testDimensions = Set
 			.of(Metric.Dimensions.LENGTH, Metric.Dimensions.VELOCITY);
 	
+	/**
+	 * @return rounding rules used by {@link #testRoundingRules}
+	 * @since 2022-04-16
+	 */
+	private static final Stream<Function<UncertainDouble, String>> getRoundingRules() {
+		final var SCIENTIFIC_ROUNDING = StandardDisplayRules.getScientificRule();
+		final var INTEGER_ROUNDING = StandardDisplayRules.getFixedPlacesRule(0);
+		final var SIG_FIG_ROUNDING = StandardDisplayRules
+				.getFixedPrecisionRule(4);
+		
+		return Stream.of(SCIENTIFIC_ROUNDING, INTEGER_ROUNDING, SIG_FIG_ROUNDING);
+	}
+	
 	private static final Set<String> names(Set<? extends Nameable> units) {
 		return units.stream().map(Nameable::getName).collect(Collectors.toSet());
 	}
@@ -106,23 +130,185 @@ public final class PresenterTest {
 		assertEquals(List.of(expectedUC), viewBot.unitConversionList());
 	}
 	
+	/**
+	 * Tests that duplicate units are successfully removed, if that is asked for
+	 * 
+	 * @since 2022-04-16
+	 */
 	@Test
 	void testDuplicateUnits() {
-		assumeTrue(false, "Not yet implemented");
-		/*
-		 * enable and disable duplicate units and check for those in From and To,
-		 * include duplicate units in the input set
-		 */
+		final var metre = Metric.METRE;
+		final var meter = Metric.METRE.withName(NameSymbol.of("meter", "m"));
+		
+		// load 2 duplicate units
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		presenter.database.clear();
+		presenter.database.addUnit("metre", metre);
+		presenter.database.addUnit("meter", meter);
+		
+		// test that only one of them is included if duplicate units disabled
+		presenter.setShowDuplicateUnits(false);
+		presenter.updateView();
+		assertEquals(1, viewBot.getFromUnitNames().size());
+		assertEquals(1, viewBot.getToUnitNames().size());
+		
+		// test that both of them is included if duplicate units enabled
+		presenter.setShowDuplicateUnits(true);
+		presenter.updateView();
+		assertEquals(2, viewBot.getFromUnitNames().size());
+		assertEquals(2, viewBot.getToUnitNames().size());
 	}
 	
+	/**
+	 * Tests that one-way conversion correctly filters From and To units
+	 * 
+	 * @since 2022-04-16
+	 */
 	@Test
 	void testOneWayConversion() {
-		assumeTrue(false, "Not yet implemented");
-		/*
-		 * enable and disable one-way conversion, testing the units in From and To
-		 * on each setting to ensure they match the rule. Include at least one
-		 * metric exception.
-		 */
+		// metre is metric, inch is non-metric, tempC is semi-metric
+		final var allNames = Set.of("metre", "inch", "tempC");
+		final var metricNames = Set.of("metre", "tempC");
+		final var nonMetricNames = Set.of("inch", "tempC");
+		
+		// load view with one metric and one non-metric unit
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		presenter.database.clear();
+		presenter.database.addUnit("metre", Metric.METRE);
+		presenter.database.addUnit("inch", BritishImperial.Length.INCH);
+		presenter.database.addUnit("tempC", Metric.CELSIUS);
+		
+		// test that units are removed from each side when one-way conversion is
+		// enabled
+		presenter.setOneWayConversionEnabled(true);
+		presenter.updateView();
+		assertEquals(metricNames, viewBot.getFromUnitNames());
+		assertEquals(nonMetricNames, viewBot.getToUnitNames());
+		
+		// test that units are kept when one-way conversion is disabled
+		presenter.setOneWayConversionEnabled(false);
+		presenter.updateView();
+		assertEquals(allNames, viewBot.getFromUnitNames());
+		assertEquals(allNames, viewBot.getToUnitNames());
+	}
+	
+	/**
+	 * Tests the prefix-viewing functionality.
+	 * 
+	 * @since 2022-04-16
+	 */
+	@Test
+	void testPrefixViewing() {
+		// setup
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		viewBot.setViewablePrefixNames(Set.of("kilo", "milli"));
+		presenter.setNumberDisplayRule(UncertainDouble::toString);
+		
+		// view prefix
+		viewBot.setViewedPrefixName("kilo");
+		presenter.prefixSelected(); // just in case
+		
+		// get correct values
+		final var expectedNameSymbol = Metric.KILO.getNameSymbol();
+		final var expectedMultiplierString = String
+				.valueOf(Metric.KILO.getMultiplier());
+		
+		// test that presenter's values are correct
+		final var prefixRecord = viewBot.prefixViewList().get(0);
+		assertEquals(expectedNameSymbol, prefixRecord.getNameSymbol());
+		assertEquals(expectedMultiplierString, prefixRecord.multiplierString());
+	}
+	
+	/**
+	 * Tests that rounding rules are used correctly.
+	 * 
+	 * @since 2022-04-16
+	 */
+	@ParameterizedTest
+	@MethodSource("getRoundingRules")
+	void testRoundingRules(Function<UncertainDouble, String> roundingRule) {
+		// setup
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		presenter.setNumberDisplayRule(roundingRule);
+		
+		// convert and round
+		viewBot.setInputValue("12345.6789");
+		viewBot.setFromSelection("metre");
+		viewBot.setToSelection("kilometre");
+		presenter.convertUnits();
+		
+		// test the result of the rounding
+		final String expectedOutputString = roundingRule
+				.apply(UncertainDouble.of(12.3456789, 0));
+		final String actualOutputString = viewBot.unitConversionList().get(0)
+				.outputValueString();
+		assertEquals(expectedOutputString, actualOutputString);
+	}
+	
+	/**
+	 * Tests that settings can be saved to and loaded from a file.
+	 * 
+	 * @since 2022-04-16
+	 */
+	@Test
+	void testSettingsSaving() {
+		// setup
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		
+		// set and save custom settings
+		presenter.setOneWayConversionEnabled(true);
+		presenter.setShowDuplicateUnits(true);
+		presenter.setNumberDisplayRule(
+				StandardDisplayRules.getFixedPrecisionRule(11));
+		presenter.saveSettings(TEST_SETTINGS);
+		
+		// overwrite custom settings
+		presenter.setOneWayConversionEnabled(false);
+		presenter.setShowDuplicateUnits(false);
+		presenter.setNumberDisplayRule(StandardDisplayRules.getScientificRule());
+		
+		// load settings & test that they're the same
+		presenter.loadSettings(TEST_SETTINGS);
+		assertTrue(presenter.oneWayConversionEnabled());
+		assertTrue(presenter.duplicateUnitsShown());
+		assertEquals(StandardDisplayRules.getFixedPlacesRule(11),
+				presenter.getNumberDisplayRule());
+	}
+	
+	/**
+	 * Ensures the Presenter generates the correct data upon a unit-viewing.
+	 * 
+	 * @since 2022-04-16
+	 */
+	@Test
+	void testUnitViewing() {
+		// setup
+		final var viewBot = new ViewBot();
+		final var presenter = new Presenter(viewBot);
+		viewBot.setViewableUnitNames(names(testUnits));
+		
+		// view unit
+		viewBot.setViewedUnitName("metre");
+		presenter.unitNameSelected(); // just in case this isn't triggered
+												// automatically
+		
+		// get correct values
+		final var expectedNameSymbol = Metric.METRE.getNameSymbol();
+		final var expectedDefinition = Metric.METRE.toDefinitionString();
+		final var expectedDimensionName = Metric.METRE.getDimension().getName();
+		final var expectedUnitType = UnitType.METRIC;
+		
+		// test for correctness
+		final var viewRecord = viewBot.unitViewList().get(0);
+		assertEquals(expectedNameSymbol, viewRecord.getNameSymbol());
+		assertEquals(expectedDefinition, viewRecord.definition());
+		assertEquals(expectedDimensionName, viewRecord.dimensionName());
+		assertEquals(expectedUnitType, viewRecord.unitType());
 	}
 	
 	/**