Some more tests for basic class members

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

@@ -112,6 +112,18 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
         }
+    
+        for(IDefinitionMember membersOfSameType : member.definition.members) {
+            if(membersOfSameType instanceof FieldMember) {
+                final FieldMember fieldMember = ((FieldMember) membersOfSameType);
+                final Expression initializer = fieldMember.initializer;
+                if(initializer != null) {
+                    constructorWriter.loadObject(0);
+                    initializer.accept(statementVisitor.expressionVisitor);
+                    constructorWriter.putField(context.getJavaField(fieldMember));
+                }
+            }
+        }
 
 		for (TypeParameter typeParameter : definition.typeParameters) {
 			final JavaTypeParameterInfo typeParameterInfo = javaModule.getTypeParameterInfo(typeParameter);

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

@@ -0,0 +1,90 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test.classes;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class AddingClasses extends ZenCodeTest {
+    
+    @Test
+    public void emptyClassCompiles() {
+        ScriptBuilder.create().add("public class SomeClass {").add("}").execute(this);
+        logger.assertNoErrors();
+    }
+    
+    @Test
+    public void memberGettable() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string;")
+                .add("    public this(){x = 'Hello World';}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertNoErrors();
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+    
+    @Test
+    public void functionCallable() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public this(){}")
+                .add("    public callMeMaybe() as void {println('Hello World!');}")
+                .add("}")
+                .add("")
+                .add("new SomeClass().callMeMaybe();")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World!");
+    }
+    
+    @Test
+    public void classAccessibleFromOtherScript() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public this(){}")
+                .add("    public callMeMaybe() as void {println('Hello World!');}")
+                .add("}")
+                .add("")
+                .startNewScript()
+                .add("new SomeClass().callMeMaybe();")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World!");
+    }
+    
+    @Test
+    public void fieldInitializerSetsField() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string = 'Hello World';")
+                .add("    public this(){}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+    
+    @Test
+    public void constructorOverridesFieldInitializer() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string = 'Hello World';")
+                .add("    public this(){this.x = 'Goodbye World';}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Goodbye World");
+    }
+}

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

@@ -0,0 +1,66 @@
+package org.openzen.zenscript.scriptingexample.tests.helpers;
+
+import java.util.*;
+
+public class ScriptBuilder {
+    
+    private final List<String> scripts;
+    private StringJoiner currentScriptJoiner;
+    
+    private ScriptBuilder() {
+        scripts = new ArrayList<>();
+        startNewScript();
+    }
+    
+    /**
+     * Creates a {@link StringJoiner} that merges with newlines.
+     * The only real reason for this to exist is that it allows code formatting to work properly lol
+     */
+    public static ScriptBuilder create() {
+        return new ScriptBuilder();
+    }
+    
+    public ScriptBuilder add(String line) {
+        currentScriptJoiner.add(line);
+        return this;
+    }
+    
+    public ScriptBuilder startNewScript() {
+        if(currentScriptJoiner != null) {
+            scripts.add(currentScriptJoiner.toString());
+        }
+        
+        currentScriptJoiner = new StringJoiner(System.lineSeparator());
+        return this;
+    }
+    
+    public void appendScriptsToTest(ZenCodeTest test) {
+        startNewScript();
+    
+        for(String script : scripts) {
+            test.addScript(script);
+        }
+    }
+    
+    public void execute(ZenCodeTest test, LogTolerance logTolerance) {
+        appendScriptsToTest(test);
+        test.executeEngine();
+        switch(logTolerance) {
+            case NO_WARNINGS:
+                test.logger.assertNoWarnings();
+            case NO_ERRORS:
+                test.logger.assertNoErrors();
+                break;
+            case ALLOW_ERRORS:
+                break;
+        }
+    }
+    
+    public void execute(ZenCodeTest test) {
+        execute(test, LogTolerance.NO_WARNINGS);
+    }
+    
+    public enum LogTolerance {
+        NO_WARNINGS, NO_ERRORS, ALLOW_ERRORS
+    }
+}

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

@@ -10,6 +10,7 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
     private static final boolean logDebug = false;
     private final List<String> printlnOutputs = new ArrayList<>();
     private final List<String> errors = new ArrayList<>();
+    private final List<String> warnings = new ArrayList<>();
     private boolean isEngineComplete = false;
     
     @Override
@@ -19,9 +20,21 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
         }
     }
     
+    @Override
+    public void warning(String message) {
+        warnings.add(message);
+        super.warning(message);
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        warnings.add(message);
+        super.throwingWarn(message, throwable);
+    }
+    
     public void logPrintln(String line) {
         info(line);
-        this.printlnOutputs.addAll(Arrays.asList(line.split(System.lineSeparator())));
+        this.printlnOutputs.addAll(Arrays.asList(String.valueOf(line).split(System.lineSeparator())));
     }
     
     @Override
@@ -57,4 +70,8 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
     public void assertNoErrors() {
         Assertions.assertEquals(0, errors.size());
     }
+    
+    public void assertNoWarnings() {
+        Assertions.assertEquals(0, warnings.size());
+    }
 }