Refactor tests

Author: MarcellPerger1

src/main/java/net/marcellperger/mathexpr/SymbolInfo.java

@@ -70,7 +70,6 @@ public enum SymbolInfo {
     private BinOpBiConstructor<?> biConstructorCache = null;
     public @NotNull BinOpBiConstructor<?> getBiConstructor() {
         if(biConstructorCache != null) return biConstructorCache;
-        // TODO could add a BiFunction<> arg to SymbolInfo(), then pass AddOperation::new etc.
         assert BinaryOperationLeftRight.class.isAssignableFrom(cls);
 
         Constructor<? extends BinaryOperationLeftRight> ctor;

src/test/java/net/marcellperger/mathexpr/parser/ParserTest.java

@@ -3,19 +3,16 @@
 import net.marcellperger.mathexpr.*;
 import net.marcellperger.mathexpr.util.Util;
 import net.marcellperger.mathexpr.util.UtilCollectors;
-
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -68,115 +65,91 @@ void assertInfixParsesToInner(String src, int level, MathSymbol expected) {
         assertEquals(expected, actual);
     }
 
-    @Test
-    void parseInfixPrecedenceLevel() {
-        assertInfixParsesTo("1.0/2.0", MUL_PREC,
-            new DivOperation(new BasicDoubleSymbol(1.0), new BasicDoubleSymbol(2.0)));
-        assertInfixParsesTo(".3*6.", MUL_PREC,
-            new MulOperation(new BasicDoubleSymbol(.3), new BasicDoubleSymbol(6.)));
-        assertInfixParsesTo("2.1*5.3+1.1", ADD_PREC,
-            new AddOperation(new MulOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(5.3)), new BasicDoubleSymbol(1.1)));
-        assertInfixParsesTo("0.9-2.1/.3", ADD_PREC,
-            new SubOperation(new BasicDoubleSymbol(0.9), new DivOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(.3))));
-        assertInfixParsesTo("(2.2+1.1)+3.7", ADD_PREC,
-            new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
-        assertInfixParsesTo(CommonData.getBigData1_groupingParens(), ADD_PREC);
-        assertInfixParsesTo(CommonData.getBigData2_groupingParens(), ADD_PREC);
-        assertInfixParsesTo("2.2+1.1+3.7", ADD_PREC,
-            new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
-        assertInfixParsesTo("2.2+1.1+3.7+0.2", ADD_PREC,
-            new AddOperation(new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)), new BasicDoubleSymbol(0.2)));
-        assertInfixParsesTo(CommonData.getBigData1_minimumParens(), ADD_PREC);
-        assertInfixParsesTo(CommonData.getBigData2_minimumParens(), ADD_PREC);
-        assertInfixParsesTo(".9/2./3.3", MUL_PREC,
-            new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
-        assertInfixParsesTo(".9/2./3.3", ADD_PREC,
-            new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
-    }
-
-    @Test
-    void parseInfixPrecedenceLevel_nocache() {
-        boolean origNocache = nocache;
-        nocache = true;
-        try {
-            parseInfixPrecedenceLevel();
-        } finally {
-            nocache = origNocache;
+    @ParameterizedTest
+    @ValueSource(booleans={true, false})
+    void parseInfixPrecedenceLevel(boolean disableCache) {
+        try(var ignored = new WithNocache(this, disableCache).start()) {
+            assertInfixParsesTo("1.0/2.0", MUL_PREC,
+                new DivOperation(new BasicDoubleSymbol(1.0), new BasicDoubleSymbol(2.0)));
+            assertInfixParsesTo(".3*6.", MUL_PREC,
+                new MulOperation(new BasicDoubleSymbol(.3), new BasicDoubleSymbol(6.)));
+            assertInfixParsesTo("2.1*5.3+1.1", ADD_PREC,
+                new AddOperation(new MulOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(5.3)), new BasicDoubleSymbol(1.1)));
+            assertInfixParsesTo("0.9-2.1/.3", ADD_PREC,
+                new SubOperation(new BasicDoubleSymbol(0.9), new DivOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(.3))));
+            assertInfixParsesTo("(2.2+1.1)+3.7", ADD_PREC,
+                new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
+            assertInfixParsesTo(CommonData.getBigData1_groupingParens(), ADD_PREC);
+            assertInfixParsesTo(CommonData.getBigData2_groupingParens(), ADD_PREC);
+            assertInfixParsesTo("2.2+1.1+3.7", ADD_PREC,
+                new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
+            assertInfixParsesTo("2.2+1.1+3.7+0.2", ADD_PREC,
+                new AddOperation(new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)), new BasicDoubleSymbol(0.2)));
+            assertInfixParsesTo(CommonData.getBigData1_minimumParens(), ADD_PREC);
+            assertInfixParsesTo(CommonData.getBigData2_minimumParens(), ADD_PREC);
+            assertInfixParsesTo(".9/2./3.3", MUL_PREC,
+                new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
+            assertInfixParsesTo(".9/2./3.3", ADD_PREC,
+                new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
         }
     }
 
-    @Test
-    void parsePrecedenceLevel() {
-        assertParsesTo("1.0/2.0",
-            new DivOperation(new BasicDoubleSymbol(1.0), new BasicDoubleSymbol(2.0)));
-        assertParsesTo(".3*6.",
-            new MulOperation(new BasicDoubleSymbol(.3), new BasicDoubleSymbol(6.)));
-        assertParsesTo("2.1*5.3+1.1",
-            new AddOperation(new MulOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(5.3)), new BasicDoubleSymbol(1.1)));
-        assertParsesTo("0.9-2.1/.3",
-            new SubOperation(new BasicDoubleSymbol(0.9), new DivOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(.3))));
-        assertParsesTo("(2.2+1.1)+3.7",
-            new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
-        assertParsesTo(CommonData.getBigData1_groupingParens());
-        assertParsesTo(CommonData.getBigData2_groupingParens());
-        assertParsesTo("2.2+1.1+3.7",
-            new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
-        assertParsesTo("2.2+1.1+3.7+0.2",
-            new AddOperation(new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)), new BasicDoubleSymbol(0.2)));
-        assertParsesTo(CommonData.getBigData1_minimumParens());
-        assertParsesTo(CommonData.getBigData2_minimumParens());
-        assertParsesTo(".9/2./3.3",
-            new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
-        assertParsesTo(".9/2./3.3",
-            new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
-    }
-
-    @Test  // TODO make this not test/inline it
-    void parsePrecedenceLevel_pow() {
-        assertInfixParsesTo("1.2**9.1", POW_PREC,
-            new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)));
-        assertInfixParsesTo("1.2**9.1**.3", POW_PREC,
-            new PowOperation(new BasicDoubleSymbol(1.2), new PowOperation(new BasicDoubleSymbol(9.1), new BasicDoubleSymbol(.3))));
-        assertInfixParsesTo("1.2**9.1+.3", ADD_PREC,
-            new AddOperation(new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)), new BasicDoubleSymbol(.3)));
-        assertInfixParsesTo(CommonData.getBigData3Pow_minimumParens(), ADD_PREC);
-        assertInfixParsesTo(CommonData.getBigData3Pow_groupingParens(), ADD_PREC);
-    }
-
-    @Test
-    void parse_pow() {
-        assertParsesTo("1.2**9.1",
-            new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)));
-        assertParsesTo("1.2**9.1**.3",
-            new PowOperation(new BasicDoubleSymbol(1.2), new PowOperation(new BasicDoubleSymbol(9.1), new BasicDoubleSymbol(.3))));
-        assertParsesTo("1.2**9.1+.3",
-            new AddOperation(new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)), new BasicDoubleSymbol(.3)));
-        assertParsesTo(CommonData.getBigData3Pow_minimumParens());
-        assertParsesTo(CommonData.getBigData3Pow_groupingParens());
-    }
-
     @ParameterizedTest
     @ValueSource(booleans={true, false})
-    void parsePrecedenceLevel_pow_nocache(boolean disableCache) {
-        try(var ignored = new WithNocache(this, disableCache)) {
-            parsePrecedenceLevel_pow();
+    void parse(boolean disableCache) {
+        try(var ignored = new WithNocache(this, disableCache).start()) {
+            assertParsesTo("1.0/2.0",
+                new DivOperation(new BasicDoubleSymbol(1.0), new BasicDoubleSymbol(2.0)));
+            assertParsesTo(".3*6.",
+                new MulOperation(new BasicDoubleSymbol(.3), new BasicDoubleSymbol(6.)));
+            assertParsesTo("2.1*5.3+1.1",
+                new AddOperation(new MulOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(5.3)), new BasicDoubleSymbol(1.1)));
+            assertParsesTo("0.9-2.1/.3",
+                new SubOperation(new BasicDoubleSymbol(0.9), new DivOperation(new BasicDoubleSymbol(2.1), new BasicDoubleSymbol(.3))));
+            assertParsesTo("(2.2+1.1)+3.7",
+                new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
+            assertParsesTo(CommonData.getBigData1_groupingParens());
+            assertParsesTo(CommonData.getBigData2_groupingParens());
+            assertParsesTo("2.2+1.1+3.7",
+                new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)));
+            assertParsesTo("2.2+1.1+3.7+0.2",
+                new AddOperation(new AddOperation(new AddOperation(new BasicDoubleSymbol(2.2), new BasicDoubleSymbol(1.1)), new BasicDoubleSymbol(3.7)), new BasicDoubleSymbol(0.2)));
+            assertParsesTo(CommonData.getBigData1_minimumParens());
+            assertParsesTo(CommonData.getBigData2_minimumParens());
+            assertParsesTo(".9/2./3.3",
+                new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
+            assertParsesTo(".9/2./3.3",
+                new DivOperation(new DivOperation(new BasicDoubleSymbol(.9), new BasicDoubleSymbol(2.)), new BasicDoubleSymbol(3.3)));
         }
     }
 
-    // TODO do more parameterized tests
     @ParameterizedTest
     @ValueSource(booleans={true, false})
-    void parse_pow_nocache(boolean disableCache) {
+    void parsePrecedenceLevel_pow(boolean disableCache) {
         try(var ignored = new WithNocache(this, disableCache)) {
-            parse_pow();
+            assertInfixParsesTo("1.2**9.1", POW_PREC,
+                new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)));
+            assertInfixParsesTo("1.2**9.1**.3", POW_PREC,
+                new PowOperation(new BasicDoubleSymbol(1.2), new PowOperation(new BasicDoubleSymbol(9.1), new BasicDoubleSymbol(.3))));
+            assertInfixParsesTo("1.2**9.1+.3", ADD_PREC,
+                new AddOperation(new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)), new BasicDoubleSymbol(.3)));
+            assertInfixParsesTo(CommonData.getBigData3Pow_minimumParens(), ADD_PREC);
+            assertInfixParsesTo(CommonData.getBigData3Pow_groupingParens(), ADD_PREC);
         }
     }
 
     @ParameterizedTest
     @ValueSource(booleans={true, false})
-    void parsePrecedenceLevel_nocache(boolean disableCache) {
-        try(var ignored = new WithNocache(this, disableCache)) {
-            parsePrecedenceLevel();
+    void parse_pow(boolean disableCache) {
+        try(var ignored = new WithNocache(this, disableCache).start()) {
+            assertParsesTo("1.2**9.1",
+                new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)));
+            assertParsesTo("1.2**9.1**.3",
+                new PowOperation(new BasicDoubleSymbol(1.2), new PowOperation(new BasicDoubleSymbol(9.1), new BasicDoubleSymbol(.3))));
+            assertParsesTo("1.2**9.1+.3",
+                new AddOperation(new PowOperation(new BasicDoubleSymbol(1.2), new BasicDoubleSymbol(9.1)), new BasicDoubleSymbol(.3)));
+            assertParsesTo(CommonData.getBigData3Pow_minimumParens());
+            assertParsesTo(CommonData.getBigData3Pow_groupingParens());
         }
     }
 
@@ -186,20 +159,22 @@ static class WithNocache implements AutoCloseable {
         ParserTest inst;
 
         WithNocache(ParserTest inst_) {
-            inst = inst_;
-            start();
+            this(inst_, true);
         }
         WithNocache(ParserTest inst_, boolean doDisable_) {
             inst = inst_;
             doDisable = doDisable_;
-            start();
         }
-        
+
         @Contract("->this")
         public WithNocache start() {
+            _start();
+            return this;
+        }
+
+        private void _start() {
             origNocache = inst.nocache;
             inst.nocache = doDisable;
-            return this;
         }
 
         public void close() {
@@ -235,12 +210,11 @@ public void close() {
         Map<SymbolInfo, Optional<BinOpBiConstructor<?>>> origCache = new HashMap<>();
         void clearCache() {
             Field cacheField = getBiConstructorCache();
-
-            origCache = Arrays.stream(SymbolInfo.values()).<Entry<SymbolInfo, Optional<BinOpBiConstructor<?>>>>map(sym -> {
+            origCache = Arrays.stream(SymbolInfo.values()).map(sym -> {
                 try {
                     @Nullable BinOpBiConstructor<?> cachedValue = (BinOpBiConstructor<?>)cacheField.get(sym);
                     cacheField.set(sym, null);
-                    return Util.makeEntry(sym, Optional.ofNullable(cachedValue));
+                    return Util.makeEntry(sym, Optional.<BinOpBiConstructor<?>>ofNullable(cachedValue));
                 } catch (IllegalAccessException e) {
                     throw Util.excToError(e);
                 }