diff --git a/test/standalone.zig b/test/standalone.zig
index 6a957b7a1d182e95fb9f01b3c3849c96b78162ce..34eb28f4a7a28e32617dd14556acbafa2e932908 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -11,43 +11,43 @@ pub const SimpleCase = struct {
 
 pub const simple_cases = [_]SimpleCase{
     .{
-        .src_path = "test/standalone/hello_world/hello.zig",
+        .src_path = "test/standalone/simple/hello_world/hello.zig",
         .all_modes = true,
     },
     .{
-        .src_path = "test/standalone/hello_world/hello_libc.zig",
+        .src_path = "test/standalone/simple/hello_world/hello_libc.zig",
         .link_libc = true,
         .all_modes = true,
     },
     .{
-        .src_path = "test/standalone/cat/main.zig",
+        .src_path = "test/standalone/simple/cat/main.zig",
     },
     // https://github.com/ziglang/zig/issues/6025
     //.{
-    //    .src_path = "test/standalone/issue_9693/main.zig",
+    //    .src_path = "test/standalone/simple/issue_9693/main.zig",
     //},
     .{
-        .src_path = "test/standalone/brace_expansion.zig",
+        .src_path = "test/standalone/simple/brace_expansion.zig",
         .is_test = true,
     },
     .{
-        .src_path = "test/standalone/issue_7030.zig",
+        .src_path = "test/standalone/simple/issue_7030.zig",
         .target = .{
             .cpu_arch = .wasm32,
             .os_tag = .freestanding,
         },
     },
 
-    .{ .src_path = "test/standalone/issue_12471/main.zig" },
-    .{ .src_path = "test/standalone/guess_number/main.zig" },
-    .{ .src_path = "test/standalone/main_return_error/error_u8.zig" },
-    .{ .src_path = "test/standalone/main_return_error/error_u8_non_zero.zig" },
-    .{ .src_path = "test/standalone/noreturn_call/inline.zig" },
-    .{ .src_path = "test/standalone/noreturn_call/as_arg.zig" },
-    .{ .src_path = "test/standalone/std_enums_big_enums.zig" },
+    .{ .src_path = "test/standalone/simple/issue_12471/main.zig" },
+    .{ .src_path = "test/standalone/simple/guess_number/main.zig" },
+    .{ .src_path = "test/standalone/simple/main_return_error/error_u8.zig" },
+    .{ .src_path = "test/standalone/simple/main_return_error/error_u8_non_zero.zig" },
+    .{ .src_path = "test/standalone/simple/noreturn_call/inline.zig" },
+    .{ .src_path = "test/standalone/simple/noreturn_call/as_arg.zig" },
+    .{ .src_path = "test/standalone/simple/std_enums_big_enums.zig" },
 
     .{
-        .src_path = "test/standalone/issue_9402/main.zig",
+        .src_path = "test/standalone/simple/issue_9402/main.zig",
         .os_filter = .windows,
         .link_libc = true,
     },
diff --git a/test/standalone/brace_expansion.zig b/test/standalone/brace_expansion.zig
deleted file mode 100644
index 7a769f6af7435c1f782a9676febf2dd91e557e23..0000000000000000000000000000000000000000
--- a/test/standalone/brace_expansion.zig
+++ /dev/null
@@ -1,292 +0,0 @@
-const std = @import("std");
-const io = std.io;
-const mem = std.mem;
-const debug = std.debug;
-const assert = debug.assert;
-const testing = std.testing;
-const ArrayList = std.ArrayList;
-const maxInt = std.math.maxInt;
-
-const Token = union(enum) {
-    Word: []const u8,
-    OpenBrace,
-    CloseBrace,
-    Comma,
-    Eof,
-};
-
-var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-var global_allocator = gpa.allocator();
-
-fn tokenize(input: []const u8) !ArrayList(Token) {
-    const State = enum {
-        Start,
-        Word,
-    };
-
-    var token_list = ArrayList(Token).init(global_allocator);
-    errdefer token_list.deinit();
-    var tok_begin: usize = undefined;
-    var state = State.Start;
-
-    for (input, 0..) |b, i| {
-        switch (state) {
-            .Start => switch (b) {
-                'a'...'z', 'A'...'Z' => {
-                    state = State.Word;
-                    tok_begin = i;
-                },
-                '{' => try token_list.append(Token.OpenBrace),
-                '}' => try token_list.append(Token.CloseBrace),
-                ',' => try token_list.append(Token.Comma),
-                else => return error.InvalidInput,
-            },
-            .Word => switch (b) {
-                'a'...'z', 'A'...'Z' => {},
-                '{', '}', ',' => {
-                    try token_list.append(Token{ .Word = input[tok_begin..i] });
-                    switch (b) {
-                        '{' => try token_list.append(Token.OpenBrace),
-                        '}' => try token_list.append(Token.CloseBrace),
-                        ',' => try token_list.append(Token.Comma),
-                        else => unreachable,
-                    }
-                    state = State.Start;
-                },
-                else => return error.InvalidInput,
-            },
-        }
-    }
-    switch (state) {
-        State.Start => {},
-        State.Word => try token_list.append(Token{ .Word = input[tok_begin..] }),
-    }
-    try token_list.append(Token.Eof);
-    return token_list;
-}
-
-const Node = union(enum) {
-    Scalar: []const u8,
-    List: ArrayList(Node),
-    Combine: []Node,
-
-    fn deinit(self: Node) void {
-        switch (self) {
-            .Scalar => {},
-            .Combine => |pair| {
-                pair[0].deinit();
-                pair[1].deinit();
-                global_allocator.free(pair);
-            },
-            .List => |list| {
-                for (list.items) |item| {
-                    item.deinit();
-                }
-                list.deinit();
-            },
-        }
-    }
-};
-
-const ParseError = error{
-    InvalidInput,
-    OutOfMemory,
-};
-
-fn parse(tokens: *const ArrayList(Token), token_index: *usize) ParseError!Node {
-    const first_token = tokens.items[token_index.*];
-    token_index.* += 1;
-
-    const result_node = switch (first_token) {
-        .Word => |word| Node{ .Scalar = word },
-        .OpenBrace => blk: {
-            var list = ArrayList(Node).init(global_allocator);
-            errdefer {
-                for (list.items) |node| node.deinit();
-                list.deinit();
-            }
-            while (true) {
-                try list.append(try parse(tokens, token_index));
-
-                const token = tokens.items[token_index.*];
-                token_index.* += 1;
-
-                switch (token) {
-                    .CloseBrace => break,
-                    .Comma => continue,
-                    else => return error.InvalidInput,
-                }
-            }
-            break :blk Node{ .List = list };
-        },
-        else => return error.InvalidInput,
-    };
-
-    switch (tokens.items[token_index.*]) {
-        .Word, .OpenBrace => {
-            const pair = try global_allocator.alloc(Node, 2);
-            errdefer global_allocator.free(pair);
-            pair[0] = result_node;
-            pair[1] = try parse(tokens, token_index);
-            return Node{ .Combine = pair };
-        },
-        else => return result_node,
-    }
-}
-
-fn expandString(input: []const u8, output: *ArrayList(u8)) !void {
-    const tokens = try tokenize(input);
-    defer tokens.deinit();
-    if (tokens.items.len == 1) {
-        return output.resize(0);
-    }
-
-    var token_index: usize = 0;
-    const root = try parse(&tokens, &token_index);
-    defer root.deinit();
-    const last_token = tokens.items[token_index];
-    switch (last_token) {
-        Token.Eof => {},
-        else => return error.InvalidInput,
-    }
-
-    var result_list = ArrayList(ArrayList(u8)).init(global_allocator);
-    defer {
-        for (result_list.items) |*buf| buf.deinit();
-        result_list.deinit();
-    }
-
-    try expandNode(root, &result_list);
-
-    try output.resize(0);
-    for (result_list.items, 0..) |buf, i| {
-        if (i != 0) {
-            try output.append(' ');
-        }
-        try output.appendSlice(buf.items);
-    }
-}
-
-const ExpandNodeError = error{OutOfMemory};
-
-fn expandNode(node: Node, output: *ArrayList(ArrayList(u8))) ExpandNodeError!void {
-    assert(output.items.len == 0);
-    switch (node) {
-        .Scalar => |scalar| {
-            var list = ArrayList(u8).init(global_allocator);
-            errdefer list.deinit();
-            try list.appendSlice(scalar);
-            try output.append(list);
-        },
-        .Combine => |pair| {
-            const a_node = pair[0];
-            const b_node = pair[1];
-
-            var child_list_a = ArrayList(ArrayList(u8)).init(global_allocator);
-            defer {
-                for (child_list_a.items) |*buf| buf.deinit();
-                child_list_a.deinit();
-            }
-            try expandNode(a_node, &child_list_a);
-
-            var child_list_b = ArrayList(ArrayList(u8)).init(global_allocator);
-            defer {
-                for (child_list_b.items) |*buf| buf.deinit();
-                child_list_b.deinit();
-            }
-            try expandNode(b_node, &child_list_b);
-
-            for (child_list_a.items) |buf_a| {
-                for (child_list_b.items) |buf_b| {
-                    var combined_buf = ArrayList(u8).init(global_allocator);
-                    errdefer combined_buf.deinit();
-
-                    try combined_buf.appendSlice(buf_a.items);
-                    try combined_buf.appendSlice(buf_b.items);
-                    try output.append(combined_buf);
-                }
-            }
-        },
-        .List => |list| {
-            for (list.items) |child_node| {
-                var child_list = ArrayList(ArrayList(u8)).init(global_allocator);
-                errdefer for (child_list.items) |*buf| buf.deinit();
-                defer child_list.deinit();
-
-                try expandNode(child_node, &child_list);
-
-                for (child_list.items) |buf| {
-                    try output.append(buf);
-                }
-            }
-        },
-    }
-}
-
-pub fn main() !void {
-    defer _ = gpa.deinit();
-    const stdin_file = io.getStdIn();
-    const stdout_file = io.getStdOut();
-
-    const stdin = try stdin_file.reader().readAllAlloc(global_allocator, std.math.maxInt(usize));
-    defer global_allocator.free(stdin);
-
-    var result_buf = ArrayList(u8).init(global_allocator);
-    defer result_buf.deinit();
-
-    try expandString(stdin, &result_buf);
-    try stdout_file.writeAll(result_buf.items);
-}
-
-test "invalid inputs" {
-    global_allocator = std.testing.allocator;
-
-    try expectError("}ABC", error.InvalidInput);
-    try expectError("{ABC", error.InvalidInput);
-    try expectError("}{", error.InvalidInput);
-    try expectError("{}", error.InvalidInput);
-    try expectError("A,B,C", error.InvalidInput);
-    try expectError("{A{B,C}", error.InvalidInput);
-    try expectError("{A,}", error.InvalidInput);
-
-    try expectError("\n", error.InvalidInput);
-}
-
-fn expectError(test_input: []const u8, expected_err: anyerror) !void {
-    var output_buf = ArrayList(u8).init(global_allocator);
-    defer output_buf.deinit();
-
-    try testing.expectError(expected_err, expandString(test_input, &output_buf));
-}
-
-test "valid inputs" {
-    global_allocator = std.testing.allocator;
-
-    try expectExpansion("{x,y,z}", "x y z");
-    try expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
-    try expectExpansion("{A,B{x,y}}", "A Bx By");
-
-    try expectExpansion("{ABC}", "ABC");
-    try expectExpansion("{A,B,C}", "A B C");
-    try expectExpansion("ABC", "ABC");
-
-    try expectExpansion("", "");
-    try expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh");
-    try expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh");
-    try expectExpansion("{A,B}a", "Aa Ba");
-    try expectExpansion("{C,{x,y}}", "C x y");
-    try expectExpansion("z{C,{x,y}}", "zC zx zy");
-    try expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg");
-    try expectExpansion("a{x,y}b", "axb ayb");
-    try expectExpansion("z{{a,b}}", "za zb");
-    try expectExpansion("a{b}", "ab");
-}
-
-fn expectExpansion(test_input: []const u8, expected_result: []const u8) !void {
-    var result = ArrayList(u8).init(global_allocator);
-    defer result.deinit();
-
-    expandString(test_input, &result) catch unreachable;
-
-    try testing.expectEqualSlices(u8, expected_result, result.items);
-}
diff --git a/test/standalone/build.zig.zon b/test/standalone/build.zig.zon
index c60aeb10e6ca2aa015aa9371d8863fdc6d727185..d65d9c778f5962c9fc9b2b9edf2867e77bd583b3 100644
--- a/test/standalone/build.zig.zon
+++ b/test/standalone/build.zig.zon
@@ -2,6 +2,9 @@
     .name = "standalone_test_cases",
     .version = "0.0.0",
     .dependencies = .{
+        // "Simple" test cases (those in the 'simple' directory) are configured by the root build
+        // script, outside of this package.
+
         .test_runner_path = .{
             .path = "test_runner_path",
         },
diff --git a/test/standalone/cat/main.zig b/test/standalone/cat/main.zig
deleted file mode 100644
index 740e73a33e21e027c5f7a2c87db83547e6cc152b..0000000000000000000000000000000000000000
--- a/test/standalone/cat/main.zig
+++ /dev/null
@@ -1,46 +0,0 @@
-const std = @import("std");
-const io = std.io;
-const process = std.process;
-const fs = std.fs;
-const mem = std.mem;
-const warn = std.log.warn;
-
-pub fn main() !void {
-    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_instance.deinit();
-    const arena = arena_instance.allocator();
-
-    const args = try process.argsAlloc(arena);
-
-    const exe = args[0];
-    var catted_anything = false;
-    const stdout_file = io.getStdOut();
-
-    const cwd = fs.cwd();
-
-    for (args[1..]) |arg| {
-        if (mem.eql(u8, arg, "-")) {
-            catted_anything = true;
-            try stdout_file.writeFileAll(io.getStdIn(), .{});
-        } else if (mem.startsWith(u8, arg, "-")) {
-            return usage(exe);
-        } else {
-            const file = cwd.openFile(arg, .{}) catch |err| {
-                warn("Unable to open file: {s}\n", .{@errorName(err)});
-                return err;
-            };
-            defer file.close();
-
-            catted_anything = true;
-            try stdout_file.writeFileAll(file, .{});
-        }
-    }
-    if (!catted_anything) {
-        try stdout_file.writeFileAll(io.getStdIn(), .{});
-    }
-}
-
-fn usage(exe: []const u8) !void {
-    warn("Usage: {s} [FILE]...\n", .{exe});
-    return error.Invalid;
-}
diff --git a/test/standalone/guess_number/main.zig b/test/standalone/guess_number/main.zig
deleted file mode 100644
index ad848608703fd5eafc992c09259ebcc9463702d4..0000000000000000000000000000000000000000
--- a/test/standalone/guess_number/main.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const io = std.io;
-const fmt = std.fmt;
-
-pub fn main() !void {
-    const stdout = io.getStdOut().writer();
-    const stdin = io.getStdIn();
-
-    try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
-
-    const answer = std.crypto.random.intRangeLessThan(u8, 0, 100) + 1;
-
-    while (true) {
-        try stdout.print("\nGuess a number between 1 and 100: ", .{});
-        var line_buf: [20]u8 = undefined;
-
-        const amt = try stdin.read(&line_buf);
-        if (amt == line_buf.len) {
-            try stdout.print("Input too long.\n", .{});
-            continue;
-        }
-        const line = std.mem.trimRight(u8, line_buf[0..amt], "\r\n");
-
-        const guess = fmt.parseUnsigned(u8, line, 10) catch {
-            try stdout.print("Invalid number.\n", .{});
-            continue;
-        };
-        if (guess > answer) {
-            try stdout.print("Guess lower.\n", .{});
-        } else if (guess < answer) {
-            try stdout.print("Guess higher.\n", .{});
-        } else {
-            try stdout.print("You win!\n", .{});
-            return;
-        }
-    }
-}
diff --git a/test/standalone/hello_world/hello.zig b/test/standalone/hello_world/hello.zig
deleted file mode 100644
index eabb226eb2ccd93b053baaa73d68f1c63dc46f5e..0000000000000000000000000000000000000000
--- a/test/standalone/hello_world/hello.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-const std = @import("std");
-
-pub fn main() !void {
-    try std.io.getStdOut().writeAll("Hello, World!\n");
-}
diff --git a/test/standalone/hello_world/hello_libc.zig b/test/standalone/hello_world/hello_libc.zig
deleted file mode 100644
index 992afd736e76f7e52bb71c3eb482f98a0526a2a9..0000000000000000000000000000000000000000
--- a/test/standalone/hello_world/hello_libc.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const c = @cImport({
-    // See https://github.com/ziglang/zig/issues/515
-    @cDefine("_NO_CRT_STDIO_INLINE", "1");
-    @cInclude("stdio.h");
-    @cInclude("string.h");
-});
-
-const msg = "Hello, world!\n";
-
-pub export fn main(argc: c_int, argv: **u8) c_int {
-    _ = argv;
-    _ = argc;
-    if (c.printf(msg) != @as(c_int, @intCast(c.strlen(msg)))) return -1;
-    return 0;
-}
diff --git a/test/standalone/issue_12471/main.zig b/test/standalone/issue_12471/main.zig
deleted file mode 100644
index 08be1fd4713563e0e6051739aed33630f8c65501..0000000000000000000000000000000000000000
--- a/test/standalone/issue_12471/main.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const c = @cImport({
-    @cDefine("FOO", "FOO");
-    @cDefine("BAR", "FOO");
-
-    @cDefine("BAZ", "QUX");
-    @cDefine("QUX", "QUX");
-});
-
-pub fn main() u8 {
-    _ = c;
-    return 0;
-}
diff --git a/test/standalone/issue_7030.zig b/test/standalone/issue_7030.zig
deleted file mode 100644
index 4d4a7279f6b19faf05bb479bb219a70e3dae382d..0000000000000000000000000000000000000000
--- a/test/standalone/issue_7030.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const std = @import("std");
-
-pub const std_options = .{
-    .logFn = log,
-};
-
-pub fn log(
-    comptime message_level: std.log.Level,
-    comptime scope: @Type(.EnumLiteral),
-    comptime format: []const u8,
-    args: anytype,
-) void {
-    _ = message_level;
-    _ = scope;
-    _ = format;
-    _ = args;
-}
-
-pub fn main() anyerror!void {
-    std.log.info("All your codebase are belong to us.", .{});
-}
diff --git a/test/standalone/issue_9402/main.zig b/test/standalone/issue_9402/main.zig
deleted file mode 100644
index eea6bbf4b5e145b7a62b525a2f66bb4cb92b08a5..0000000000000000000000000000000000000000
--- a/test/standalone/issue_9402/main.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const FILE = extern struct {
-    dummy_field: u8,
-};
-
-extern fn _ftelli64([*c]FILE) i64;
-extern fn _fseeki64([*c]FILE, i64, c_int) c_int;
-
-pub export fn main(argc: c_int, argv: **u8) c_int {
-    _ = argv;
-    _ = argc;
-    _ = _ftelli64(null);
-    _ = _fseeki64(null, 123, 2);
-    return 0;
-}
diff --git a/test/standalone/main_return_error/error_u8.zig b/test/standalone/main_return_error/error_u8.zig
deleted file mode 100644
index 8fbe1e8f6595e350964d9ba61e4c94091988fe9c..0000000000000000000000000000000000000000
--- a/test/standalone/main_return_error/error_u8.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-const Err = error{Foo};
-
-pub fn main() !u8 {
-    return Err.Foo;
-}
diff --git a/test/standalone/main_return_error/error_u8_non_zero.zig b/test/standalone/main_return_error/error_u8_non_zero.zig
deleted file mode 100644
index 47fe7946ec1e4ce6fdd33a749fc11d313eb3f3ab..0000000000000000000000000000000000000000
--- a/test/standalone/main_return_error/error_u8_non_zero.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Err = error{Foo};
-
-fn foo() u8 {
-    return @intCast(9);
-}
-
-pub fn main() !u8 {
-    if (foo() == 7) return Err.Foo;
-    return 123;
-}
diff --git a/test/standalone/noreturn_call/as_arg.zig b/test/standalone/noreturn_call/as_arg.zig
deleted file mode 100644
index 08a4f0bd75803280775cd7644bec88b850e0b344..0000000000000000000000000000000000000000
--- a/test/standalone/noreturn_call/as_arg.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const std = @import("std");
-fn foo() noreturn {
-    std.process.exit(0);
-}
-fn bar(_: u8, _: u8) void {}
-pub fn main() void {
-    bar(foo(), @compileError("bad"));
-}
diff --git a/test/standalone/noreturn_call/inline.zig b/test/standalone/noreturn_call/inline.zig
deleted file mode 100644
index 436d97896a774f5a84fa344822c9668026c4a432..0000000000000000000000000000000000000000
--- a/test/standalone/noreturn_call/inline.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    _ = bar();
-}
-inline fn bar() u8 {
-    noret();
-}
-const std = @import("std");
-inline fn noret() noreturn {
-    std.process.exit(0);
-}
diff --git a/test/standalone/simple/brace_expansion.zig b/test/standalone/simple/brace_expansion.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7a769f6af7435c1f782a9676febf2dd91e557e23
--- /dev/null
+++ b/test/standalone/simple/brace_expansion.zig
@@ -0,0 +1,292 @@
+const std = @import("std");
+const io = std.io;
+const mem = std.mem;
+const debug = std.debug;
+const assert = debug.assert;
+const testing = std.testing;
+const ArrayList = std.ArrayList;
+const maxInt = std.math.maxInt;
+
+const Token = union(enum) {
+    Word: []const u8,
+    OpenBrace,
+    CloseBrace,
+    Comma,
+    Eof,
+};
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+var global_allocator = gpa.allocator();
+
+fn tokenize(input: []const u8) !ArrayList(Token) {
+    const State = enum {
+        Start,
+        Word,
+    };
+
+    var token_list = ArrayList(Token).init(global_allocator);
+    errdefer token_list.deinit();
+    var tok_begin: usize = undefined;
+    var state = State.Start;
+
+    for (input, 0..) |b, i| {
+        switch (state) {
+            .Start => switch (b) {
+                'a'...'z', 'A'...'Z' => {
+                    state = State.Word;
+                    tok_begin = i;
+                },
+                '{' => try token_list.append(Token.OpenBrace),
+                '}' => try token_list.append(Token.CloseBrace),
+                ',' => try token_list.append(Token.Comma),
+                else => return error.InvalidInput,
+            },
+            .Word => switch (b) {
+                'a'...'z', 'A'...'Z' => {},
+                '{', '}', ',' => {
+                    try token_list.append(Token{ .Word = input[tok_begin..i] });
+                    switch (b) {
+                        '{' => try token_list.append(Token.OpenBrace),
+                        '}' => try token_list.append(Token.CloseBrace),
+                        ',' => try token_list.append(Token.Comma),
+                        else => unreachable,
+                    }
+                    state = State.Start;
+                },
+                else => return error.InvalidInput,
+            },
+        }
+    }
+    switch (state) {
+        State.Start => {},
+        State.Word => try token_list.append(Token{ .Word = input[tok_begin..] }),
+    }
+    try token_list.append(Token.Eof);
+    return token_list;
+}
+
+const Node = union(enum) {
+    Scalar: []const u8,
+    List: ArrayList(Node),
+    Combine: []Node,
+
+    fn deinit(self: Node) void {
+        switch (self) {
+            .Scalar => {},
+            .Combine => |pair| {
+                pair[0].deinit();
+                pair[1].deinit();
+                global_allocator.free(pair);
+            },
+            .List => |list| {
+                for (list.items) |item| {
+                    item.deinit();
+                }
+                list.deinit();
+            },
+        }
+    }
+};
+
+const ParseError = error{
+    InvalidInput,
+    OutOfMemory,
+};
+
+fn parse(tokens: *const ArrayList(Token), token_index: *usize) ParseError!Node {
+    const first_token = tokens.items[token_index.*];
+    token_index.* += 1;
+
+    const result_node = switch (first_token) {
+        .Word => |word| Node{ .Scalar = word },
+        .OpenBrace => blk: {
+            var list = ArrayList(Node).init(global_allocator);
+            errdefer {
+                for (list.items) |node| node.deinit();
+                list.deinit();
+            }
+            while (true) {
+                try list.append(try parse(tokens, token_index));
+
+                const token = tokens.items[token_index.*];
+                token_index.* += 1;
+
+                switch (token) {
+                    .CloseBrace => break,
+                    .Comma => continue,
+                    else => return error.InvalidInput,
+                }
+            }
+            break :blk Node{ .List = list };
+        },
+        else => return error.InvalidInput,
+    };
+
+    switch (tokens.items[token_index.*]) {
+        .Word, .OpenBrace => {
+            const pair = try global_allocator.alloc(Node, 2);
+            errdefer global_allocator.free(pair);
+            pair[0] = result_node;
+            pair[1] = try parse(tokens, token_index);
+            return Node{ .Combine = pair };
+        },
+        else => return result_node,
+    }
+}
+
+fn expandString(input: []const u8, output: *ArrayList(u8)) !void {
+    const tokens = try tokenize(input);
+    defer tokens.deinit();
+    if (tokens.items.len == 1) {
+        return output.resize(0);
+    }
+
+    var token_index: usize = 0;
+    const root = try parse(&tokens, &token_index);
+    defer root.deinit();
+    const last_token = tokens.items[token_index];
+    switch (last_token) {
+        Token.Eof => {},
+        else => return error.InvalidInput,
+    }
+
+    var result_list = ArrayList(ArrayList(u8)).init(global_allocator);
+    defer {
+        for (result_list.items) |*buf| buf.deinit();
+        result_list.deinit();
+    }
+
+    try expandNode(root, &result_list);
+
+    try output.resize(0);
+    for (result_list.items, 0..) |buf, i| {
+        if (i != 0) {
+            try output.append(' ');
+        }
+        try output.appendSlice(buf.items);
+    }
+}
+
+const ExpandNodeError = error{OutOfMemory};
+
+fn expandNode(node: Node, output: *ArrayList(ArrayList(u8))) ExpandNodeError!void {
+    assert(output.items.len == 0);
+    switch (node) {
+        .Scalar => |scalar| {
+            var list = ArrayList(u8).init(global_allocator);
+            errdefer list.deinit();
+            try list.appendSlice(scalar);
+            try output.append(list);
+        },
+        .Combine => |pair| {
+            const a_node = pair[0];
+            const b_node = pair[1];
+
+            var child_list_a = ArrayList(ArrayList(u8)).init(global_allocator);
+            defer {
+                for (child_list_a.items) |*buf| buf.deinit();
+                child_list_a.deinit();
+            }
+            try expandNode(a_node, &child_list_a);
+
+            var child_list_b = ArrayList(ArrayList(u8)).init(global_allocator);
+            defer {
+                for (child_list_b.items) |*buf| buf.deinit();
+                child_list_b.deinit();
+            }
+            try expandNode(b_node, &child_list_b);
+
+            for (child_list_a.items) |buf_a| {
+                for (child_list_b.items) |buf_b| {
+                    var combined_buf = ArrayList(u8).init(global_allocator);
+                    errdefer combined_buf.deinit();
+
+                    try combined_buf.appendSlice(buf_a.items);
+                    try combined_buf.appendSlice(buf_b.items);
+                    try output.append(combined_buf);
+                }
+            }
+        },
+        .List => |list| {
+            for (list.items) |child_node| {
+                var child_list = ArrayList(ArrayList(u8)).init(global_allocator);
+                errdefer for (child_list.items) |*buf| buf.deinit();
+                defer child_list.deinit();
+
+                try expandNode(child_node, &child_list);
+
+                for (child_list.items) |buf| {
+                    try output.append(buf);
+                }
+            }
+        },
+    }
+}
+
+pub fn main() !void {
+    defer _ = gpa.deinit();
+    const stdin_file = io.getStdIn();
+    const stdout_file = io.getStdOut();
+
+    const stdin = try stdin_file.reader().readAllAlloc(global_allocator, std.math.maxInt(usize));
+    defer global_allocator.free(stdin);
+
+    var result_buf = ArrayList(u8).init(global_allocator);
+    defer result_buf.deinit();
+
+    try expandString(stdin, &result_buf);
+    try stdout_file.writeAll(result_buf.items);
+}
+
+test "invalid inputs" {
+    global_allocator = std.testing.allocator;
+
+    try expectError("}ABC", error.InvalidInput);
+    try expectError("{ABC", error.InvalidInput);
+    try expectError("}{", error.InvalidInput);
+    try expectError("{}", error.InvalidInput);
+    try expectError("A,B,C", error.InvalidInput);
+    try expectError("{A{B,C}", error.InvalidInput);
+    try expectError("{A,}", error.InvalidInput);
+
+    try expectError("\n", error.InvalidInput);
+}
+
+fn expectError(test_input: []const u8, expected_err: anyerror) !void {
+    var output_buf = ArrayList(u8).init(global_allocator);
+    defer output_buf.deinit();
+
+    try testing.expectError(expected_err, expandString(test_input, &output_buf));
+}
+
+test "valid inputs" {
+    global_allocator = std.testing.allocator;
+
+    try expectExpansion("{x,y,z}", "x y z");
+    try expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
+    try expectExpansion("{A,B{x,y}}", "A Bx By");
+
+    try expectExpansion("{ABC}", "ABC");
+    try expectExpansion("{A,B,C}", "A B C");
+    try expectExpansion("ABC", "ABC");
+
+    try expectExpansion("", "");
+    try expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh");
+    try expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh");
+    try expectExpansion("{A,B}a", "Aa Ba");
+    try expectExpansion("{C,{x,y}}", "C x y");
+    try expectExpansion("z{C,{x,y}}", "zC zx zy");
+    try expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg");
+    try expectExpansion("a{x,y}b", "axb ayb");
+    try expectExpansion("z{{a,b}}", "za zb");
+    try expectExpansion("a{b}", "ab");
+}
+
+fn expectExpansion(test_input: []const u8, expected_result: []const u8) !void {
+    var result = ArrayList(u8).init(global_allocator);
+    defer result.deinit();
+
+    expandString(test_input, &result) catch unreachable;
+
+    try testing.expectEqualSlices(u8, expected_result, result.items);
+}
diff --git a/test/standalone/simple/cat/main.zig b/test/standalone/simple/cat/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..740e73a33e21e027c5f7a2c87db83547e6cc152b
--- /dev/null
+++ b/test/standalone/simple/cat/main.zig
@@ -0,0 +1,46 @@
+const std = @import("std");
+const io = std.io;
+const process = std.process;
+const fs = std.fs;
+const mem = std.mem;
+const warn = std.log.warn;
+
+pub fn main() !void {
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+
+    const args = try process.argsAlloc(arena);
+
+    const exe = args[0];
+    var catted_anything = false;
+    const stdout_file = io.getStdOut();
+
+    const cwd = fs.cwd();
+
+    for (args[1..]) |arg| {
+        if (mem.eql(u8, arg, "-")) {
+            catted_anything = true;
+            try stdout_file.writeFileAll(io.getStdIn(), .{});
+        } else if (mem.startsWith(u8, arg, "-")) {
+            return usage(exe);
+        } else {
+            const file = cwd.openFile(arg, .{}) catch |err| {
+                warn("Unable to open file: {s}\n", .{@errorName(err)});
+                return err;
+            };
+            defer file.close();
+
+            catted_anything = true;
+            try stdout_file.writeFileAll(file, .{});
+        }
+    }
+    if (!catted_anything) {
+        try stdout_file.writeFileAll(io.getStdIn(), .{});
+    }
+}
+
+fn usage(exe: []const u8) !void {
+    warn("Usage: {s} [FILE]...\n", .{exe});
+    return error.Invalid;
+}
diff --git a/test/standalone/simple/guess_number/main.zig b/test/standalone/simple/guess_number/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ad848608703fd5eafc992c09259ebcc9463702d4
--- /dev/null
+++ b/test/standalone/simple/guess_number/main.zig
@@ -0,0 +1,38 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const io = std.io;
+const fmt = std.fmt;
+
+pub fn main() !void {
+    const stdout = io.getStdOut().writer();
+    const stdin = io.getStdIn();
+
+    try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
+
+    const answer = std.crypto.random.intRangeLessThan(u8, 0, 100) + 1;
+
+    while (true) {
+        try stdout.print("\nGuess a number between 1 and 100: ", .{});
+        var line_buf: [20]u8 = undefined;
+
+        const amt = try stdin.read(&line_buf);
+        if (amt == line_buf.len) {
+            try stdout.print("Input too long.\n", .{});
+            continue;
+        }
+        const line = std.mem.trimRight(u8, line_buf[0..amt], "\r\n");
+
+        const guess = fmt.parseUnsigned(u8, line, 10) catch {
+            try stdout.print("Invalid number.\n", .{});
+            continue;
+        };
+        if (guess > answer) {
+            try stdout.print("Guess lower.\n", .{});
+        } else if (guess < answer) {
+            try stdout.print("Guess higher.\n", .{});
+        } else {
+            try stdout.print("You win!\n", .{});
+            return;
+        }
+    }
+}
diff --git a/test/standalone/simple/hello_world/hello.zig b/test/standalone/simple/hello_world/hello.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eabb226eb2ccd93b053baaa73d68f1c63dc46f5e
--- /dev/null
+++ b/test/standalone/simple/hello_world/hello.zig
@@ -0,0 +1,5 @@
+const std = @import("std");
+
+pub fn main() !void {
+    try std.io.getStdOut().writeAll("Hello, World!\n");
+}
diff --git a/test/standalone/simple/hello_world/hello_libc.zig b/test/standalone/simple/hello_world/hello_libc.zig
new file mode 100644
index 0000000000000000000000000000000000000000..992afd736e76f7e52bb71c3eb482f98a0526a2a9
--- /dev/null
+++ b/test/standalone/simple/hello_world/hello_libc.zig
@@ -0,0 +1,15 @@
+const c = @cImport({
+    // See https://github.com/ziglang/zig/issues/515
+    @cDefine("_NO_CRT_STDIO_INLINE", "1");
+    @cInclude("stdio.h");
+    @cInclude("string.h");
+});
+
+const msg = "Hello, world!\n";
+
+pub export fn main(argc: c_int, argv: **u8) c_int {
+    _ = argv;
+    _ = argc;
+    if (c.printf(msg) != @as(c_int, @intCast(c.strlen(msg)))) return -1;
+    return 0;
+}
diff --git a/test/standalone/simple/issue_12471/main.zig b/test/standalone/simple/issue_12471/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08be1fd4713563e0e6051739aed33630f8c65501
--- /dev/null
+++ b/test/standalone/simple/issue_12471/main.zig
@@ -0,0 +1,12 @@
+const c = @cImport({
+    @cDefine("FOO", "FOO");
+    @cDefine("BAR", "FOO");
+
+    @cDefine("BAZ", "QUX");
+    @cDefine("QUX", "QUX");
+});
+
+pub fn main() u8 {
+    _ = c;
+    return 0;
+}
diff --git a/test/standalone/simple/issue_7030.zig b/test/standalone/simple/issue_7030.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d4a7279f6b19faf05bb479bb219a70e3dae382d
--- /dev/null
+++ b/test/standalone/simple/issue_7030.zig
@@ -0,0 +1,21 @@
+const std = @import("std");
+
+pub const std_options = .{
+    .logFn = log,
+};
+
+pub fn log(
+    comptime message_level: std.log.Level,
+    comptime scope: @Type(.EnumLiteral),
+    comptime format: []const u8,
+    args: anytype,
+) void {
+    _ = message_level;
+    _ = scope;
+    _ = format;
+    _ = args;
+}
+
+pub fn main() anyerror!void {
+    std.log.info("All your codebase are belong to us.", .{});
+}
diff --git a/test/standalone/simple/issue_9402/main.zig b/test/standalone/simple/issue_9402/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eea6bbf4b5e145b7a62b525a2f66bb4cb92b08a5
--- /dev/null
+++ b/test/standalone/simple/issue_9402/main.zig
@@ -0,0 +1,14 @@
+const FILE = extern struct {
+    dummy_field: u8,
+};
+
+extern fn _ftelli64([*c]FILE) i64;
+extern fn _fseeki64([*c]FILE, i64, c_int) c_int;
+
+pub export fn main(argc: c_int, argv: **u8) c_int {
+    _ = argv;
+    _ = argc;
+    _ = _ftelli64(null);
+    _ = _fseeki64(null, 123, 2);
+    return 0;
+}
diff --git a/test/standalone/simple/main_return_error/error_u8.zig b/test/standalone/simple/main_return_error/error_u8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8fbe1e8f6595e350964d9ba61e4c94091988fe9c
--- /dev/null
+++ b/test/standalone/simple/main_return_error/error_u8.zig
@@ -0,0 +1,5 @@
+const Err = error{Foo};
+
+pub fn main() !u8 {
+    return Err.Foo;
+}
diff --git a/test/standalone/simple/main_return_error/error_u8_non_zero.zig b/test/standalone/simple/main_return_error/error_u8_non_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47fe7946ec1e4ce6fdd33a749fc11d313eb3f3ab
--- /dev/null
+++ b/test/standalone/simple/main_return_error/error_u8_non_zero.zig
@@ -0,0 +1,10 @@
+const Err = error{Foo};
+
+fn foo() u8 {
+    return @intCast(9);
+}
+
+pub fn main() !u8 {
+    if (foo() == 7) return Err.Foo;
+    return 123;
+}
diff --git a/test/standalone/simple/noreturn_call/as_arg.zig b/test/standalone/simple/noreturn_call/as_arg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08a4f0bd75803280775cd7644bec88b850e0b344
--- /dev/null
+++ b/test/standalone/simple/noreturn_call/as_arg.zig
@@ -0,0 +1,8 @@
+const std = @import("std");
+fn foo() noreturn {
+    std.process.exit(0);
+}
+fn bar(_: u8, _: u8) void {}
+pub fn main() void {
+    bar(foo(), @compileError("bad"));
+}
diff --git a/test/standalone/simple/noreturn_call/inline.zig b/test/standalone/simple/noreturn_call/inline.zig
new file mode 100644
index 0000000000000000000000000000000000000000..436d97896a774f5a84fa344822c9668026c4a432
--- /dev/null
+++ b/test/standalone/simple/noreturn_call/inline.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    _ = bar();
+}
+inline fn bar() u8 {
+    noret();
+}
+const std = @import("std");
+inline fn noret() noreturn {
+    std.process.exit(0);
+}
diff --git a/test/standalone/simple/std_enums_big_enums.zig b/test/standalone/simple/std_enums_big_enums.zig
new file mode 100644
index 0000000000000000000000000000000000000000..76237d3447a06a5125b1fe03cd1305aa2f8cc198
--- /dev/null
+++ b/test/standalone/simple/std_enums_big_enums.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+
+// big enums should not hit the eval branch quota
+pub fn main() void {
+    const big = struct {
+        const Big = @Type(@as(std.builtin.Type, .{
+            .Enum = .{
+                .tag_type = u16,
+                .fields = make_fields: {
+                    var fields: [1001]std.builtin.Type.EnumField = undefined;
+                    for (&fields, 0..) |*field, i| {
+                        field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };
+                    }
+                    fields[1000] = .{ .name = "field_9999", .value = 9999 };
+                    break :make_fields &fields;
+                },
+                .decls = &.{},
+                .is_exhaustive = true,
+            },
+        }));
+    };
+
+    var set = std.enums.EnumSet(big.Big).init(.{});
+    _ = &set;
+
+    var map = std.enums.EnumMap(big.Big, u8).init(undefined);
+    map = std.enums.EnumMap(big.Big, u8).initFullWith(undefined);
+    map = std.enums.EnumMap(big.Big, u8).initFullWithDefault(123, .{});
+
+    var multiset = std.enums.EnumMultiset(big.Big).init(.{});
+    _ = &multiset;
+
+    var bounded_multiset = std.enums.BoundedEnumMultiset(big.Big, u8).init(.{});
+    _ = &bounded_multiset;
+
+    var array = std.enums.EnumArray(big.Big, u8).init(undefined);
+    array = std.enums.EnumArray(big.Big, u8).initDefault(123, .{});
+}
diff --git a/test/standalone/std_enums_big_enums.zig b/test/standalone/std_enums_big_enums.zig
deleted file mode 100644
index 76237d3447a06a5125b1fe03cd1305aa2f8cc198..0000000000000000000000000000000000000000
--- a/test/standalone/std_enums_big_enums.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-const std = @import("std");
-
-// big enums should not hit the eval branch quota
-pub fn main() void {
-    const big = struct {
-        const Big = @Type(@as(std.builtin.Type, .{
-            .Enum = .{
-                .tag_type = u16,
-                .fields = make_fields: {
-                    var fields: [1001]std.builtin.Type.EnumField = undefined;
-                    for (&fields, 0..) |*field, i| {
-                        field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };
-                    }
-                    fields[1000] = .{ .name = "field_9999", .value = 9999 };
-                    break :make_fields &fields;
-                },
-                .decls = &.{},
-                .is_exhaustive = true,
-            },
-        }));
-    };
-
-    var set = std.enums.EnumSet(big.Big).init(.{});
-    _ = &set;
-
-    var map = std.enums.EnumMap(big.Big, u8).init(undefined);
-    map = std.enums.EnumMap(big.Big, u8).initFullWith(undefined);
-    map = std.enums.EnumMap(big.Big, u8).initFullWithDefault(123, .{});
-
-    var multiset = std.enums.EnumMultiset(big.Big).init(.{});
-    _ = &multiset;
-
-    var bounded_multiset = std.enums.BoundedEnumMultiset(big.Big, u8).init(.{});
-    _ = &bounded_multiset;
-
-    var array = std.enums.EnumArray(big.Big, u8).init(undefined);
-    array = std.enums.EnumArray(big.Big, u8).initDefault(123, .{});
-}