authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-13 15:58:14-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-09-24 20:01:19-07:00
log79d9997d229c76c1f78c3d69d4a2f150a65ea5a4
tree76ad5f2bd13c44f30863bd79fdb6b890aeca1ae5
parente1d6f478c9e96d89ad1f2683d6b372eb466b8339

delete `@cImport` tests

These are now maintained in a separate repository: ziglang/translate-c

6 files changed, 0 insertions(+), 351 deletions(-)

build.zig-20
...@@ -460,26 +460,6 @@ pub fn build(b: *std.Build) !void {...@@ -460,26 +460,6 @@ pub fn build(b: *std.Build) !void {
460 .max_rss = 4000000000,460 .max_rss = 4000000000,
461 }));461 }));
462462
463 test_modules_step.dependOn(tests.addModuleTests(b, .{
464 .test_filters = test_filters,
465 .test_target_filters = test_target_filters,
466 .test_extra_targets = test_extra_targets,
467 .root_src = "test/c_import.zig",
468 .name = "c-import",
469 .desc = "Run the @cImport tests",
470 .optimize_modes = optimization_modes,
471 .include_paths = &.{"test/c_import"},
472 .skip_single_threaded = true,
473 .skip_non_native = skip_non_native,
474 .skip_freebsd = skip_freebsd,
475 .skip_netbsd = skip_netbsd,
476 .skip_windows = skip_windows,
477 .skip_macos = skip_macos,
478 .skip_linux = skip_linux,
479 .skip_llvm = skip_llvm,
480 .skip_libc = skip_libc,
481 }));
482
483 test_modules_step.dependOn(tests.addModuleTests(b, .{463 test_modules_step.dependOn(tests.addModuleTests(b, .{
484 .test_filters = test_filters,464 .test_filters = test_filters,
485 .test_target_filters = test_target_filters,465 .test_target_filters = test_target_filters,
test/c_import.zig deleted-4
...@@ -1,4 +0,0 @@
1test {
2 _ = @import("c_import/c_char_signedness.zig");
3 _ = @import("c_import/macros.zig");
4}
test/c_import/c_char_signedness.zig deleted-13
...@@ -1,13 +0,0 @@
1const std = @import("std");
2const builtin = @import("builtin");
3const expectEqual = std.testing.expectEqual;
4const c = @cImport({
5 @cInclude("limits.h");
6});
7
8test "c_char signedness" {
9 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10
11 try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char));
12 try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char));
13}
test/c_import/macros.h deleted-70
...@@ -1,70 +0,0 @@
1// initializer list expression
2typedef struct Color {
3 unsigned char r;
4 unsigned char g;
5 unsigned char b;
6 unsigned char a;
7} Color;
8#define CLITERAL(type) (type)
9#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray
10
11#define MY_SIZEOF(x) ((int)sizeof(x))
12#define MY_SIZEOF2(x) ((int)sizeof x)
13
14struct Foo {
15 int a;
16};
17
18union U {
19 long l;
20 double d;
21};
22
23#define SIZE_OF_FOO sizeof(struct Foo)
24
25#define MAP_FAILED ((void *) -1)
26
27#define IGNORE_ME_1(x) ((void)(x))
28#define IGNORE_ME_2(x) ((const void)(x))
29#define IGNORE_ME_3(x) ((volatile void)(x))
30#define IGNORE_ME_4(x) ((const volatile void)(x))
31#define IGNORE_ME_5(x) ((volatile const void)(x))
32
33#define IGNORE_ME_6(x) (void)(x)
34#define IGNORE_ME_7(x) (const void)(x)
35#define IGNORE_ME_8(x) (volatile void)(x)
36#define IGNORE_ME_9(x) (const volatile void)(x)
37#define IGNORE_ME_10(x) (volatile const void)(x)
38
39#define UNION_CAST(X) (union U)(X)
40#define CAST_OR_CALL_WITH_PARENS(type_or_fn, val) ((type_or_fn)(val))
41
42#define NESTED_COMMA_OPERATOR (1, (2, 3))
43#define NESTED_COMMA_OPERATOR_LHS (1, 2), 3
44
45#include <stdint.h>
46#if !defined(__UINTPTR_MAX__)
47typedef _Bool uintptr_t;
48#endif
49
50#define CAST_TO_BOOL(X) (_Bool)(X)
51#define CAST_TO_UINTPTR(X) (uintptr_t)(X)
52
53#define LARGE_INT 18446744073709550592
54
55#define EMBEDDED_TAB "hello "
56
57#define DIVIDE_CONSTANT(version) (version / 1000)
58#define DIVIDE_ARGS(A, B) (A / B)
59
60#define REMAINDER_CONSTANT(version) (version % 10000)
61#define REMAINDER_ARGS(A, B) (A % B)
62
63#define LONG(x) x##L
64#define X LONG(10)
65
66#define BLANK_MACRO
67#define BLANK_CHILD_MACRO BLANK_MACRO BLANK_MACRO BLANK_MACRO
68#define MACRO_VALUE 0
69typedef long def_type;
70#define BLANK_MACRO_CAST (BLANK_CHILD_MACRO def_type BLANK_CHILD_MACRO)MACRO_VALUE
test/c_import/macros.zig deleted-239
...@@ -1,239 +0,0 @@
1const builtin = @import("builtin");
2const std = @import("std");
3const expect = std.testing.expect;
4const expectEqual = std.testing.expectEqual;
5const expectEqualStrings = std.testing.expectEqualStrings;
6
7const h = @cImport(@cInclude("macros.h"));
8const latin1 = @cImport(@cInclude("macros_not_utf8.h"));
9
10test "casting to void with a macro" {
11 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13
14 h.IGNORE_ME_1(42);
15 h.IGNORE_ME_2(42);
16 h.IGNORE_ME_3(42);
17 h.IGNORE_ME_4(42);
18 h.IGNORE_ME_5(42);
19 h.IGNORE_ME_6(42);
20 h.IGNORE_ME_7(42);
21 h.IGNORE_ME_8(42);
22 h.IGNORE_ME_9(42);
23 h.IGNORE_ME_10(42);
24}
25
26test "initializer list expression" {
27 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
30
31 try expectEqual(h.Color{
32 .r = 200,
33 .g = 200,
34 .b = 200,
35 .a = 255,
36 }, h.LIGHTGRAY);
37}
38
39test "sizeof in macros" {
40 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
42
43 try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
44 try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
45}
46
47test "reference to a struct type" {
48 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
50
51 try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
52}
53
54test "cast negative integer to pointer" {
55 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58
59 try expectEqual(@as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))))), h.MAP_FAILED);
60}
61
62test "casting to union with a macro" {
63 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
64 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
65 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
66
67 const l: c_long = 42;
68 const d: f64 = 2.0;
69
70 var casted = h.UNION_CAST(l);
71 try expect(l == casted.l);
72
73 casted = h.UNION_CAST(d);
74 try expect(d == casted.d);
75}
76
77test "casting or calling a value with a paren-surrounded macro" {
78 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
79 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
81
82 const l: c_long = 42;
83 const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
84 try expect(casted == @as(c_int, @intCast(l)));
85
86 const Helper = struct {
87 fn foo(n: c_int) !void {
88 try expect(n == 42);
89 }
90 };
91
92 try h.CAST_OR_CALL_WITH_PARENS(Helper.foo, 42);
93}
94
95test "nested comma operator" {
96 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
99
100 try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
101 try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
102}
103
104test "cast functions" {
105 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
106 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
107 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
108
109 const S = struct {
110 fn foo() void {}
111 };
112 try expectEqual(true, h.CAST_TO_BOOL(S.foo));
113 try expect(h.CAST_TO_UINTPTR(S.foo) != 0);
114}
115
116test "large integer macro" {
117 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
118 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
119 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
121
122 try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
123}
124
125test "string literal macro with embedded tab character" {
126 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129
130 try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
131}
132
133test "string and char literals that are not UTF-8 encoded. Issue #12784" {
134 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
135 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
136 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
137
138 try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
139 try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
140}
141
142test "Macro that uses division operator. Issue #13162" {
143 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
147 if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
148
149 try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
150 try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
151
152 try expectEqual(
153 @as(f64, 42.0),
154 h.DIVIDE_ARGS(
155 @as(f64, 42.0),
156 true,
157 ),
158 );
159
160 try expectEqual(
161 @as(c_int, 21),
162 h.DIVIDE_ARGS(
163 @as(i8, 42),
164 @as(i8, 2),
165 ),
166 );
167
168 try expectEqual(
169 @as(c_uint, 21),
170 h.DIVIDE_ARGS(
171 @as(u32, 42),
172 @as(u32, 2),
173 ),
174 );
175
176 try expectEqual(
177 @as(c_int, 21),
178 h.DIVIDE_ARGS(
179 @as(c_ushort, 42),
180 @as(c_ushort, 2),
181 ),
182 );
183}
184
185test "Macro that uses remainder operator. Issue #13346" {
186 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
187 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
188 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
189 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
190
191 try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
192 try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));
193
194 try expectEqual(
195 @as(c_int, 7),
196 h.REMAINDER_ARGS(
197 @as(i8, 17),
198 @as(i8, 10),
199 ),
200 );
201
202 try expectEqual(
203 @as(c_int, 5),
204 h.REMAINDER_ARGS(
205 @as(c_ushort, 25),
206 @as(c_ushort, 20),
207 ),
208 );
209
210 try expectEqual(
211 @as(c_int, 1),
212 h.REMAINDER_ARGS(
213 @as(c_int, 5),
214 @as(c_int, -2),
215 ),
216 );
217}
218
219test "@typeInfo on @cImport result" {
220 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
221
222 try expect(@typeInfo(h).@"struct".decls.len > 1);
223}
224
225test "Macro that uses Long type concatenation casting" {
226 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
227
228 try expect((@TypeOf(h.X)) == c_long);
229 try expectEqual(h.X, @as(c_long, 10));
230}
231
232test "Blank macros" {
233 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
234
235 try expectEqual(h.BLANK_MACRO, "");
236 try expectEqual(h.BLANK_CHILD_MACRO, "");
237 try expect(@TypeOf(h.BLANK_MACRO_CAST) == h.def_type);
238 try expectEqual(h.BLANK_MACRO_CAST, @as(c_long, 0));
239}
test/c_import/macros_not_utf8.h deleted-5
...@@ -1,5 +0,0 @@
1// Note: This file is encoded with ISO/IEC 8859-1 (latin1), not UTF-8.
2// Do not change the encoding
3
4#define UNPRINTABLE_STRING "���"
5#define UNPRINTABLE_CHAR '�'