Chapter 31: Software Drawing and Graphical Gameslinear-chapter31linear

Co-authored-by: Hsiang-Ying Fu <66062782+fuhsnn@users.noreply.github.com>
Co-authored-by: fuhsnn <66062782+fuhsnn@users.noreply.github.com>
Co-authored-by: Symious <14933944+symious@users.noreply.github.com>
Co-authored-by: Jun Kawasaki <jun784@gmail.com>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

12 files changed, 366 insertions, 14 deletions

diff --git a/src/test/java/com/seaofnodes/simple/AudioTest.java b/src/test/java/com/seaofnodes/simple/AudioTest.java
new file mode 100644
index 00000000..db8542d0
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/AudioTest.java
@@ -0,0 +1,94 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.util.Ary;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.TimeUnit;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+// Loader and Simple/C ABI checks: no miniaudio download or audio device.
+public class AudioTest {
+    private static String missing, playback;
+
+    @BeforeClass public static void compilePrograms() throws Exception {
+        var paths=new Ary<>(new String[]{TestC.RELEASE_SYS_DIR});
+        missing=TestC.compile("""
+            val main = { ->
+                if( sys.audio.open()!=sys.audio.ERROR ) return 1;
+                if( sys.audio.boop()!=sys.audio.ERROR || sys.audio.playing() ) return 2;
+                sys.audio.stop(); sys.audio.close(); sys.audio.close();
+                sys.io.p("silent fallback\\n");
+                return 0;
+            };
+            ""","audio_missing",paths,TestC.CALL_CONVENTION,null,null,-1);
+        playback=TestC.compile("""
+            val main = { ->
+                if( sys.audio.open()!=sys.audio.OK ) return 1;
+                val pcm = new i16[3];
+                pcm[0]=-32768; pcm[1]=123; pcm[2]=32767;
+                int sound = sys.audio.load(pcm);
+                if( sound!=4 || sys.audio.play(sound)!=0 || !sys.audio.playing() ) return 2;
+                if( sys.audio.boop()!=0 || sys.audio.win()!=0 || sys.audio.lose()!=0 ) return 3;
+                sys.audio.stop();
+                if( sys.audio.playing() ) return 4;
+                sys.audio.close();
+                return 0;
+            };
+            ""","audio_playback",paths,TestC.CALL_CONVENTION,null,null,-1);
+    }
+
+    private static String run(String exe, String backend) throws Exception {
+        ProcessBuilder pb=new ProcessBuilder(exe).redirectErrorStream(true);
+        if( backend==null ) pb.environment().remove("SIMPLE_MINIAUDIO");
+        else pb.environment().put("SIMPLE_MINIAUDIO",backend);
+        Process child=pb.start();
+        try {
+            assertTrue("audio program timed out",child.waitFor(10,TimeUnit.SECONDS));
+            String out=new String(child.getInputStream().readAllBytes(),StandardCharsets.UTF_8);
+            assertEquals(out,0,child.exitValue());
+            return out;
+        } finally { if( child.isAlive() ) child.destroyForcibly(); }
+    }
+
+    @Test public void silentFallback() throws Exception {
+        assertEquals("silent fallback\n",run(missing,null));
+        assertEquals("silent fallback\n",run(missing,"off"));
+        assertTrue(run(missing,"no-such-miniaudio-backend").contains("cannot load backend"));
+    }
+
+    @Test public void nativeBoundary() throws Exception {
+        Path source=Path.of("build/objs/audio_stub.c");
+        Path library=Path.of("build/objs/audio_stub"+(TestC.OS.startsWith("Windows") ? ".dll" : ".so"));
+        Files.writeString(source,"""
+            #include "simple_audio.h"
+            static int active;
+            static int32_t open_audio(void) { return 0; }
+            static int32_t load(const int16_t *p, uint32_t n) {
+                return n==3 && p[0]==-32768 && p[1]==123 && p[2]==32767 ? 4 : -1;
+            }
+            static int32_t play(int32_t cue) { active=1; return cue>=1 && cue<=4 ? 0 : -1; }
+            static int32_t stop(void) { active=0; return 0; }
+            static int32_t playing(void) { return active; }
+            static void close_audio(void) { active=0; }
+            static const struct simple_audio_api api={1,open_audio,load,play,stop,playing,close_audio};
+            const struct simple_audio_api *simple_miniaudio_api(void) { return &api; }
+            """);
+        TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
+        assertEquals("",run(playback,library.toAbsolutePath().toString()));
+    }
+
+    @Test public void incompatibleBackend() throws Exception {
+        Path source=Path.of("build/objs/audio_bad.c");
+        Path library=Path.of("build/objs/audio_bad"+(TestC.OS.startsWith("Windows") ? ".dll" : ".so"));
+        Files.writeString(source,"""
+            #include "simple_audio.h"
+            static const struct simple_audio_api api={999};
+            const struct simple_audio_api *simple_miniaudio_api(void) { return &api; }
+            """);
+        TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
+        assertTrue(run(missing,library.toAbsolutePath().toString()).contains("incompatible backend"));
+    }
+}
diff --git a/src/test/java/com/seaofnodes/simple/BrainFuckTest.java b/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
index 63858df0..07e702c7 100644
--- a/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
+++ b/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
@@ -1,19 +1,21 @@
 package com.seaofnodes.simple;
 
 import com.seaofnodes.isa.eval.EvalRisc5;
-
 import com.seaofnodes.isa.eval.EvalArm64;
-
 import java.io.IOException;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 import java.nio.file.Files;
 import java.nio.file.Path;
-
 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 
 public class BrainFuckTest {
 
     @Test public void testBrainFuckAryu8() throws IOException {
+
+
         String brain_fuck = "Hello World!\n";
         String src =
 """
diff --git a/src/test/java/com/seaofnodes/simple/Chapter01Test.java b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
index fa7fb68a..6db79c16 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter01Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
@@ -41,13 +41,8 @@ public class Chapter01Test {
     }
 
     @Test
-    public void testBad2() {
-        try {
-            new CodeGen("return 0123;").parse();
-            fail();
-        } catch( RuntimeException e ) {
-            assertEquals("Syntax error: integer values cannot start with '0'",e.getMessage());
-        }
+    public void testOctal() {
+        assertEquals("return 83;",new CodeGen("return 0123;").parse().print());
     }
 
     @Test
diff --git a/src/test/java/com/seaofnodes/simple/Chapter21Test.java b/src/test/java/com/seaofnodes/simple/Chapter21Test.java
index c6d558eb..1a57d4da 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter21Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter21Test.java
@@ -531,7 +531,8 @@ val sieve = { int N ->
         String sprimes = sb.p("]").toString();
 
         // Compile, link against native C; expect the above string of primes to be printed out by C
-        TestC.runC(src, "sieve", sprimes,344);
+        // Load/Phi hoisting now requires the pointer before the loop entry.
+        TestC.runC(src, "sieve", sprimes,216);
 
         // Evaluate on RISC5 emulator; expect return of an array of primes in
         // the simulated heap.
diff --git a/src/test/java/com/seaofnodes/simple/Chapter25Test.java b/src/test/java/com/seaofnodes/simple/Chapter25Test.java
index 67e7f982..7f2b4a77 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter25Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter25Test.java
@@ -475,9 +475,9 @@ public class Chapter25Test {
 
         // Elf files are sane
 
-        // Sys depends on io, libc, text, char, collections, and array utilities.
+        // Software drawing and the optional native graphics interface.
         assertArrayEquals(new String[]{"sys/adt", "sys/ary",
-            "sys/aryi64", "sys/aryu8", "sys/char", "sys/io", "sys/libc", "sys/rt", "sys/scan", "sys/text"},sys_elf._deps);
+            "sys/aryi64", "sys/aryu8", "sys/audio", "sys/char", "sys/draw", "sys/gfx", "sys/io", "sys/libc", "sys/rt", "sys/scan", "sys/text"},sys_elf._deps);
         assertArrayEquals(new String[]{"sys"},sys_elf._units);
         assertSame("class:sys" ,sys_elf._clz._name);
     }
diff --git a/src/test/java/com/seaofnodes/simple/DrawTest.java b/src/test/java/com/seaofnodes/simple/DrawTest.java
new file mode 100644
index 00000000..6eb261f1
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/DrawTest.java
@@ -0,0 +1,105 @@
+package com.seaofnodes.simple;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+
+// Native raster and game checks; no backend or display is needed.
+public class DrawTest {
+    @Test public void rectanglesAndColors() throws Exception {
+        TestC.runSYS("""
+            val main = { ->
+                val c = new sys.draw.Canvas(12,10);
+                u32 color = sys.draw.rgb(300,-1,128);
+                if( color!=16711808 ) return 1;
+                c.clear(7).fillRect(-2,-1,5,4,color);
+                for( int y=0; y<10; y++ )
+                    for( int x=0; x<12; x++ )
+                        if( c.pixels[y*12+x]!=(x<3 && y<3 ? color : 7) ) return 2;
+                c.clear(0).rect(2,2,7,6,1,9);
+                for( int y=0; y<10; y++ )
+                    for( int x=0; x<12; x++ ) {
+                        var inside = 2<=x<9 && 2<=y<8;
+                        var border = inside && (x==2 || x==8 || y==2 || y==7);
+                        if( c.pixels[y*12+x]!=(border ? 9 : 0) ) return 3;
+                    }
+                c.clear(5).fillRect(20,0,8,8,1).rect(0,0,12,10,0,1);
+                c.fillRect(0,0,-1,5,1).pixel(-1,0,1).pixel(12,9,1);
+                for( int i=0; i<c.pixels#; i++ ) if( c.pixels[i]!=5 ) return 4;
+                return 0;
+            };
+            ""","drawRectangles","",-1);
+    }
+
+    @Test public void circlesLinesAndText() throws Exception {
+        TestC.runSYS("""
+            val main = { ->
+                val c = new sys.draw.Canvas(16,16);
+                c.fillCircle(8,8,3,1);
+                for( int y=0; y<16; y++ )
+                    for( int x=0; x<16; x++ )
+                        if( c.pixels[y*16+x]!=((x-8)*(x-8)+(y-8)*(y-8)<=9 ? 1 : 0) ) {
+                            sys.io.p("circle mismatch %(x) %(y): %(c.pixels[y*16+x])\\n");
+                            return 1;
+                        }
+                c.clear(0).circle(8,8,3,1,2);
+                if( c.pixels[8*16+8]!=0 || c.pixels[8*16+11]!=2 || c.pixels[8*16+10]!=0 ) return 2;
+                c.clear(0).circle(8,8,3,3,2);
+                if( c.pixels[8*16+8]!=2 ) return 8;
+                c.clear(0).line(-5,8,20,8,3,3);
+                for( int y=0; y<16; y++ )
+                    for( int x=0; x<16; x++ )
+                        if( c.pixels[y*16+x]!=(7<=y<=9 ? 3 : 0) ) return 3;
+                c.clear(0).line(8,8,8,8,2,4);
+                if( c.pixels[8*16+8]!=4 || c.pixels[8*16+9]!=4 || c.pixels[9*16+9]!=0 ) return 4;
+                c.clear(0).line(2,2,13,13,1,5);
+                if( c.pixels[7*16+7]!=5 || c.pixels[7*16+8]!=0 ) return 5;
+                c.clear(0).text(0,0,"x",1,6).text(8,0,"X",1,6);
+                for( int y=0; y<5; y++ )
+                    for( int x=0; x<3; x++ )
+                        if( c.pixels[y*16+x]!=c.pixels[y*16+x+8] ) return 6;
+                c.clear(0).fillCircle(-1,-1,2,7);
+                if( c.pixels[0]!=7 || c.pixels[2]!=0 ) return 7;
+                return 0;
+            };
+            ""","drawCurves","",-1);
+    }
+
+    @Test public void graphicalGameWithoutWindow() throws Exception {
+        String game=Files.readString(Path.of("docs/examples/TicTacToeGraphical.smp"))
+            .replace("val main =","val _windowMain =");
+        TestC.runSYS(game+"""
+
+            val main = { ->
+                val board = new u8[9];
+                _reset(board);
+                if( _square(48,168)!=0 || _square(551,671)!=8 || _square(552,400)!=-1 || _square(100,167)!=-1 ) return 1;
+                if( !_move(board,4) || board[4]!='X' || board[0]!='O' ) return 2;
+                if( _sound(board)!=sys.audio.BOOP ) return 10;
+                if( _move(board,4) || _move(board,0) || _move(board,-1) || _move(board,9) ) return 3;
+                val moves = "1879";
+                _reset(board);
+                for( int i=0; i<moves#; i++ )
+                    if( !_move(board,moves[i]-'1') ) return 4;
+                if( _winner(board)!='X' || _move(board,1) ) return 5;
+                if( _sound(board)!=sys.audio.WIN ) return 11;
+                val screen = new sys.draw.Canvas(600,780);
+                _draw(screen,board,-1);
+                if( screen.pixels[252*600+132]==screen.pixels[0] ) return 6;
+                _reset(board);
+                val draw = "12768";
+                for( int i=0; i<draw#; i++ ) _move(board,draw[i]-'1');
+                if( !_finished(board) || _winner(board)!=0 ) return 7;
+                _reset(board);
+                _move(board,0); _move(board,1); _move(board,3);
+                if( _winner(board)!='O' ) return 8;
+                if( _sound(board)!=sys.audio.LOSE ) return 12;
+                _draw(screen,board,-1);
+                _reset(board);
+                if( _finished(board) ) return 9;
+                _draw(screen,board,4);
+                return 0;
+            };
+            ""","drawGame","",-1);
+    }
+}
diff --git a/src/test/java/com/seaofnodes/simple/GraphicsTest.java b/src/test/java/com/seaofnodes/simple/GraphicsTest.java
new file mode 100644
index 00000000..9c432ce4
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/GraphicsTest.java
@@ -0,0 +1,75 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.util.Ary;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+// These tests never open a window and do not need MiniFB installed.
+public class GraphicsTest {
+    private static String graphics, text, game;
+
+    @BeforeClass public static void compilePrograms() throws Exception {
+        var paths = new Ary<>(new String[]{TestC.RELEASE_SYS_DIR});
+        graphics = TestC.compile(Files.readString(Path.of("docs/examples/Graphics.smp")),
+            "graphics_missing",paths,TestC.CALL_CONVENTION,null,null,-1);
+        text = TestC.compile("val main={ -> sys.io.p(\"text still works\\n\"); return 0; };",
+            "graphics_text",paths,TestC.CALL_CONVENTION,null,null,-1);
+        game = TestC.compile(Files.readString(Path.of("docs/examples/TicTacToeGraphical.smp")),
+            "graphics_game",paths,TestC.CALL_CONVENTION,null,null,-1);
+    }
+
+    private static String run(String exe, String backend, int exit) throws Exception {
+        ProcessBuilder pb = new ProcessBuilder(exe).redirectErrorStream(true);
+        if( backend == null ) pb.environment().remove("SIMPLE_MINIFB");
+        else pb.environment().put("SIMPLE_MINIFB",backend);
+        Process child = pb.start();
+        try {
+            assertTrue("native program timed out",child.waitFor(10,TimeUnit.SECONDS));
+            String output = new String(child.getInputStream().readAllBytes(),java.nio.charset.StandardCharsets.UTF_8);
+            assertEquals(output,exit,child.exitValue());
+            return output;
+        } finally { if( child.isAlive() ) child.destroyForcibly(); }
+    }
+
+    @Test public void missingConfiguration() throws Exception {
+        String output = run(graphics,null,1);
+        assertTrue(output,output.contains("MiniFB backend not configured"));
+        assertTrue(output,output.contains("make graphics"));
+    }
+
+    @Test public void disabledGraphics() throws Exception {
+        assertTrue(run(graphics,"off",1).contains("disabled"));
+    }
+
+    @Test public void gameWithoutBackend() throws Exception {
+        assertTrue(run(game,"off",1).contains("disabled"));
+    }
+
+    @Test public void missingLibrary() throws Exception {
+        String missing = Path.of("build","no-such-minifb-backend").toAbsolutePath().toString();
+        String output = run(graphics,missing,1);
+        assertTrue(output,output.contains("cannot load MiniFB backend"));
+    }
+
+    @Test public void textIgnoresGraphicsConfiguration() throws Exception {
+        assertEquals("text still works\n",run(text,"off",0));
+        assertEquals("text still works\n",run(text,"no-such-backend",0));
+    }
+
+    @Test public void incompatibleLibrary() throws Exception {
+        Path source = Path.of("build/objs/graphics_incompatible.c");
+        Path library = Path.of("build/objs/graphics_incompatible" +
+            (TestC.OS.startsWith("Windows") ? ".dll" : ".so"));
+        Files.writeString(source,"""
+            #include "simple_graphics.h"
+            static const struct simple_graphics_api api = {999};
+            const struct simple_graphics_api *simple_minifb_api(void) { return &api; }
+            """);
+        TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
+        assertTrue(run(graphics,library.toAbsolutePath().toString(),1).contains("incompatible MiniFB backend"));
+    }
+}
diff --git a/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java b/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java
new file mode 100644
index 00000000..975042c2
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java
@@ -0,0 +1,46 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeFloat;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class IntegerLiteralTest {
+    private static void value(String expression, long expected) {
+        var code = new CodeGen("return "+expression+";").parse();
+        assertEquals(expression,TypeInteger.constant(expected),code.expr()._type);
+    }
+
+    @Test public void valuesAndBitPatterns() {
+        value("0x00e47b57",14973783);
+        value("0XfF",255);
+        value("025755",11245); // A: rows 010, 101, 111, 101, 101.
+        value("000000",0);
+        value("0x7fffffffffffffff",Long.MAX_VALUE);
+        value("0x8000000000000000",Long.MIN_VALUE);
+        value("0xffffffffffffffff",-1);
+        value("0777777777777777777777",Long.MAX_VALUE);
+        value("01000000000000000000000",Long.MIN_VALUE);
+        value("01777777777777777777777",-1);
+        value("0x00000000000000000001",1);
+        value("-0x2a + 052",0);
+        value("0x1e+2",32); // e and f are hex digits, not float markers.
+        value("0xff & 017",15);
+        value("017<<0x4",240);
+        value("0x0f",15);
+        value("0123",83);
+        value("000000000000000000000000000000000001",1);
+        assertEquals(TypeFloat.constant(12.5),new CodeGen("return 012.5;").parse().expr()._type);
+        assertEquals(TypeFloat.constant(12.0),new CodeGen("return 012f;").parse().expr()._type);
+    }
+
+    @Test public void nativeLiterals() throws Exception {
+        TestC.runSF("""
+            val check_noInline = { i64 mask, u32 color, int glyph ->
+                return mask==-1 && color==14973783 && glyph==11245 ? 0 : 1;
+            };
+            val main = { -> return check_noInline(0xffffffffffffffff,0x00e47b57,025755); };
+            ""","basedLiterals","",-1);
+    }
+}
diff --git a/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java b/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
index 2b7eea78..ef26a943 100644
--- a/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
+++ b/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
@@ -30,7 +30,18 @@ public class ParserDiagnosticTest {
         diagnostic("return 9223372036854775808;",1,8,"Integer literal is outside the signed 64-bit range");
         diagnostic("return 1e;",1,8,"Invalid floating-point literal '1e'");
         diagnostic("return 1.2.3f;",1,8,"Invalid floating-point literal '1.2.3f'");
-        diagnostic("return 012;",1,8,"Syntax error: integer values cannot start with '0'");
+        diagnostic("return 018;",1,8,"Invalid octal integer literal '018'");
+    }
+
+    @Test public void testBasedIntegerLiteralErrors() {
+        diagnostic("return 0x;",1,8,"Hexadecimal integer literal requires at least one digit");
+        diagnostic("return 0x12g;",1,8,"Invalid hexadecimal integer literal '0x12g'");
+        diagnostic("return 0128;",1,8,"Invalid octal integer literal '0128'");
+        diagnostic("return 0x_ff;",1,8,"Invalid hexadecimal integer literal '0x_ff'");
+        diagnostic("return 09;",1,8,"Invalid octal integer literal '09'");
+        diagnostic("return 0x10000000000000000;",1,8,"Hexadecimal integer literal exceeds 64 bits");
+        diagnostic("return 02000000000000000000000;",1,8,"Octal integer literal exceeds 64 bits");
+        diagnostic("int 0xabc;",1,5,"Expected an identifier, found '0xabc'");
     }
 
     @Test public void testUnclosedCommentsAndStrings() {
diff --git a/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java b/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java
index 1853aa48..1c278791 100644
--- a/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java
+++ b/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java
@@ -10,6 +10,22 @@ import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class SeparateCompilationTest {
+    @Test public void testImportedReadOnlyPrimitiveArray() throws Exception {
+        Path build=Path.of("build/objs/separate");
+        Files.createDirectories(build);
+        Path lib=Files.createTempDirectory(build,"pixels-");
+        new CodeGen(null,lib.toString(),null,"Pixels",
+            "val first={ u32[~] pixels -> pixels[0]; };",123,true,TypeInteger.BOT)
+            .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false);
+        var paths=new Ary<>(new String[]{lib.toString()});
+        CodeGen code=new CodeGen(null,"build/objs",paths,"PixelClient","""
+            val pixels=new u32[2];
+            pixels[0]=4294967295;
+            return Pixels.first(pixels);
+            """,123,true,TypeInteger.BOT).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("4294967295",Eval2.eval(code,0));
+    }
+
     @Test public void testImportedNativeExposure() throws Exception {
         Path build=Path.of("build/objs/separate");
         Files.createDirectories(build);
diff --git a/src/test/java/com/seaofnodes/simple/StreamIOTest.java b/src/test/java/com/seaofnodes/simple/StreamIOTest.java
index f3491314..e47cd929 100644
--- a/src/test/java/com/seaofnodes/simple/StreamIOTest.java
+++ b/src/test/java/com/seaofnodes/simple/StreamIOTest.java
@@ -131,6 +131,9 @@ public class StreamIOTest extends TestC {
         gcc.addAll(linkObjs(code));
         gcc.add(runtimeObject("simple_crt"));
         gcc.add(runtimeObject("simple_args"));
+        gcc.add(runtimeObject("simple_graphics"));
+        gcc.add(runtimeObject("simple_audio"));
+        if( !OS.startsWith("Windows") ) gcc.add("-ldl");
         gcc.addAll(new String[]{"-lm","-o",exe});
         exec(TEST_TIMEOUT_SECONDS,gcc.asAry());
         assertEquals("ok\n",exec(TEST_TIMEOUT_SECONDS,exe));
diff --git a/src/test/java/com/seaofnodes/simple/TestC.java b/src/test/java/com/seaofnodes/simple/TestC.java
index dd7999c9..741ee13b 100644
--- a/src/test/java/com/seaofnodes/simple/TestC.java
+++ b/src/test/java/com/seaofnodes/simple/TestC.java
@@ -190,6 +190,10 @@ public abstract class TestC {
         params.add(OS.startsWith("Windows") ? "-Wl,--image-base,0x400000" : "-no-pie");
         if( cfile!=null ) params.add(cfile); // Associated C driver, usually has a `main`
         params.addAll(objects);
+        // The loader has no MiniFB dependency and opens nothing until gfx.open.
+        params.add(runtimeObject("simple_graphics"));
+        params.add(runtimeObject("simple_audio"));
+        if( !OS.startsWith("Windows") ) params.add("-ldl");
         // Standalone Simple programs export `simple_main`; the small C
         // runtime owns native main and calls the Simple argument converter
         // before making the ABI-qualified entry call.