diff --git a/build.zig b/build.zig
index 5ca0e08d4ef97144e47fb1327928f010438a3c58..98025dbb137b0ba9bc621a76f756fd06cd25f38c 100644
--- a/build.zig
+++ b/build.zig
@@ -471,6 +471,7 @@ pub fn build(b: *std.Build) !void {
         .name = "behavior",
         .desc = "Run the behavior tests",
         .optimize_modes = optimization_modes,
+        .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
         .skip_cross_glibc = skip_cross_glibc,
@@ -478,12 +479,26 @@ pub fn build(b: *std.Build) !void {
         .max_rss = 1 * 1024 * 1024 * 1024,
     }));
 
+    test_step.dependOn(tests.addModuleTests(b, .{
+        .test_filter = test_filter,
+        .root_src = "test/c_import.zig",
+        .name = "c-import",
+        .desc = "Run the @cImport tests",
+        .optimize_modes = optimization_modes,
+        .include_paths = &.{"test/c_import"},
+        .skip_single_threaded = true,
+        .skip_non_native = skip_non_native,
+        .skip_cross_glibc = skip_cross_glibc,
+        .skip_libc = skip_libc,
+    }));
+
     test_step.dependOn(tests.addModuleTests(b, .{
         .test_filter = test_filter,
         .root_src = "lib/compiler_rt.zig",
         .name = "compiler-rt",
         .desc = "Run the compiler_rt tests",
         .optimize_modes = optimization_modes,
+        .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
         .skip_cross_glibc = skip_cross_glibc,
@@ -496,6 +511,7 @@ pub fn build(b: *std.Build) !void {
         .name = "universal-libc",
         .desc = "Run the universal libc tests",
         .optimize_modes = optimization_modes,
+        .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
         .skip_cross_glibc = skip_cross_glibc,
@@ -527,6 +543,7 @@ pub fn build(b: *std.Build) !void {
         .name = "std",
         .desc = "Run the standard library tests",
         .optimize_modes = optimization_modes,
+        .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
         .skip_cross_glibc = skip_cross_glibc,
diff --git a/ci/aarch64-linux-debug.sh b/ci/aarch64-linux-debug.sh
index 9f4f159f1352d3b18c681ff0131b99eeff0b21f6..750f76e103461d13b991001767143a16f2557fb3 100644
--- a/ci/aarch64-linux-debug.sh
+++ b/ci/aarch64-linux-debug.sh
@@ -99,11 +99,11 @@ unset CXX
 
 ninja install
 
-stage3/bin/zig test ../test/behavior.zig -I../test
+stage3/bin/zig test ../test/behavior.zig
 stage3/bin/zig build -p stage4 \
   -Dstatic-llvm \
   -Dtarget=native-native-musl \
   -Dno-lib \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$(pwd)/../lib"
-stage4/bin/zig test ../test/behavior.zig -I../test
+stage4/bin/zig test ../test/behavior.zig
diff --git a/ci/aarch64-linux-release.sh b/ci/aarch64-linux-release.sh
index 40af643502e362b4a78ba6155618d72788f30526..2a70b4dd1af9865ad1000e6d012ce3e1dab5b3b2 100644
--- a/ci/aarch64-linux-release.sh
+++ b/ci/aarch64-linux-release.sh
@@ -99,11 +99,11 @@ unset CXX
 
 ninja install
 
-stage3/bin/zig test ../test/behavior.zig -I../test
+stage3/bin/zig test ../test/behavior.zig
 stage3/bin/zig build -p stage4 \
   -Dstatic-llvm \
   -Dtarget=native-native-musl \
   -Dno-lib \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$(pwd)/../lib"
-stage4/bin/zig test ../test/behavior.zig -I../test
+stage4/bin/zig test ../test/behavior.zig
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 69c71c50aad5846b72c0412b4c3b2587b1b0eff6..d6df5639250309fb35ec13f4fdc64ef017b6cc48 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -25,8 +25,7 @@ rm -rf zig-out
 cc -o bootstrap bootstrap.c
 ./bootstrap
 ./zig2 build -Dno-lib
-# In order to run these behavior tests we need to move the `@cImport` ones to somewhere else.
-# ./zig-out/bin/zig test test/behavior.zig
+./zig-out/bin/zig test test/behavior.zig
 
 export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
 export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
@@ -108,11 +107,11 @@ unset CXX
 
 ninja install
 
-stage3/bin/zig test ../test/behavior.zig -I../test
+stage3/bin/zig test ../test/behavior.zig
 stage3/bin/zig build -p stage4 \
   -Dstatic-llvm \
   -Dtarget=native-native-musl \
   -Dno-lib \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$(pwd)/../lib"
-stage4/bin/zig test ../test/behavior.zig -I../test
+stage4/bin/zig test ../test/behavior.zig
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 3e5f3a232c32c8dcbd65f6921c69482f624ff489..2518100f9e0aca552c41da419690e834bed2a32c 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -25,8 +25,7 @@ rm -rf zig-out
 cc -o bootstrap bootstrap.c
 ./bootstrap
 ./zig2 build -Dno-lib
-# In order to run these behavior tests we need to move the `@cImport` ones to somewhere else.
-# ./zig-out/bin/zig test test/behavior.zig
+./zig-out/bin/zig test test/behavior.zig
 
 export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
 export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
@@ -125,11 +124,11 @@ unset CXX
 
 ninja install
 
-stage3/bin/zig test ../test/behavior.zig -I../test
+stage3/bin/zig test ../test/behavior.zig
 stage3/bin/zig build -p stage4 \
   -Dstatic-llvm \
   -Dtarget=native-native-musl \
   -Dno-lib \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$(pwd)/../lib"
-stage4/bin/zig test ../test/behavior.zig -I../test
+stage4/bin/zig test ../test/behavior.zig
diff --git a/ci/x86_64-macos-release.sh b/ci/x86_64-macos-release.sh
index ecd6d6688633a7b5a53306e7f717e3de9cb29dec..041941b2cf568491b6a79bd3a9fc7886dd7a41d8 100755
--- a/ci/x86_64-macos-release.sh
+++ b/ci/x86_64-macos-release.sh
@@ -31,8 +31,7 @@ rm -rf zig-out
 cc -o bootstrap bootstrap.c
 ./bootstrap
 ./zig2 build -Dno-lib
-# In order to run these behavior tests we need to move the `@cImport` ones to somewhere else.
-# ./zig-out/bin/zig test test/behavior.zig
+./zig-out/bin/zig test test/behavior.zig
 
 rm -rf build
 mkdir build
diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
index 1d73579188c6dbd2137e2f7d53d5910ce7d26125..84cf253957d00ebe5990db21c539f0dfe1f9fe06 100644
--- a/ci/x86_64-windows-debug.ps1
+++ b/ci/x86_64-windows-debug.ps1
@@ -66,8 +66,6 @@ Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
 & "stage3-debug\bin\zig.exe" test `
   ..\test\behavior.zig `
   --zig-lib-dir "$ZIG_LIB_DIR" `
-  -I..\test `
-  -I..\lib `
   -ofmt=c `
   -femit-bin="test-x86_64-windows-msvc.c" `
   --test-no-exec `
diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
index d2fe655182dd2100e9f04c02696e8b2a8c368d2e..4cda0ad98bad28888df9504e9fb161c699a68dd4 100644
--- a/ci/x86_64-windows-release.ps1
+++ b/ci/x86_64-windows-release.ps1
@@ -65,8 +65,6 @@ Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
 & "stage3-release\bin\zig.exe" test `
   ..\test\behavior.zig `
   --zig-lib-dir "$ZIG_LIB_DIR" `
-  -I..\test `
-  -I..\lib `
   -ofmt=c `
   -femit-bin="test-x86_64-windows-msvc.c" `
   --test-no-exec `
diff --git a/test/behavior.zig b/test/behavior.zig
index b8af6b544eb8a931cabba2f51e0272b6a3344d5c..4067ffd99f797a357eecbc2374271d1077c5837c 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -14,7 +14,6 @@ test {
     _ = @import("behavior/bool.zig");
     _ = @import("behavior/byteswap.zig");
     _ = @import("behavior/byval_arg_var.zig");
-    _ = @import("behavior/c_char_signedness.zig");
     _ = @import("behavior/call.zig");
     _ = @import("behavior/call_tail.zig");
     _ = @import("behavior/cast.zig");
@@ -92,7 +91,6 @@ test {
     _ = @import("behavior/switch_prong_implicit_cast.zig");
     _ = @import("behavior/this.zig");
     _ = @import("behavior/threadlocal.zig");
-    _ = @import("behavior/translate_c_macros.zig");
     _ = @import("behavior/truncate.zig");
     _ = @import("behavior/try.zig");
     _ = @import("behavior/tuple.zig");
diff --git a/test/behavior/c_char_signedness.zig b/test/behavior/c_char_signedness.zig
deleted file mode 100644
index 6b0bfe4049b2da56daa675368e5ec11c9ae5adbe..0000000000000000000000000000000000000000
--- a/test/behavior/c_char_signedness.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const expectEqual = std.testing.expectEqual;
-const c = @cImport({
-    @cInclude("limits.h");
-});
-
-test "c_char signedness" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char));
-    try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char));
-}
diff --git a/test/behavior/translate_c_macros.h b/test/behavior/translate_c_macros.h
deleted file mode 100644
index c6e2e381e2d8b84584d6fad87cb19f9aa335e1a4..0000000000000000000000000000000000000000
--- a/test/behavior/translate_c_macros.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// initializer list expression
-typedef struct Color {
-    unsigned char r;
-    unsigned char g;
-    unsigned char b;
-    unsigned char a;
-} Color;
-#define CLITERAL(type)      (type)
-#define LIGHTGRAY  CLITERAL(Color){ 200, 200, 200, 255 }   // Light Gray
-
-#define MY_SIZEOF(x) ((int)sizeof(x))
-#define MY_SIZEOF2(x) ((int)sizeof x)
-
-struct Foo {
-    int a;
-};
-
-union U {
-    long l;
-    double d;
-};
-
-#define SIZE_OF_FOO sizeof(struct Foo)
-
-#define MAP_FAILED	((void *) -1)
-
-#define IGNORE_ME_1(x) ((void)(x))
-#define IGNORE_ME_2(x) ((const void)(x))
-#define IGNORE_ME_3(x) ((volatile void)(x))
-#define IGNORE_ME_4(x) ((const volatile void)(x))
-#define IGNORE_ME_5(x) ((volatile const void)(x))
-
-#define IGNORE_ME_6(x) (void)(x)
-#define IGNORE_ME_7(x) (const void)(x)
-#define IGNORE_ME_8(x) (volatile void)(x)
-#define IGNORE_ME_9(x) (const volatile void)(x)
-#define IGNORE_ME_10(x) (volatile const void)(x)
-
-#define UNION_CAST(X) (union U)(X)
-#define CAST_OR_CALL_WITH_PARENS(type_or_fn, val) ((type_or_fn)(val))
-
-#define NESTED_COMMA_OPERATOR (1, (2, 3))
-#define NESTED_COMMA_OPERATOR_LHS (1, 2), 3
-
-#include <stdint.h>
-#if !defined(__UINTPTR_MAX__)
-typedef _Bool uintptr_t;
-#endif
-
-#define CAST_TO_BOOL(X) (_Bool)(X)
-#define CAST_TO_UINTPTR(X) (uintptr_t)(X)
-
-#define LARGE_INT 18446744073709550592
-
-#define EMBEDDED_TAB "hello	"
-
-#define DIVIDE_CONSTANT(version) (version / 1000)
-#define DIVIDE_ARGS(A, B) (A / B)
-
-#define REMAINDER_CONSTANT(version) (version % 10000)
-#define REMAINDER_ARGS(A, B) (A % B)
-
-#define LONG(x) x##L
-#define X LONG(10)
-
-#define BLANK_MACRO
-#define BLANK_CHILD_MACRO BLANK_MACRO BLANK_MACRO BLANK_MACRO
-#define MACRO_VALUE 0
-typedef long def_type;
-#define BLANK_MACRO_CAST (BLANK_CHILD_MACRO def_type BLANK_CHILD_MACRO)MACRO_VALUE
diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig
deleted file mode 100644
index c8a9e1bad119249a24bec03618f582ad1b070d3b..0000000000000000000000000000000000000000
--- a/test/behavior/translate_c_macros.zig
+++ /dev/null
@@ -1,242 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectEqualStrings = std.testing.expectEqualStrings;
-
-const h = @cImport(@cInclude("behavior/translate_c_macros.h"));
-const latin1 = @cImport(@cInclude("behavior/translate_c_macros_not_utf8.h"));
-
-test "casting to void with a macro" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    h.IGNORE_ME_1(42);
-    h.IGNORE_ME_2(42);
-    h.IGNORE_ME_3(42);
-    h.IGNORE_ME_4(42);
-    h.IGNORE_ME_5(42);
-    h.IGNORE_ME_6(42);
-    h.IGNORE_ME_7(42);
-    h.IGNORE_ME_8(42);
-    h.IGNORE_ME_9(42);
-    h.IGNORE_ME_10(42);
-}
-
-test "initializer list expression" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(h.Color{
-        .r = 200,
-        .g = 200,
-        .b = 200,
-        .a = 255,
-    }, h.LIGHTGRAY);
-}
-
-test "sizeof in macros" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
-    try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
-}
-
-test "reference to a struct type" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
-}
-
-test "cast negative integer to pointer" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))))), h.MAP_FAILED);
-}
-
-test "casting to union with a macro" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    const l: c_long = 42;
-    const d: f64 = 2.0;
-
-    var casted = h.UNION_CAST(l);
-    try expect(l == casted.l);
-
-    casted = h.UNION_CAST(d);
-    try expect(d == casted.d);
-}
-
-test "casting or calling a value with a paren-surrounded macro" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    const l: c_long = 42;
-    const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
-    try expect(casted == @as(c_int, @intCast(l)));
-
-    const Helper = struct {
-        fn foo(n: c_int) !void {
-            try expect(n == 42);
-        }
-    };
-
-    try h.CAST_OR_CALL_WITH_PARENS(Helper.foo, 42);
-}
-
-test "nested comma operator" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
-    try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
-}
-
-test "cast functions" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    const S = struct {
-        fn foo() void {}
-    };
-    try expectEqual(true, h.CAST_TO_BOOL(S.foo));
-    try expect(h.CAST_TO_UINTPTR(S.foo) != 0);
-}
-
-test "large integer macro" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
-}
-
-test "string literal macro with embedded tab character" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
-}
-
-test "string and char literals that are not UTF-8 encoded. Issue #12784" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
-    try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
-}
-
-test "Macro that uses division operator. Issue #13162" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
-
-    try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
-    try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
-
-    try expectEqual(
-        @as(f64, 42.0),
-        h.DIVIDE_ARGS(
-            @as(f64, 42.0),
-            true,
-        ),
-    );
-    try expectEqual(
-        @as(c_int, 21),
-        h.DIVIDE_ARGS(
-            @as(i8, 42),
-            @as(i8, 2),
-        ),
-    );
-
-    try expectEqual(
-        @as(c_int, 21),
-        h.DIVIDE_ARGS(
-            @as(c_ushort, 42),
-            @as(c_ushort, 2),
-        ),
-    );
-}
-
-test "Macro that uses remainder operator. Issue #13346" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
-    try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));
-
-    try expectEqual(
-        @as(c_int, 7),
-        h.REMAINDER_ARGS(
-            @as(i8, 17),
-            @as(i8, 10),
-        ),
-    );
-
-    try expectEqual(
-        @as(c_int, 5),
-        h.REMAINDER_ARGS(
-            @as(c_ushort, 25),
-            @as(c_ushort, 20),
-        ),
-    );
-
-    try expectEqual(
-        @as(c_int, 1),
-        h.REMAINDER_ARGS(
-            @as(c_int, 5),
-            @as(c_int, -2),
-        ),
-    );
-}
-
-test "@typeInfo on @cImport result" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expect(@typeInfo(h).Struct.decls.len > 1);
-}
-
-test "Macro that uses Long type concatenation casting" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expect((@TypeOf(h.X)) == c_long);
-    try expectEqual(h.X, @as(c_long, 10));
-}
-
-test "Blank macros" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    try expectEqual(h.BLANK_MACRO, "");
-    try expectEqual(h.BLANK_CHILD_MACRO, "");
-    try expect(@TypeOf(h.BLANK_MACRO_CAST) == h.def_type);
-    try expectEqual(h.BLANK_MACRO_CAST, @as(c_long, 0));
-}
diff --git a/test/behavior/translate_c_macros_not_utf8.h b/test/behavior/translate_c_macros_not_utf8.h
deleted file mode 100644
index 0a7fa4cc6bb534e125ef62670f9d9d952073c6f7..0000000000000000000000000000000000000000
--- a/test/behavior/translate_c_macros_not_utf8.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// Note: This file is encoded with ISO/IEC 8859-1 (latin1), not UTF-8.
-// Do not change the encoding
-
-#define UNPRINTABLE_STRING "İİİ"
-#define UNPRINTABLE_CHAR 'İ'
diff --git a/test/c_import.zig b/test/c_import.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3252648d18e7a17edb215dd1cd5427ca4dfcb6c6
--- /dev/null
+++ b/test/c_import.zig
@@ -0,0 +1,4 @@
+test {
+    _ = @import("c_import/c_char_signedness.zig");
+    _ = @import("c_import/macros.zig");
+}
diff --git a/test/c_import/c_char_signedness.zig b/test/c_import/c_char_signedness.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6b0bfe4049b2da56daa675368e5ec11c9ae5adbe
--- /dev/null
+++ b/test/c_import/c_char_signedness.zig
@@ -0,0 +1,13 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const expectEqual = std.testing.expectEqual;
+const c = @cImport({
+    @cInclude("limits.h");
+});
+
+test "c_char signedness" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char));
+    try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char));
+}
diff --git a/test/c_import/macros.h b/test/c_import/macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6e2e381e2d8b84584d6fad87cb19f9aa335e1a4
--- /dev/null
+++ b/test/c_import/macros.h
@@ -0,0 +1,70 @@
+// initializer list expression
+typedef struct Color {
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+    unsigned char a;
+} Color;
+#define CLITERAL(type)      (type)
+#define LIGHTGRAY  CLITERAL(Color){ 200, 200, 200, 255 }   // Light Gray
+
+#define MY_SIZEOF(x) ((int)sizeof(x))
+#define MY_SIZEOF2(x) ((int)sizeof x)
+
+struct Foo {
+    int a;
+};
+
+union U {
+    long l;
+    double d;
+};
+
+#define SIZE_OF_FOO sizeof(struct Foo)
+
+#define MAP_FAILED	((void *) -1)
+
+#define IGNORE_ME_1(x) ((void)(x))
+#define IGNORE_ME_2(x) ((const void)(x))
+#define IGNORE_ME_3(x) ((volatile void)(x))
+#define IGNORE_ME_4(x) ((const volatile void)(x))
+#define IGNORE_ME_5(x) ((volatile const void)(x))
+
+#define IGNORE_ME_6(x) (void)(x)
+#define IGNORE_ME_7(x) (const void)(x)
+#define IGNORE_ME_8(x) (volatile void)(x)
+#define IGNORE_ME_9(x) (const volatile void)(x)
+#define IGNORE_ME_10(x) (volatile const void)(x)
+
+#define UNION_CAST(X) (union U)(X)
+#define CAST_OR_CALL_WITH_PARENS(type_or_fn, val) ((type_or_fn)(val))
+
+#define NESTED_COMMA_OPERATOR (1, (2, 3))
+#define NESTED_COMMA_OPERATOR_LHS (1, 2), 3
+
+#include <stdint.h>
+#if !defined(__UINTPTR_MAX__)
+typedef _Bool uintptr_t;
+#endif
+
+#define CAST_TO_BOOL(X) (_Bool)(X)
+#define CAST_TO_UINTPTR(X) (uintptr_t)(X)
+
+#define LARGE_INT 18446744073709550592
+
+#define EMBEDDED_TAB "hello	"
+
+#define DIVIDE_CONSTANT(version) (version / 1000)
+#define DIVIDE_ARGS(A, B) (A / B)
+
+#define REMAINDER_CONSTANT(version) (version % 10000)
+#define REMAINDER_ARGS(A, B) (A % B)
+
+#define LONG(x) x##L
+#define X LONG(10)
+
+#define BLANK_MACRO
+#define BLANK_CHILD_MACRO BLANK_MACRO BLANK_MACRO BLANK_MACRO
+#define MACRO_VALUE 0
+typedef long def_type;
+#define BLANK_MACRO_CAST (BLANK_CHILD_MACRO def_type BLANK_CHILD_MACRO)MACRO_VALUE
diff --git a/test/c_import/macros.zig b/test/c_import/macros.zig
new file mode 100644
index 0000000000000000000000000000000000000000..661d8e38470fd6505f041be66228d2d9a24fd34b
--- /dev/null
+++ b/test/c_import/macros.zig
@@ -0,0 +1,242 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
+
+const h = @cImport(@cInclude("macros.h"));
+const latin1 = @cImport(@cInclude("macros_not_utf8.h"));
+
+test "casting to void with a macro" {
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    h.IGNORE_ME_1(42);
+    h.IGNORE_ME_2(42);
+    h.IGNORE_ME_3(42);
+    h.IGNORE_ME_4(42);
+    h.IGNORE_ME_5(42);
+    h.IGNORE_ME_6(42);
+    h.IGNORE_ME_7(42);
+    h.IGNORE_ME_8(42);
+    h.IGNORE_ME_9(42);
+    h.IGNORE_ME_10(42);
+}
+
+test "initializer list expression" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(h.Color{
+        .r = 200,
+        .g = 200,
+        .b = 200,
+        .a = 255,
+    }, h.LIGHTGRAY);
+}
+
+test "sizeof in macros" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
+    try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
+}
+
+test "reference to a struct type" {
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
+}
+
+test "cast negative integer to pointer" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))))), h.MAP_FAILED);
+}
+
+test "casting to union with a macro" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const l: c_long = 42;
+    const d: f64 = 2.0;
+
+    var casted = h.UNION_CAST(l);
+    try expect(l == casted.l);
+
+    casted = h.UNION_CAST(d);
+    try expect(d == casted.d);
+}
+
+test "casting or calling a value with a paren-surrounded macro" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const l: c_long = 42;
+    const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
+    try expect(casted == @as(c_int, @intCast(l)));
+
+    const Helper = struct {
+        fn foo(n: c_int) !void {
+            try expect(n == 42);
+        }
+    };
+
+    try h.CAST_OR_CALL_WITH_PARENS(Helper.foo, 42);
+}
+
+test "nested comma operator" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
+    try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
+}
+
+test "cast functions" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const S = struct {
+        fn foo() void {}
+    };
+    try expectEqual(true, h.CAST_TO_BOOL(S.foo));
+    try expect(h.CAST_TO_UINTPTR(S.foo) != 0);
+}
+
+test "large integer macro" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
+}
+
+test "string literal macro with embedded tab character" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
+}
+
+test "string and char literals that are not UTF-8 encoded. Issue #12784" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
+    try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
+}
+
+test "Macro that uses division operator. Issue #13162" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
+
+    try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
+    try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
+
+    try expectEqual(
+        @as(f64, 42.0),
+        h.DIVIDE_ARGS(
+            @as(f64, 42.0),
+            true,
+        ),
+    );
+    try expectEqual(
+        @as(c_int, 21),
+        h.DIVIDE_ARGS(
+            @as(i8, 42),
+            @as(i8, 2),
+        ),
+    );
+
+    try expectEqual(
+        @as(c_int, 21),
+        h.DIVIDE_ARGS(
+            @as(c_ushort, 42),
+            @as(c_ushort, 2),
+        ),
+    );
+}
+
+test "Macro that uses remainder operator. Issue #13346" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
+    try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));
+
+    try expectEqual(
+        @as(c_int, 7),
+        h.REMAINDER_ARGS(
+            @as(i8, 17),
+            @as(i8, 10),
+        ),
+    );
+
+    try expectEqual(
+        @as(c_int, 5),
+        h.REMAINDER_ARGS(
+            @as(c_ushort, 25),
+            @as(c_ushort, 20),
+        ),
+    );
+
+    try expectEqual(
+        @as(c_int, 1),
+        h.REMAINDER_ARGS(
+            @as(c_int, 5),
+            @as(c_int, -2),
+        ),
+    );
+}
+
+test "@typeInfo on @cImport result" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expect(@typeInfo(h).Struct.decls.len > 1);
+}
+
+test "Macro that uses Long type concatenation casting" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expect((@TypeOf(h.X)) == c_long);
+    try expectEqual(h.X, @as(c_long, 10));
+}
+
+test "Blank macros" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try expectEqual(h.BLANK_MACRO, "");
+    try expectEqual(h.BLANK_CHILD_MACRO, "");
+    try expect(@TypeOf(h.BLANK_MACRO_CAST) == h.def_type);
+    try expectEqual(h.BLANK_MACRO_CAST, @as(c_long, 0));
+}
diff --git a/test/c_import/macros_not_utf8.h b/test/c_import/macros_not_utf8.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a7fa4cc6bb534e125ef62670f9d9d952073c6f7
--- /dev/null
+++ b/test/c_import/macros_not_utf8.h
@@ -0,0 +1,5 @@
+// Note: This file is encoded with ISO/IEC 8859-1 (latin1), not UTF-8.
+// Do not change the encoding
+
+#define UNPRINTABLE_STRING "İİİ"
+#define UNPRINTABLE_CHAR 'İ'
diff --git a/test/tests.zig b/test/tests.zig
index a749719c83e7352e469520fea6f3dd693b0c0ce9..b07bc50f69b4a4432b3ee21b59d480d07ce31c44 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -1037,6 +1037,7 @@ const ModuleTestOptions = struct {
     name: []const u8,
     desc: []const u8,
     optimize_modes: []const OptimizeMode,
+    include_paths: []const []const u8,
     skip_single_threaded: bool,
     skip_non_native: bool,
     skip_cross_glibc: bool,
@@ -1140,7 +1141,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
         const use_lld = if (test_target.use_lld == false) "-no-lld" else "";
         const use_pic = if (test_target.pic == true) "-pic" else "";
 
-        these_tests.addIncludePath(.{ .path = "test" });
+        for (options.include_paths) |include_path| these_tests.addIncludePath(.{ .path = include_path });
 
         if (target.os.tag == .wasi) {
             // WASI's default stack size can be too small for some big tests.