Only build tests on native targets

Author: rtfeldman

build.zig

@@ -598,6 +598,25 @@ pub fn build(b: *std.Build) void {
     const is_native = target.query.isNativeCpu() and target.query.isNativeOs() and (target.query.isNativeAbi() or target.result.abi.isMusl());
     const is_windows = target.result.os.tag == .windows;
 
+    // fx platform effectful functions test - only run on native builds
+    if (is_native) {
+        const fx_platform_test = b.addTest(.{
+            .name = "fx_platform_test",
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("src/cli/test/fx_platform_test.zig"),
+                .target = target,
+                .optimize = optimize,
+            }),
+            .filters = test_filters,
+        });
+
+        const run_fx_platform_test = b.addRunArtifact(fx_platform_test);
+        if (run_args.len != 0) {
+            run_fx_platform_test.addArgs(run_args);
+        }
+        tests_summary.addRun(&run_fx_platform_test.step);
+    }
+
     var build_afl = false;
     if (!is_native) {
         std.log.warn("Cross compilation does not support fuzzing (Only building repro executables)", .{});
@@ -809,6 +828,22 @@ fn addMainExe(
     copy_test_int_host.addCopyFileToSource(test_platform_int_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/int/platform", test_int_host_filename }));
     b.getInstallStep().dependOn(&copy_test_int_host.step);
 
+    // Create fx test platform host static library - native target only
+    const test_platform_fx_host_lib = createTestPlatformHostLib(
+        b,
+        "test_platform_fx_host",
+        "test/fx/platform/host.zig",
+        target,
+        optimize,
+        roc_modules,
+    );
+
+    // Copy the fx test platform host library to the source directory
+    const copy_test_fx_host = b.addUpdateSourceFiles();
+    const test_fx_host_filename = if (target.result.os.tag == .windows) "host.lib" else "libhost.a";
+    copy_test_fx_host.addCopyFileToSource(test_platform_fx_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/fx/platform", test_fx_host_filename }));
+    b.getInstallStep().dependOn(&copy_test_fx_host.step);
+
     // Cross-compile int platform host libraries for musl and glibc targets
     const cross_compile_targets = [_]struct { name: []const u8, query: std.Target.Query }{
         .{ .name = "x64musl", .query = .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl } },

src/cli/test/fx_platform_test.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const testing = std.testing;
+
+test "fx platform effectful functions" {
+    const allocator = testing.allocator;
+
+    // Build the fx app
+    const build_result = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &[_][]const u8{
+            "./zig-out/bin/roc",
+            "build",
+            "test/fx/app.roc",
+        },
+    });
+    defer allocator.free(build_result.stdout);
+    defer allocator.free(build_result.stderr);
+
+    switch (build_result.term) {
+        .Exited => |code| {
+            if (code != 0) {
+                std.debug.print("Build failed with exit code {}\n", .{code});
+                std.debug.print("STDOUT: {s}\n", .{build_result.stdout});
+                std.debug.print("STDERR: {s}\n", .{build_result.stderr});
+                return error.BuildFailed;
+            }
+        },
+        else => {
+            std.debug.print("Build terminated abnormally: {}\n", .{build_result.term});
+            std.debug.print("STDOUT: {s}\n", .{build_result.stdout});
+            std.debug.print("STDERR: {s}\n", .{build_result.stderr});
+            return error.BuildFailed;
+        },
+    }
+
+    // Run the app and capture stdout/stderr separately
+    const run_result = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &[_][]const u8{"./app"},
+    });
+    defer allocator.free(run_result.stdout);
+    defer allocator.free(run_result.stderr);
+
+    // Clean up the app binary
+    std.fs.cwd().deleteFile("./app") catch {};
+
+    switch (run_result.term) {
+        .Exited => |code| {
+            if (code != 0) {
+                std.debug.print("Run failed with exit code {}\n", .{code});
+                std.debug.print("STDOUT: {s}\n", .{run_result.stdout});
+                std.debug.print("STDERR: {s}\n", .{run_result.stderr});
+                return error.RunFailed;
+            }
+        },
+        else => {
+            std.debug.print("Run terminated abnormally: {}\n", .{run_result.term});
+            std.debug.print("STDOUT: {s}\n", .{run_result.stdout});
+            std.debug.print("STDERR: {s}\n", .{run_result.stderr});
+            return error.RunFailed;
+        },
+    }
+
+    // Verify stdout contains expected messages
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Hello from stdout!") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 1 to stdout") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 3 to stdout") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "ALL TESTS COMPLETED") != null);
+
+    // Verify stderr contains expected messages
+    try testing.expect(std.mem.indexOf(u8, run_result.stderr, "Error from stderr!") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stderr, "Line 2 to stderr") != null);
+
+    // Verify stderr messages are NOT in stdout
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Error from stderr!") == null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 2 to stderr") == null);
+
+    // Verify stdout messages are NOT in stderr (except the ones we intentionally put there for display)
+    // Note: The host.zig writes "STDOUT: ..." to stdout and "STDERR: ..." to stderr
+    // so we check that the actual content is separated correctly
+}

test/fx/app.roc

@@ -0,0 +1,11 @@
+app [writeToStdout, writeToStderr] { pf: platform "./platform/main.roc" }
+
+writeToStdout : Str => {}
+writeToStdout = |_msg|
+    # The host will actually handle the IO
+    {}
+
+writeToStderr : Str => {}
+writeToStderr = |_msg|
+    # The host will actually handle the IO
+    {}

test/fx/platform/main.roc

@@ -0,0 +1,12 @@
+platform ""
+    requires {} {
+        writeToStdout : Str => {},
+        writeToStderr : Str => {}
+    }
+    exposes []
+    packages {}
+    provides { writeToStdout: "writeToStdout", writeToStderr: "writeToStderr" }
+
+writeToStdout : Str => {}
+
+writeToStderr : Str => {}