Improve symbol generation testing and symbol check output (#108)

Author: fkleedorfer

qudtlib-test/src/test/java/io/github/qudtlib/FactorUnitsTests.java

@@ -431,22 +431,25 @@ public static Stream<Arguments> testSortAccordingToUnitLabel() {
                                 .getFactorUnits()));
     }
 
-    @Test
-    public void getSymbol() {
-        FactorUnits m1 = FactorUnits.ofFactorUnitSpec(M, 1);
-        Assertions.assertEquals("m", m1.getSymbol().get());
-
-        FactorUnits m_1 = FactorUnits.ofFactorUnitSpec(M, -1);
-        Assertions.assertEquals("/m", m_1.getSymbol().get());
-
-        FactorUnits m8 = FactorUnits.ofFactorUnitSpec(M, 8);
-        Assertions.assertEquals("m⁸", m8.getSymbol().get());
-
-        FactorUnits ms12 = FactorUnits.ofFactorUnitSpec(MilliSEC, 12);
-        Assertions.assertEquals("ms¹²", ms12.getSymbol().get());
+    @ParameterizedTest
+    @MethodSource
+    public void getSymbol(String expectedSymbol, FactorUnits factorUnits) {
+        Assertions.assertEquals(
+                expectedSymbol,
+                factorUnits.getSymbol().orElse("[no symbol]"),
+                String.format(
+                        "Factor units %s should return %s for getSymbol()",
+                        factorUnits, expectedSymbol));
+    }
 
-        FactorUnits ms_9 = FactorUnits.ofFactorUnitSpec(MilliSEC, -9);
-        Assertions.assertEquals("/ms⁹", ms_9.getSymbol().get());
+    public static Stream<Arguments> getSymbol() {
+        return Stream.of(
+                Arguments.of("m", FactorUnits.ofFactorUnitSpec(M, 1)),
+                Arguments.of("/m", FactorUnits.ofFactorUnitSpec(M, -1)),
+                Arguments.of("m⁸", FactorUnits.ofFactorUnitSpec(M, 8)),
+                Arguments.of("ms¹²", FactorUnits.ofFactorUnitSpec(MilliSEC, 12)),
+                Arguments.of("/ms⁹", FactorUnits.ofFactorUnitSpec(MilliSEC, -9)),
+                Arguments.of("ft·h/gal{UK}", FT__HR__PER__GAL_UK.getFactorUnits()));
     }
 
     @ParameterizedTest

qudtlib-tools/src/main/java/io/github/qudtlib/tools/contributions/CheckSymbols.java

@@ -43,19 +43,23 @@ public static void main(String[] args) {
                         unitsToCheck.stream()
                                 .filter(u -> !globalData.correctUnits.contains(u))
                                 .forEach(unit -> checkUnit(unit, globalData, ttlPrintStream));
-                        System.out.println(
-                                String.format(
-                                        "was incorrect: \n%s\n",
-                                        globalData.wasIncorrect.stream()
-                                                .map(Unit::getIriAbbreviated)
-                                                .collect(Collectors.joining("\n"))));
-                        System.out.println(
-                                String.format(
-                                        "was missing: \n%s\n",
-                                        globalData.wasMissing.stream()
-                                                .map(Unit::getIriAbbreviated)
-                                                .collect(Collectors.joining("\n"))));
                     }
+                    System.out.println(
+                            String.format(
+                                    "# %d Units with incorrect symbol: \n%s\n",
+                                    globalData.wasIncorrect.size(),
+                                    globalData.wasIncorrect.stream()
+                                            .sorted(Comparator.comparing(Unit::getIriLocalname))
+                                            .map(Unit::getIriAbbreviated)
+                                            .collect(Collectors.joining("\n# ", "\n# ", "\n"))));
+                    System.out.println(
+                            String.format(
+                                    "# %d Units without symbol: \n%s\n",
+                                    globalData.wasMissing.size(),
+                                    globalData.wasMissing.stream()
+                                            .sorted(Comparator.comparing(Unit::getIriLocalname))
+                                            .map(Unit::getIriAbbreviated)
+                                            .collect(Collectors.joining("\n# ", "\n#", "\n"))));
                 });
         globalData.missingData.entrySet().stream()
                 .sorted(
@@ -84,7 +88,7 @@ private static Predicate<Unit> isLikelyDerivedUnit() {
     }
 
     private static void printStatements(ByteArrayOutputStream ttlOut) {
-        System.out.println("STATEMENTS TO ADD:\n\n");
+        System.out.println("# STATEMENTS TO ADD:\n\n");
         System.out.println(ttlOut.toString());
     }
 
@@ -107,24 +111,24 @@ private static void checkUnit(Unit unit, GlobalData globalData, PrintStream ttlP
         if (!globalData.trustCalculationForUnit(unit)) {
             return;
         }
-        Optional<String> calculatedSymbol =
-                unit.getSymbol().or(() -> unit.getFactorUnits().getSymbol());
+        Optional<String> calculatedSymbol = unit.getFactorUnits().getSymbol();
         if (calculatedSymbol.isEmpty()) {
             return;
         } else {
             if (unit.getSymbol().isPresent()) {
                 String actualSymbol = unit.getSymbol().get();
-                globalData.correctUnits.add(unit);
                 boolean isRelevantDifference = !actualSymbol.equals(calculatedSymbol.get());
                 if (isRelevantDifference) {
                     commentsForTTl.println(
                             format(
-                                    "WRONG SYMBOL?  : %s - calculated from factors: %s, actual: %s\n",
+                                    "WRONG SYMBOL  : %s - calculated from factors: %s, actual: %s\n",
                                     unit.getIriAbbreviated(),
                                     calculatedSymbol.get().toString(),
                                     actualSymbol.toString()));
-                    commentsForTTl.println("Here is the triple you might want to use instead:");
-                    printSymbolTriple(commentsForTTl, commentsForTTl, unit, calculatedSymbol.get());
+                    printSymbolTriple(ttlPrintStream, commentsForTTl, unit, calculatedSymbol.get());
+                    globalData.wasIncorrect.add(unit);
+                } else {
+                    globalData.correctUnits.add(unit);
                 }
             } else {
                 commentsForTTl.println(

qudtlib-tools/src/main/java/io/github/qudtlib/tools/contributions/GlobalData.java

@@ -11,9 +11,7 @@ public class GlobalData {
 
     final Map<Unit, Set<Unit>> unitDependencies;
     final String relativeDifferenceThreshold = "0.001";
-    final Set<Unit> undecidedUnits = new HashSet<>();
     final Set<Unit> correctUnits = new HashSet<>();
-    final Set<Unit> incorrectUnits = new HashSet<>();
 
     final Set<Unit> wasIncorrect = new HashSet<>();
     final Set<Unit> wasMissing = new HashSet<>();