ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

                 .filter(File::isFile)
                 .filter(f -> f.getName().endsWith(".zs"))
                 .filter(f -> !f.getAbsolutePath().contains("nope"))
-                .map(f -> new FileSourceFile(f.getName(), f))
+                .map(f -> new FileSourceFile(f.getAbsolutePath().substring(inputDirectory.getAbsolutePath().length() + 1), f))
                 .toArray(SourceFile[]::new);
         
         final PrefixedBracketParser parser = new PrefixedBracketParser(null);

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

+package org.openzen.zenscript.scriptingexample.tests.actual_test.arrays;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class ArrayOperators extends ZenCodeTest {
+    @Test
+    public void containsReturnsTrueForMatch() {
+        ScriptBuilder.create()
+                .add("var array = ['a', 'b', 'c'] as string[];")
+                .add("println(('a' in array) as string);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "true");
+    }
+    
+    @Test
+    public void containsReturnsFalseForNonMatch() {
+        ScriptBuilder.create()
+                .add("var array = ['a', 'b', 'c'] as string[];")
+                .add("println(('d' in array) as string);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "false");
+    }
+}

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

+package org.openzen.zenscript.scriptingexample.tests.actual_test.expansions;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class StringExpansions extends ZenCodeTest {
+    @Test
+    public void toUpperCaseMethod() {
+        ScriptBuilder.create()
+                .add("println('hello world'.toUpperCase());")
+                .execute(this);
+    
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World".toUpperCase());
+    }
+}

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

+package org.openzen.zenscript.scriptingexample.tests.actual_test.packages;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class SamePackage extends ZenCodeTest {
+    
+    @Test
+    public void definitionsInSamePackageAreAccessible() {
+        addScript("public function doSomething() as string => 'Hello World';", "a.zs");
+        addScript("println(doSomething());", "b.zs");
+        
+        executeEngine();
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+    
+    @Test
+    public void definitionsInSamePackageAreAccessible_2() {
+        addScript("public function doSomething() as string => 'Hello World';", "some/test/package/a.zs");
+        addScript("println(doSomething());", "some/test/package/b.zs");
+    
+        executeEngine();
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+}

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

 
 public class ScriptBuilder {
     
-    private final List<String> scripts;
+    private final Map<String, String> scriptNameToScript;
     private StringJoiner currentScriptJoiner;
+    private String currentScriptName;
     
     private ScriptBuilder() {
-        scripts = new ArrayList<>();
+        scriptNameToScript = new HashMap<>();
         startNewScript();
     }
     
     }
     
     public ScriptBuilder startNewScript() {
-        if(currentScriptJoiner != null) {
-            scripts.add(currentScriptJoiner.toString());
+        return startNewScript(null);
+    }
+    
+    public ScriptBuilder startNewScript(String fileName) {
+        if(currentScriptJoiner != null && currentScriptJoiner.length() != 0) {
+            scriptNameToScript.put(currentScriptName, currentScriptJoiner.toString());
         }
-        
+    
         currentScriptJoiner = new StringJoiner(System.lineSeparator());
+        if(fileName == null) {
+            currentScriptName = "test_script_" + (scriptNameToScript.size() + 1) + ".zs";
+        } else {
+            currentScriptName = fileName;
+        }
         return this;
     }
     
     public void appendScriptsToTest(ZenCodeTest test) {
         startNewScript();
     
-        for(String script : scripts) {
-            test.addScript(script);
-        }
+        scriptNameToScript.forEach((name, content) -> {
+            test.addScript(content, name);
+        });
     }
     
     public void execute(ZenCodeTest test, LogTolerance logTolerance) {

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

 import org.openzen.zenscript.scriptingexample.tests.*;
 
 import java.util.*;
+import java.util.stream.*;
 
 
 public abstract class ZenCodeTest {
     public void beforeEach() throws CompileException {
         this.logger = new ZenCodeTestLogger();
         this.engine = new ScriptingEngine(logger);
+        engine.debug = true;
         this.testModule = engine.createNativeModule("test_module", "org.openzen.zenscript.scripting_tests");
         SharedGlobals.currentlyActiveLogger = logger;
         
         logger.setEngineComplete();
     }
     
-    public void addScript(String context) {
-        sourceFiles.add(new LiteralSourceFile("test_script_" + sourceFiles.size() + ".zs", context));
+    public void addScript(String content) {
+        addScript(content, "test_script_" + sourceFiles.size() + ".zs");
+    }
+    
+    public void addScript(String content, String name) {
+        sourceFiles.add(new LiteralSourceFile(name, content));
     }