Started with Unit tests

ScriptingExample/build.gradle

@@ -15,4 +15,13 @@ if (!hasProperty('mainClass')) {
 
 dependencies {
     compile project(':JavaIntegration')
+    testCompile group: "org.junit.jupiter", name: "junit-jupiter", version: "5.4.2"
+    testRuntime group: "org.junit.jupiter", name: "junit-jupiter", version: "5.4.2"
 }
+
+test {
+    useJUnitPlatform()
+    testLogging{
+        events "PASSED", "FAILED", "SKIPPED"
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/SharedGlobals.java

@@ -0,0 +1,14 @@
+package org.openzen.zenscript.scriptingexample.tests;
+
+import org.openzen.zencode.java.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class SharedGlobals {
+    
+    public static ZenCodeTestLogger currentlyActiveLogger;
+    
+    @ZenCodeGlobals.Global
+    public static void println(String s) {
+        currentlyActiveLogger.logPrintln(s);
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/HelloWorldTest.java

@@ -0,0 +1,16 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class HelloWorldTest extends ZenCodeTest {
+    
+    @Test
+    public void helloWorld() {
+        addScript("println('hello world');");
+        executeEngine();
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "hello world");
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/arithmethic_operators/AdditionTest.java

@@ -0,0 +1,28 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test.arithmethic_operators;
+
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.*;
+import org.junit.jupiter.params.provider.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class AdditionTest extends ZenCodeTest {
+    
+    @ParameterizedTest(name = "{0} + {1}")
+    @CsvSource({"0,0", "0,1", "10,10", "-1,1", "815,4711"})
+    public void testSomeAdditions(int i, int j) {
+        addScript(String.format("println(%d + %d);", i, j));
+        executeEngine();
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, String.valueOf(i + j));
+    }
+    
+    @Test
+    public void testChainedAdditions() {
+        addScript("println(1+2+3+4+5+6+7+8+9+10);");
+        executeEngine();
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, String.valueOf(55));
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/control_structures/LoopTest.java

@@ -0,0 +1,18 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test.control_structures;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class LoopTest extends ZenCodeTest {
+    
+    @Test
+    public void validateOutput() {
+        addScript("for i in 0 .. 100 println(i);");
+        executeEngine();
+        
+        logger.assertPrintOutputSize(100);
+        for(int i = 0; i < 100; i++) {
+            logger.assertPrintOutput(i, String.valueOf(i));
+        }
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/helpers/FunctionParameterList.java

@@ -0,0 +1,33 @@
+package org.openzen.zenscript.scriptingexample.tests.helpers;
+
+
+import org.openzen.zenscript.codemodel.*;
+
+import java.util.*;
+
+public class FunctionParameterList {
+    private final List<FunctionParameter> parameters;
+    private final List<Object> values;
+    
+    public FunctionParameterList() {
+        this.parameters = new ArrayList<>();
+        this.values = new ArrayList<>();
+    }
+    
+    public void addParameter(FunctionParameter parameter, Object value) {
+        parameters.add(parameter);
+        values.add(value);
+    }
+    
+    public FunctionParameter[] getParameters() {
+        return parameters.toArray(FunctionParameter.NONE);
+    }
+    
+    public Map<FunctionParameter, Object> getParameterMap() {
+        final Map<FunctionParameter, Object> results = new HashMap<>();
+        for(int i = 0; i < parameters.size(); i++) {
+            results.put(parameters.get(i), values.get(i));
+        }
+        return results;
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/helpers/ZenCodeTest.java

@@ -0,0 +1,80 @@
+package org.openzen.zenscript.scriptingexample.tests.helpers;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zencode.java.*;
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.codemodel.*;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.lexer.*;
+import org.openzen.zenscript.parser.*;
+import org.openzen.zenscript.scriptingexample.tests.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+import java.util.*;
+
+
+public abstract class ZenCodeTest {
+    
+    private final List<SourceFile> sourceFiles;
+    protected ScriptingEngine engine;
+    protected JavaNativeModule testModule;
+    protected ZenCodeTestLogger logger;
+    
+    protected ZenCodeTest() {
+        sourceFiles = new ArrayList<>();
+    }
+    
+    
+    @BeforeEach
+    public void beforeEach() throws CompileException {
+        this.logger = new ZenCodeTestLogger();
+        this.engine = new ScriptingEngine(logger);
+        this.testModule = engine.createNativeModule("test_module", "org.openzen.zenscript.scripting_tests");
+        SharedGlobals.currentlyActiveLogger = logger;
+        
+        getRequiredClasses().stream().distinct().forEach(requiredClass -> {
+            testModule.addGlobals(requiredClass);
+            testModule.addClass(requiredClass);
+        });
+        engine.registerNativeProvided(testModule);
+    }
+    
+    public void executeEngine() {
+        try {
+            final FunctionParameterList parameters = getParameters();
+            final SemanticModule script_tests = engine.createScriptedModule("script_tests", sourceFiles
+                    .toArray(new SourceFile[0]), getBEP(), parameters.getParameters());
+            
+            Assertions.assertTrue(script_tests.isValid(), "Scripts are not valid!");
+            engine.registerCompiled(script_tests);
+            engine.run(parameters.getParameterMap());
+        } catch(ParseException e) {
+            e.printStackTrace();
+            Assertions.fail("Error in Engine execution", e);
+        }
+        logger.setEngineComplete();
+    }
+    
+    public void addScript(String context) {
+        sourceFiles.add(new LiteralSourceFile("test_script_" + sourceFiles.size() + ".zs", context));
+    }
+    
+    
+    public BracketExpressionParser getBEP() {
+        return null;
+    }
+    
+    public FunctionParameterList getParameters() {
+        final FunctionParameterList functionParameterList = new FunctionParameterList();
+        final StoredType stringArrayType = engine.registry.getArray(StringTypeID.AUTO, 1).stored();
+        FunctionParameter args = new FunctionParameter(stringArrayType, "args");
+        functionParameterList.addParameter(args, new String[]{"a", "b", "c"});
+        return functionParameterList;
+    }
+    
+    public List<Class<?>> getRequiredClasses() {
+        final ArrayList<Class<?>> result = new ArrayList<>();
+        result.add(SharedGlobals.class);
+        return result;
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/helpers/ZenCodeTestLogger.java

@@ -0,0 +1,43 @@
+package org.openzen.zenscript.scriptingexample.tests.helpers;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zencode.java.logger.*;
+
+import java.util.*;
+
+public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
+    
+    private static final boolean logDebug = false;
+    private final List<String> printlnOutputs = new ArrayList<>();
+    private boolean isEngineComplete = false;
+    
+    @Override
+    public void debug(String message) {
+        if(logDebug) {
+            super.debug(message);
+        }
+    }
+    
+    public void logPrintln(String line) {
+        info(line);
+        this.printlnOutputs.addAll(Arrays.asList(line.split(System.lineSeparator())));
+    }
+    
+    void setEngineComplete() {
+        isEngineComplete = true;
+    }
+    
+    public void assertPrintOutput(int line, String content) {
+        if(!isEngineComplete) {
+            Assertions.fail("Trying to call an assertion before the engine ran, probably a fault in the test!");
+        }
+        Assertions.assertEquals(content, printlnOutputs.get(line));
+    }
+    
+    public void assertPrintOutputSize(int size) {
+        if(!isEngineComplete) {
+            Assertions.fail("Trying to call an assertion before the engine ran, probably a fault in the test!");
+        }
+        Assertions.assertEquals(size, printlnOutputs.size());
+    }
+}