mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-13 12:59:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove references to stage1 in behavior tests

Browse Source 
Good riddance.
This commit is contained in:
Andrew Kelley 2022-12-06 19:06:48 -07:00
parent b7b905d227
commit c8aba15c22
61 changed files with 150 additions and 647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
test/behavior.zig
View File

@ -94,6 +94,8 @@ test {
_ = @import("behavior/bugs/12551.zig");
_ = @import("behavior/bugs/12644.zig");
_ = @import("behavior/bugs/12680.zig");
_ = @import("behavior/bugs/12723.zig");
_ = @import("behavior/bugs/12776.zig");
_ = @import("behavior/bugs/12786.zig");
_ = @import("behavior/bugs/12794.zig");
_ = @import("behavior/bugs/12801-1.zig");
@ -112,8 +114,8 @@ test {
_ = @import("behavior/bugs/13069.zig");
_ = @import("behavior/bugs/13112.zig");
_ = @import("behavior/bugs/13128.zig");
_ = @import("behavior/bugs/13164.zig");
_ = @import("behavior/bugs/13159.zig");
_ = @import("behavior/bugs/13164.zig");
_ = @import("behavior/bugs/13171.zig");
_ = @import("behavior/bugs/13285.zig");
_ = @import("behavior/bugs/13435.zig");
@ -126,7 +128,9 @@ test {
_ = @import("behavior/cast_int.zig");
_ = @import("behavior/comptime_memory.zig");
_ = @import("behavior/const_slice_child.zig");
_ = @import("behavior/decltest.zig");
_ = @import("behavior/defer.zig");
_ = @import("behavior/empty_union.zig");
_ = @import("behavior/enum.zig");
_ = @import("behavior/error.zig");
_ = @import("behavior/eval.zig");
@ -142,6 +146,7 @@ test {
_ = @import("behavior/if.zig");
_ = @import("behavior/import.zig");
_ = @import("behavior/incomplete_struct_param_tld.zig");
_ = @import("behavior/inline_switch.zig");
_ = @import("behavior/int128.zig");
_ = @import("behavior/int_div.zig");
_ = @import("behavior/inttoptr.zig");
@ -154,6 +159,8 @@ test {
_ = @import("behavior/namespace_depends_on_compile_var.zig");
_ = @import("behavior/null.zig");
_ = @import("behavior/optional.zig");
_ = @import("behavior/packed-struct.zig");
_ = @import("behavior/packed_struct_explicit_backing_int.zig");
_ = @import("behavior/pointers.zig");
_ = @import("behavior/popcount.zig");
_ = @import("behavior/prefetch.zig");
@ -169,7 +176,6 @@ test {
_ = @import("behavior/slice_sentinel_comptime.zig");
_ = @import("behavior/src.zig");
_ = @import("behavior/struct.zig");
_ = @import("behavior/packed-struct.zig");
_ = @import("behavior/struct_contains_null_ptr_itself.zig");
_ = @import("behavior/struct_contains_slice_of_itself.zig");
_ = @import("behavior/switch.zig");
@ -180,6 +186,7 @@ test {
_ = @import("behavior/truncate.zig");
_ = @import("behavior/try.zig");
_ = @import("behavior/tuple.zig");
_ = @import("behavior/tuple_declarations.zig");
_ = @import("behavior/type.zig");
_ = @import("behavior/type_info.zig");
_ = @import("behavior/typename.zig");
@ -198,16 +205,6 @@ test {
_ = @import("behavior/wasm.zig");
}
if (builtin.zig_backend != .stage1) {
_ = @import("behavior/decltest.zig");
_ = @import("behavior/packed_struct_explicit_backing_int.zig");
_ = @import("behavior/empty_union.zig");
_ = @import("behavior/inline_switch.zig");
_ = @import("behavior/tuple_declarations.zig");
_ = @import("behavior/bugs/12723.zig");
_ = @import("behavior/bugs/12776.zig");
}
if (builtin.os.tag != .wasi) {
_ = @import("behavior/asm.zig");
}

16
test/behavior/align.zig
View File

@ -16,7 +16,6 @@ test "global variable alignment" {
}
test "slicing array of length 1 can not assume runtime index is always zero" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -61,10 +60,6 @@ test "alignment of struct with pointer has same alignment as usize" {
}
test "alignment and size of structs with 128-bit fields" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the wrong answer for a lot of targets
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -313,7 +308,6 @@ test "function alignment" {
}
test "implicitly decreasing fn alignment" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -337,7 +331,6 @@ fn alignedBig() align(16) i32 {
test "@alignCast functions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
// function alignment is a compile error on wasm32/wasm64
@ -380,8 +373,6 @@ test "function align expression depends on generic parameter" {
}
test "function callconv expression depends on generic parameter" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try expect(foobar(.C, 1) == 2);
@ -435,8 +426,6 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
}
test "alignment of function with c calling convention" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var runtime_nothing = &nothing;
const casted1 = @ptrCast(*const u8, runtime_nothing);
const casted2 = @ptrCast(*const fn () callconv(.C) void, casted1);
@ -495,7 +484,7 @@ test "struct field explicit alignment" {
}
test "align(@alignOf(T)) T does not force resolution of T" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
if (true) return error.SkipZigTest; // TODO
const S = struct {
const A = struct {
@ -519,7 +508,6 @@ test "align(@alignOf(T)) T does not force resolution of T" {
}
test "align(N) on functions" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -557,8 +545,6 @@ test "@alignCast null" {
}
test "alignment of slice element" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const a: []align(1024) const u8 = undefined;
try expect(@TypeOf(&a[0]) == *align(1024) const u8);
}

6
test/behavior/array.zig
View File

@ -102,12 +102,6 @@ test "array len field" {
}
test "array with sentinels" {
if (builtin.zig_backend == .stage1) {
// Stage1 test coverage disabled at runtime because of
// https://github.com/ziglang/zig/issues/4372
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {

132
test/behavior/async_fn.zig
View File

@ -8,7 +8,7 @@ const expectError = std.testing.expectError;
var global_x: i32 = 1;
test "simple coroutine suspend and resume" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
var frame = async simpleAsyncFn();
@ -31,7 +31,7 @@ fn simpleAsyncFn() void {
var global_y: i32 = 1;
test "pass parameter to coroutine" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
var p = async simpleAsyncFnWithArg(2);
@ -46,7 +46,7 @@ fn simpleAsyncFnWithArg(delta: i32) void {
}
test "suspend at end of function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -68,7 +68,7 @@ test "suspend at end of function" {
}
test "local variable in async function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -100,7 +100,7 @@ test "local variable in async function" {
}
test "calling an inferred async function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -127,7 +127,7 @@ test "calling an inferred async function" {
}
test "@frameSize" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
if (builtin.target.cpu.arch == .thumb or builtin.target.cpu.arch == .thumbeb)
@ -161,7 +161,7 @@ test "@frameSize" {
}
test "coroutine suspend, resume" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -205,7 +205,7 @@ test "coroutine suspend, resume" {
}
test "coroutine suspend with block" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const p = async testSuspendBlock();
@ -234,7 +234,7 @@ var await_a_promise: anyframe = undefined;
var await_final_result: i32 = 0;
test "coroutine await" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
await_seq('a');
@ -274,7 +274,7 @@ fn await_seq(c: u8) void {
var early_final_result: i32 = 0;
test "coroutine await early return" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
early_seq('a');
@ -305,7 +305,7 @@ fn early_seq(c: u8) void {
}
test "async function with dot syntax" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -321,7 +321,7 @@ test "async function with dot syntax" {
}
test "async fn pointer in a struct field" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
var data: i32 = 1;
@ -349,7 +349,7 @@ fn simpleAsyncFn2(y: *i32) callconv(.Async) void {
}
test "@asyncCall with return type" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const Foo = struct {
@ -376,7 +376,7 @@ test "@asyncCall with return type" {
}
test "async fn with inferred error set" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -409,7 +409,7 @@ test "async fn with inferred error set" {
}
test "error return trace across suspend points - early return" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const p = nonFailing();
@ -419,7 +419,7 @@ test "error return trace across suspend points - early return" {
}
test "error return trace across suspend points - async return" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const p = nonFailing();
@ -452,7 +452,7 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
}
test "break from suspend" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
var my_result: i32 = 1;
@ -470,7 +470,7 @@ fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void {
}
test "heap allocated async function frame" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -497,7 +497,7 @@ test "heap allocated async function frame" {
}
test "async function call return value" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -541,7 +541,7 @@ test "async function call return value" {
}
test "suspension points inside branching control flow" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -570,7 +570,7 @@ test "suspension points inside branching control flow" {
}
test "call async function which has struct return type" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -606,7 +606,7 @@ test "call async function which has struct return type" {
}
test "pass string literal to async function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -630,7 +630,7 @@ test "pass string literal to async function" {
}
test "await inside an errdefer" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -656,7 +656,7 @@ test "await inside an errdefer" {
}
test "try in an async function with error union and non-zero-bit payload" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -689,7 +689,7 @@ test "try in an async function with error union and non-zero-bit payload" {
}
test "returning a const error from async function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -723,7 +723,7 @@ test "returning a const error from async function" {
}
test "async/await typical usage" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
inline for ([_]bool{ false, true }) |b1| {
@ -821,7 +821,7 @@ fn testAsyncAwaitTypicalUsage(
}
test "alignment of local variables in async functions" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -836,7 +836,7 @@ test "alignment of local variables in async functions" {
}
test "no reason to resolve frame still works" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
_ = async simpleNothing();
@ -847,7 +847,7 @@ fn simpleNothing() void {
}
test "async call a generic function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -870,7 +870,7 @@ test "async call a generic function" {
}
test "return from suspend block" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -887,7 +887,7 @@ test "return from suspend block" {
}
test "struct parameter to async function is copied to the frame" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -934,7 +934,7 @@ test "struct parameter to async function is copied to the frame" {
}
test "cast fn to async fn when it is inferred to be async" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -965,7 +965,7 @@ test "cast fn to async fn when it is inferred to be async" {
}
test "cast fn to async fn when it is inferred to be async, awaited directly" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -995,7 +995,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
}
test "await does not force async if callee is blocking" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1008,7 +1008,7 @@ test "await does not force async if callee is blocking" {
}
test "recursive async function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
try expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
@ -1073,7 +1073,7 @@ fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
}
test "@asyncCall with comptime-known function, but not awaited directly" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1105,7 +1105,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
}
test "@asyncCall with actual frame instead of byte buffer" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1122,7 +1122,7 @@ test "@asyncCall with actual frame instead of byte buffer" {
}
test "@asyncCall using the result location inside the frame" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1152,7 +1152,7 @@ test "@asyncCall using the result location inside the frame" {
}
test "@TypeOf an async function call of generic fn with error union type" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1166,7 +1166,7 @@ test "@TypeOf an async function call of generic fn with error union type" {
}
test "using @TypeOf on a generic function call" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1194,7 +1194,7 @@ test "using @TypeOf on a generic function call" {
}
test "recursive call of await @asyncCall with struct return type" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1233,7 +1233,7 @@ test "recursive call of await @asyncCall with struct return type" {
}
test "nosuspend function call" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1252,7 +1252,7 @@ test "nosuspend function call" {
}
test "await used in expression and awaiting fn with no suspend but async calling convention" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1271,7 +1271,7 @@ test "await used in expression and awaiting fn with no suspend but async calling
}
test "await used in expression after a fn call" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1292,7 +1292,7 @@ test "await used in expression after a fn call" {
}
test "async fn call used in expression after a fn call" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1312,7 +1312,7 @@ test "async fn call used in expression after a fn call" {
}
test "suspend in for loop" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1341,7 +1341,7 @@ test "suspend in for loop" {
}
test "suspend in while loop" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1381,7 +1381,7 @@ test "suspend in while loop" {
}
test "correctly spill when returning the error union result of another async fn" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1407,7 +1407,7 @@ test "correctly spill when returning the error union result of another async fn"
}
test "spill target expr in a for loop" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1441,7 +1441,7 @@ test "spill target expr in a for loop" {
}
test "spill target expr in a for loop, with a var decl in the loop body" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1480,7 +1480,7 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
}
test "async call with @call" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1505,7 +1505,7 @@ test "async call with @call" {
}
test "async function passed 0-bit arg after non-0-bit arg" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1529,7 +1529,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {
}
test "async function passed align(16) arg after align(8) arg" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1554,7 +1554,7 @@ test "async function passed align(16) arg after align(8) arg" {
}
test "async function call resolves target fn frame, comptime func" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1579,7 +1579,7 @@ test "async function call resolves target fn frame, comptime func" {
}
test "async function call resolves target fn frame, runtime func" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1605,7 +1605,7 @@ test "async function call resolves target fn frame, runtime func" {
}
test "properly spill optional payload capture value" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1632,7 +1632,7 @@ test "properly spill optional payload capture value" {
}
test "handle defer interfering with return value spill" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1675,7 +1675,7 @@ test "handle defer interfering with return value spill" {
}
test "take address of temporary async frame" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1707,7 +1707,7 @@ test "take address of temporary async frame" {
}
test "nosuspend await" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1731,7 +1731,7 @@ test "nosuspend await" {
}
test "nosuspend on function calls" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S0 = struct {
@ -1750,7 +1750,7 @@ test "nosuspend on function calls" {
}
test "nosuspend on async function calls" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S0 = struct {
@ -1771,7 +1771,7 @@ test "nosuspend on async function calls" {
}
// test "resume nosuspend async function calls" {
// if (builtin.zig_backend != .stage1) return error.SkipZigTest; // if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
// if (true) return error.SkipZigTest; // if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
// const S0 = struct {
// b: i32 = 42,
// };
@ -1794,7 +1794,7 @@ test "nosuspend on async function calls" {
// }
test "nosuspend resume async function calls" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S0 = struct {
@ -1819,7 +1819,7 @@ test "nosuspend resume async function calls" {
}
test "avoid forcing frame alignment resolution implicit cast to *anyopaque" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const S = struct {
@ -1838,7 +1838,7 @@ test "avoid forcing frame alignment resolution implicit cast to *anyopaque" {
}
test "@asyncCall with pass-by-value arguments" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const F0: u64 = 0xbeefbeefbeefbeef;
@ -1874,7 +1874,7 @@ test "@asyncCall with pass-by-value arguments" {
}
test "@asyncCall with arguments having non-standard alignment" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
const F0: u64 = 0xbeefbeef;

8
test/behavior/atomics.zig
View File

@ -151,9 +151,7 @@ test "cmpxchg on a global variable" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if ((builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) and
builtin.cpu.arch == .aarch64)
{
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/10627
return error.SkipZigTest;
}
@ -220,8 +218,8 @@ test "atomicrmw with floats" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if ((builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm or
builtin.zig_backend == .stage2_c) and builtin.cpu.arch == .aarch64)
if ((builtin.zig_backend == .stage2_llvm or builtin.zig_backend == .stage2_c) and
builtin.cpu.arch == .aarch64)
{
// https://github.com/ziglang/zig/issues/10627
return error.SkipZigTest;

2
test/behavior/await_struct.zig
View File

@ -10,7 +10,7 @@ var await_a_promise: anyframe = undefined;
var await_final_result = Foo{ .x = 0 };
test "coroutine await struct" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
if (true) return error.SkipZigTest; // TODO
await_seq('a');
var p = async await_amain();

20
test/behavior/basic.zig
View File

@ -198,11 +198,6 @@ const OpaqueA = opaque {};
const OpaqueB = opaque {};
test "opaque types" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the type names wrong
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
try expect(*OpaqueA != *OpaqueB);
@ -290,7 +285,6 @@ fn fB() []const u8 {
test "call function pointer in struct" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try expect(mem.eql(u8, f3(true), "a"));
try expect(mem.eql(u8, f3(false), "b"));
@ -329,7 +323,6 @@ fn copy(src: *const u64, dst: *u64) void {
}
test "call result of if else expression" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 has different function pointers
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -573,22 +566,16 @@ fn emptyFn() void {}
const addr1 = @ptrCast(*const u8, &emptyFn);
test "comptime cast fn to ptr" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const addr2 = @ptrCast(*const u8, &emptyFn);
comptime try expect(addr1 == addr2);
}
test "equality compare fn ptrs" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var a = &emptyFn;
try expect(a == a);
}
test "self reference through fn ptr field" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
const A = struct {
f: *const fn (A) u8,
@ -783,10 +770,6 @@ test "auto created variables have correct alignment" {
}
test "extern variable with non-pointer opaque type" {
if (builtin.zig_backend == .stage1) {
// Regressed with LLVM 14
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -963,7 +946,7 @@ test "array type comes from generic function" {
}
test "generic function uses return type of other generic function" {
if (builtin.zig_backend != .stage1) {
if (true) {
// This test has been failing sporadically on the CI.
// It's not enough to verify that it works locally; we need to diagnose why
// it fails on the CI sometimes before turning it back on.
@ -1067,7 +1050,6 @@ test "inline call of function with a switch inside the return statement" {
}
test "namespace lookup ignores decl causing the lookup" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

8
test/behavior/bitcast.zig
View File

@ -155,10 +155,6 @@ test "bitcast generates a temporary value" {
}
test "@bitCast packed structs at runtime and comptime" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the wrong answer for a lot of targets
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -323,7 +319,6 @@ test "@bitCast packed struct of floats" {
}
test "comptime @bitCast packed struct to int and back" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -377,8 +372,7 @@ test "comptime bitcast with fields following f80" {
}
test "bitcast vector to integer and back" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/13220
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the comptime cast wrong
if (true) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/13220
const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
var x = @splat(16, true);

6
test/behavior/bitreverse.zig
View File

@ -5,8 +5,6 @@ const minInt = std.math.minInt;
test "@bitReverse large exotic integer" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
// Currently failing on stage1 for big-endian targets
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
}
@ -96,7 +94,6 @@ fn vector8() !void {
}
test "bitReverse vectors u8" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -115,7 +112,6 @@ fn vector16() !void {
}
test "bitReverse vectors u16" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -134,7 +130,6 @@ fn vector24() !void {
}
test "bitReverse vectors u24" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -153,7 +148,6 @@ fn vector0() !void {
}
test "bitReverse vectors u0" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

5
test/behavior/bugs/10147.zig
View File

@ -1,8 +1,7 @@
const builtin = @import("builtin");
const std = @import("std");
test "uses correct LLVM builtin" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
test "test calling @clz on both vector and scalar inputs" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -11,8 +10,6 @@ test "uses correct LLVM builtin" {
var x: u32 = 0x1;
var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
// The stage1 compiler used to call the same builtin function for both
// scalar and vector inputs, causing the LLVM module verification to fail.
var a = @clz(x);
var b = @clz(y);
try std.testing.expectEqual(@as(u6, 31), a);

2
test/behavior/bugs/11159.zig
View File

@ -8,8 +8,6 @@ test {
}
test {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
const S = struct {
comptime x: i32 = 0,
comptime y: u32 = 0,

5
test/behavior/bugs/11162.zig
View File

@ -2,9 +2,8 @@ const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
test "aggregate initializers should allow initializing comptime fields, verifying equality (stage2 only)" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
test "aggregate initializers should allow initializing comptime fields, verifying equality" {
if (true) return error.SkipZigTest; // TODO
var x: u32 = 15;
const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });

2
test/behavior/bugs/11227.zig
View File

@ -6,8 +6,6 @@ fn foo() u32 {
}
const bar = foo;
test "pointer to alias behaves same as pointer to function" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 has different function pointers
var a = &bar;
try std.testing.expect(foo() == a());
}

1
test/behavior/bugs/11816.zig
View File

@ -3,7 +3,6 @@ const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var x: u32 = 3;
const val: usize = while (true) switch (x) {

2
test/behavior/bugs/12486.zig
View File

@ -23,8 +23,6 @@ const ErrStruct = struct {
};
test {
if (@import("builtin").zig_backend == .stage1) return error.SkipZigTest;
_ = OptEnum{
.opt_enum = .{
.EnumVariant = 1,

3
test/behavior/bugs/12723.zig
View File

@ -1,8 +1,5 @@
const expect = @import("std").testing.expect;
// This test causes a compile error on stage1 regardless of whether
// the body of the test is comptime-gated or not. To workaround this,
// we gate the inclusion of the test file.
test "Non-exhaustive enum backed by comptime_int" {
const E = enum(comptime_int) { a, b, c, _ };
comptime var e: E = .a;

1
test/behavior/bugs/1277.zig
View File

@ -12,7 +12,6 @@ fn f() i32 {
}
test "don't emit an LLVM global for a const function when it's in an optional in a struct" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 has different function pointers
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

1
test/behavior/bugs/12801-1.zig
View File

@ -8,7 +8,6 @@ fn capacity_() u64 {
test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try std.testing.expect((@This(){}).capacity() == 64);
}

1
test/behavior/bugs/12801-2.zig
View File

@ -14,7 +14,6 @@ const Auto = struct {
}
};
test {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
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_x86_64) return error.SkipZigTest; // TODO

2
test/behavior/bugs/12885.zig
View File

@ -11,8 +11,6 @@ const Foo = @Type(.{
.ErrorSet = &info.args,
});
test "ErrorSet comptime_field_ptr" {
if (@import("builtin").zig_backend == .stage1) return error.SkipZigTest;
try expect(Foo == error{bar});
}

2
test/behavior/bugs/12891.zig
View File

@ -7,8 +7,6 @@ test "issue12891" {
try std.testing.expect(i < f);
}
test "nan" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
const f = comptime std.math.nan(f64);
var i: usize = 0;
try std.testing.expect(!(f < i));

2
test/behavior/bugs/12911.zig
View File

@ -5,7 +5,5 @@ const Thing = struct {
array: [1]Item,
};
test {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
_ = Thing{ .array = undefined };
}

3
test/behavior/bugs/1310.zig
View File

@ -22,7 +22,6 @@ fn agent_callback(_vm: [*]VM, options: [*]u8) callconv(.C) i32 {
return 11;
}
test "fixed" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
test {
try expect(agent_callback(undefined, undefined) == 11);
}

9
test/behavior/bugs/2006.zig
View File

@ -9,12 +9,5 @@ test "bug 2006" {
var a: S = undefined;
a = S{ .p = undefined };
try expect(@sizeOf(S) != 0);
if (@import("builtin").zig_backend != .stage1) {
// It is an accepted proposal to make `@sizeOf` for pointers independent
// of whether the element type is zero bits.
// This language change has not been implemented in stage1.
try expect(@sizeOf(*void) == @sizeOf(*i32));
} else {
try expect(@sizeOf(*void) == 0);
}
try expect(@sizeOf(*void) == @sizeOf(*i32));
}

1
test/behavior/bugs/3112.zig
View File

@ -13,7 +13,6 @@ fn prev(p: ?State) void {
test "zig test crash" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var global: State = undefined;
global.enter = prev;

3
test/behavior/bugs/3779.zig
View File

@ -6,7 +6,6 @@ const tag_name = @tagName(TestEnum.TestEnumValue);
const ptr_tag_name: [*:0]const u8 = tag_name;
test "@tagName() returns a string literal" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
@ -19,7 +18,6 @@ const error_name = @errorName(TestError.TestErrorCode);
const ptr_error_name: [*:0]const u8 = error_name;
test "@errorName() returns a string literal" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
@ -32,7 +30,6 @@ const type_name = @typeName(TestType);
const ptr_type_name: [*:0]const u8 = type_name;
test "@typeName() returns a string literal" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));

8
test/behavior/bugs/6850.zig
View File

@ -8,11 +8,5 @@ test "lazy sizeof comparison with zero" {
}
fn hasNoBits(comptime T: type) bool {
if (@import("builtin").zig_backend != .stage1) {
// It is an accepted proposal to make `@sizeOf` for pointers independent
// of whether the element type is zero bits.
// This language change has not been implemented in stage1.
return @sizeOf(T) == @sizeOf(*i32);
}
return @sizeOf(T) == 0;
return @sizeOf(T) == @sizeOf(*i32);
}

13
test/behavior/bugs/920.zig
View File

@ -2,23 +2,14 @@ const builtin = @import("builtin");
const std = @import("std");
const Random = std.rand.Random;
const zeroCaseFn = switch (builtin.zig_backend) {
.stage1 => fn (*Random, f64) f64,
else => *const fn (*Random, f64) f64,
};
const pdfFn = switch (builtin.zig_backend) {
.stage1 => fn (f64) f64,
else => *const fn (f64) f64,
};
const ZigTable = struct {
r: f64,
x: [257]f64,
f: [257]f64,
pdf: pdfFn,
pdf: *const fn (f64) f64,
is_symmetric: bool,
zero_case: zeroCaseFn,
zero_case: *const fn (*Random, f64) f64,
};
fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn (f64) f64, comptime f_inv: fn (f64) f64, comptime zero_case: fn (*Random, f64) f64) ZigTable {

5
test/behavior/byteswap.zig
View File

@ -3,7 +3,6 @@ const builtin = @import("builtin");
const expect = std.testing.expect;
test "@byteSwap integers" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -62,7 +61,6 @@ fn vector8() !void {
}
test "@byteSwap vectors u8" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -81,7 +79,6 @@ fn vector16() !void {
}
test "@byteSwap vectors u16" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -100,7 +97,6 @@ fn vector24() !void {
}
test "@byteSwap vectors u24" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@ -119,7 +115,6 @@ fn vector0() !void {
}
test "@byteSwap vectors u0" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

14
test/behavior/call.zig
View File

@ -45,10 +45,7 @@ test "basic invocations" {
}
{
// call of non comptime-known function
var alias_foo = switch (builtin.zig_backend) {
.stage1 => foo,
else => &foo,
};
var alias_foo = &foo;
try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234);
try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234);
try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234);
@ -71,7 +68,9 @@ test "tuple parameters" {
try expect(@call(.{}, add, .{ 12, b }) == 46);
try expect(@call(.{}, add, .{ a, b }) == 46);
try expect(@call(.{}, add, .{ 12, 34 }) == 46);
if (builtin.zig_backend == .stage1) comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46); // TODO
if (false) {
comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46); // TODO
}
try expect(comptime @call(.{}, add, .{ 12, 34 }) == 46);
{
const separate_args0 = .{ a, b };
@ -246,8 +245,6 @@ test "function call with 40 arguments" {
}
test "arguments to comptime parameters generated in comptime blocks" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
fn fortyTwo() i32 {
return 42;
@ -261,7 +258,6 @@ test "arguments to comptime parameters generated in comptime blocks" {
}
test "forced tail call" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
@ -294,7 +290,6 @@ test "forced tail call" {
}
test "inline call preserves tail call" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
@ -329,7 +324,6 @@ test "inline call preserves tail call" {
}
test "inline call doesn't re-evaluate non generic struct" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

15
test/behavior/cast.zig
View File

@ -113,8 +113,6 @@ test "@intToFloat" {
}
test "@intToFloat(f80)" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -699,11 +697,6 @@ test "peer type resolution: error set supersets" {
}
test "peer type resolution: disjoint error sets" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the order of the error names wrong after merging the sets.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -733,11 +726,6 @@ test "peer type resolution: disjoint error sets" {
}
test "peer type resolution: error union and error set" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the order of the error names wrong after merging the sets.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1080,7 +1068,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
}
test "compile time int to ptr of function" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
try foobar(FUNCTION_CONSTANT);
@ -1421,8 +1408,6 @@ test "floatToInt to zero-bit int" {
}
test "peer type resolution of function pointer and function body" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const T = fn () u32;
const a: T = undefined;
const b: *const T = undefined;

43
test/behavior/comptime_memory.zig
View File

@ -4,8 +4,6 @@ const testing = @import("std").testing;
const ptr_size = @sizeOf(usize);
test "type pun signed and unsigned as single pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
comptime {
var x: u32 = 0;
const y = @ptrCast(*i32, &x);
@ -15,8 +13,6 @@ test "type pun signed and unsigned as single pointer" {
}
test "type pun signed and unsigned as many pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
comptime {
var x: u32 = 0;
const y = @ptrCast([*]i32, &x);
@ -26,8 +22,6 @@ test "type pun signed and unsigned as many pointer" {
}
test "type pun signed and unsigned as array pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
comptime {
var x: u32 = 0;
const y = @ptrCast(*[1]i32, &x);
@ -37,8 +31,7 @@ test "type pun signed and unsigned as array pointer" {
}
test "type pun signed and unsigned as offset many pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -53,8 +46,7 @@ test "type pun signed and unsigned as offset many pointer" {
}
test "type pun signed and unsigned as array pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -69,8 +61,6 @@ test "type pun signed and unsigned as array pointer" {
}
test "type pun value and struct" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
comptime {
const StructOfU32 = extern struct { x: u32 };
var inst: StructOfU32 = .{ .x = 0 };
@ -85,7 +75,6 @@ fn bigToNativeEndian(comptime T: type, v: T) T {
return if (endian == .Big) v else @byteSwap(v);
}
test "type pun endianness" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime {
@ -179,8 +168,7 @@ fn doTypePunBitsTest(as_bits: *Bits) !void {
}
test "type pun bits" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -197,8 +185,7 @@ const imports = struct {
// Make sure lazy values work on their own, before getting into more complex tests
test "basic pointer preservation" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -211,8 +198,7 @@ test "basic pointer preservation" {
}
test "byte copy preserves linker value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -235,8 +221,7 @@ test "byte copy preserves linker value" {
}
test "unordered byte copy preserves linker value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -260,8 +245,7 @@ test "unordered byte copy preserves linker value" {
}
test "shuffle chunks of linker value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -279,8 +263,7 @@ test "shuffle chunks of linker value" {
}
test "dance on linker values" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -311,8 +294,7 @@ test "dance on linker values" {
}
test "offset array ptr by element size" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -339,8 +321,7 @@ test "offset array ptr by element size" {
}
test "offset instance by field size" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -365,8 +346,7 @@ test "offset instance by field size" {
}
test "offset field ptr by enclosing array element size" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend != .stage1) {
if (true) {
// TODO https://github.com/ziglang/zig/issues/9646
return error.SkipZigTest;
}
@ -395,7 +375,6 @@ test "offset field ptr by enclosing array element size" {
}
test "accessing reinterpreted memory of parent object" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
const S = extern struct {
a: f32,

15
test/behavior/error.zig
View File

@ -151,7 +151,6 @@ test "fn returning empty error set can be passed as fn returning any error" {
}
test "fn returning empty error set can be passed as fn returning any error - pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -465,11 +464,6 @@ test "nested catch" {
}
test "function pointer with return type that is error union with payload which is pointer of parent struct" {
if (builtin.zig_backend == .stage1) {
// stage1 has wrong function pointer semantics
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -582,9 +576,6 @@ pub fn testBuiltinErrorName(err: anyerror) [:0]const u8 {
}
test "error set equality" {
// This tests using stage2 logic (#11022)
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const a = error{One};
const b = error{One};
@ -752,7 +743,6 @@ const NoReturn = struct {
};
test "error union of noreturn used with if" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
@ -767,7 +757,6 @@ test "error union of noreturn used with if" {
}
test "error union of noreturn used with try" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
@ -779,7 +768,6 @@ test "error union of noreturn used with try" {
}
test "error union of noreturn used with catch" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
@ -807,7 +795,6 @@ test "alignment of wrapping an error union payload" {
}
test "compare error union and error set" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var a: anyerror = error.Foo;
@ -857,8 +844,6 @@ test "error from comptime string" {
}
test "field access of anyerror results in smaller error set" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const E1 = @TypeOf(error.Foo);
try expect(@TypeOf(E1.Foo) == E1);
const E2 = error{ A, B, C };

30
test/behavior/eval.zig
View File

@ -606,15 +606,16 @@ fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void {
// This one is still up for debate in the language specification.
// Application code should not rely on this behavior until it is solidified.
// Currently, stage1 has special case code to make this pass for string literals
// but it does not work if the values are constructed with comptime code, or if
// Historically, stage1 had special case code to make this pass for string literals
// but it did not work if the values are constructed with comptime code, or if
// arrays of non-u8 elements are used instead.
// The official language specification might not make this guarantee. However, if
// it does make this guarantee, it will make it consistently for all types, not
// only string literals. This is why stage2 currently has a string table for
// string literals, to match stage1 and pass this test, however the end-game once
// the lang spec issue is settled would be to use a global InternPool for comptime
// memoized objects, making this behavior consistent across all types.
// only string literals. This is why Zig currently has a string table for
// string literals, to match legacy stage1 behavior and pass this test, however
// the end-game once the lang spec issue is settled would be to use a global
// InternPool for comptime memoized objects, making this behavior consistent
// across all types.
test "string literal used as comptime slice is memoized" {
const a = "link";
const b = "link";
@ -742,7 +743,6 @@ fn scalar(x: u32) u32 {
}
test "array concatenation peer resolves element types - value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -758,7 +758,6 @@ test "array concatenation peer resolves element types - value" {
}
test "array concatenation peer resolves element types - pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -774,7 +773,6 @@ test "array concatenation peer resolves element types - pointer" {
}
test "array concatenation sets the sentinel - value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -794,7 +792,6 @@ test "array concatenation sets the sentinel - value" {
}
test "array concatenation sets the sentinel - pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var a = [2]u3{ 1, 7 };
@ -811,7 +808,6 @@ test "array concatenation sets the sentinel - pointer" {
}
test "array multiplication sets the sentinel - value" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -829,7 +825,6 @@ test "array multiplication sets the sentinel - value" {
}
test "array multiplication sets the sentinel - pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -894,8 +889,6 @@ test "const type-annotated local initialized with function call has correct type
}
test "comptime pointer load through elem_ptr" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 fails this test
const S = struct {
x: usize,
};
@ -1038,7 +1031,6 @@ test "comptime break operand passing through runtime condition converted to runt
}
test "comptime break operand passing through runtime switch converted to runtime break" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
const S = struct {
@ -1294,8 +1286,6 @@ test "repeated value is correctly expanded" {
}
test "value in if block is comptime-known" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const first = blk: {
const s = if (false) "a" else "b";
break :blk "foo" ++ s;
@ -1330,8 +1320,6 @@ test "lazy value is resolved as slice operand" {
}
test "break from inline loop depends on runtime condition" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
fn foo(a: u8) bool {
return a == 4;
@ -1405,7 +1393,7 @@ test "length of global array is determinable at comptime" {
test "continue nested inline for loop" {
// TODO: https://github.com/ziglang/zig/issues/13175
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
if (true) return error.SkipZigTest;
var a: u8 = 0;
loop: inline for ([_]u8{ 1, 2 }) |x| {
@ -1422,7 +1410,7 @@ test "continue nested inline for loop" {
test "continue nested inline for loop in named block expr" {
// TODO: https://github.com/ziglang/zig/issues/13175
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
if (true) return error.SkipZigTest;
var a: u8 = 0;
loop: inline for ([_]u8{ 1, 2 }) |x| {

16
test/behavior/floatop.zig
View File

@ -114,7 +114,7 @@ fn testSqrt() !void {
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), 1.0488088481701516, epsilon));
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.0)), 1.4142135623730950, epsilon));
if (builtin.zig_backend == .stage1) {
if (false) {
if (has_f80_rt) {
// TODO https://github.com/ziglang/zig/issues/10875
if (builtin.os.tag != .freebsd) {
@ -181,10 +181,6 @@ test "more @sqrt f16 tests" {
}
test "@sin" {
if (builtin.zig_backend == .stage1) {
// stage1 emits an incorrect compile error for `@as(ty, std.math.pi / 2)`
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -205,7 +201,6 @@ fn testSin() !void {
}
test "@sin with vectors" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -226,10 +221,6 @@ fn testSinWithVectors() !void {
}
test "@cos" {
if (builtin.zig_backend == .stage1) {
// stage1 emits an incorrect compile error for `@as(ty, std.math.pi / 2)`
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -250,7 +241,6 @@ fn testCos() !void {
}
test "@cos with vectors" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -781,7 +771,6 @@ test "f128 at compile time is lossy" {
}
test "comptime fixed-width float zero divided by zero produces NaN" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -793,7 +782,6 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
}
test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -810,8 +798,6 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
}
test "comptime_float zero divided by zero produces zero" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try expect((0.0 / 0.0) == 0.0);
}

10
test/behavior/fn.zig
View File

@ -68,8 +68,6 @@ fn outer(y: u32) *const fn (u32) u32 {
}
test "return inner function which references comptime variable of outer function" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var func = outer(10);
try expect(func(3) == 7);
}
@ -97,7 +95,6 @@ test "discard the result of a function that returns a struct" {
}
test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -145,7 +142,6 @@ fn fnWithUnreachable() noreturn {
}
test "extern struct with stdcallcc fn pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -293,11 +289,6 @@ fn acceptsString(foo: []u8) void {
}
test "function pointers" {
if (builtin.zig_backend == .stage1) {
// stage1 has wrong semantics for function pointers
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -415,7 +406,6 @@ test "import passed byref to function in return type" {
}
test "implicit cast function to function ptr" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
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_wasm) return error.SkipZigTest; // TODO

6
test/behavior/generics.zig
View File

@ -21,8 +21,8 @@ test "simple generic fn" {
try expect(max(i32, 3, -1) == 3);
try expect(max(u8, 1, 100) == 100);
if (builtin.zig_backend == .stage1) {
// TODO: stage2 is incorrectly emitting the following:
if (false) {
// TODO: zig is incorrectly emitting the following:
// error: cast of value 1.23e-01 to type 'f32' loses information
try expect(max(f32, 0.123, 0.456) == 0.456);
}
@ -342,8 +342,6 @@ test "generic instantiation of tagged union with only one field" {
}
test "nested generic function" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
try callback(data);

4
test/behavior/int128.zig
View File

@ -29,8 +29,8 @@ test "undefined 128 bit int" {
@setRuntimeSafety(true);
// TODO implement @setRuntimeSafety in stage2
if (builtin.zig_backend != .stage1 and builtin.mode != .Debug and builtin.mode != .ReleaseSafe) {
// TODO implement @setRuntimeSafety
if (builtin.mode != .Debug and builtin.mode != .ReleaseSafe) {
return error.SkipZigTest;
}

2
test/behavior/inttoptr.zig
View File

@ -1,8 +1,6 @@
const builtin = @import("builtin");
test "casting integer address to function pointer" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
addressToFunction();
comptime addressToFunction();
}

17
test/behavior/math.zig
View File

@ -94,7 +94,6 @@ fn testOneClz(comptime T: type, x: T) u32 {
}
test "@clz vectors" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -156,7 +155,6 @@ fn testOneCtz(comptime T: type, x: T) u32 {
}
test "@ctz vectors" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -971,8 +969,6 @@ test "overflow arithmetic with u0 values" {
}
test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try expect(5 / 3 == 1);
try expect(-5 / -3 == 1);
try expect(-6 / 3 == -2);
@ -1009,14 +1005,8 @@ test "quad hex float literal parsing accurate" {
try expect(@bitCast(u128, f) == 0x40042eab345678439abcdefea5678234);
}
{
// TODO: modify stage1/parse_f128.c to use round-to-even
if (builtin.zig_backend == .stage1) {
var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
try expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134674); // round-down
} else {
var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
try expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134675); // round-to-even
}
var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
try expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134675); // round-to-even
}
{
var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50;
@ -1270,7 +1260,8 @@ test "@sqrt" {
try testSqrt(f16, 13.0);
comptime try testSqrt(f16, 13.0);
if (builtin.zig_backend == .stage1) {
// TODO: make this pass
if (false) {
const x = 14.0;
const y = x * x;
const z = @sqrt(y);

2
test/behavior/member_func.zig
View File

@ -27,7 +27,6 @@ const HasFuncs = struct {
};
test "standard field calls" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -71,7 +70,6 @@ test "standard field calls" {
}
test "@field field calls" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

6
test/behavior/muladd.zig
View File

@ -47,7 +47,6 @@ test "@mulAdd f80" {
if (builtin.zig_backend == .stage2_x86_64) 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 == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
comptime try testMulAdd80();
@ -91,7 +90,6 @@ fn vector16() !void {
}
test "vector f16" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -115,7 +113,6 @@ fn vector32() !void {
}
test "vector f32" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -139,7 +136,6 @@ fn vector64() !void {
}
test "vector f64" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -162,7 +158,6 @@ fn vector80() !void {
}
test "vector f80" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -187,7 +182,6 @@ fn vector128() !void {
}
test "vector f128" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

5
test/behavior/optional.zig
View File

@ -377,8 +377,6 @@ const NoReturn = struct {
};
test "optional of noreturn used with if" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
NoReturn.a = 64;
if (NoReturn.loop()) |_| {
@compileError("bad");
@ -388,8 +386,6 @@ test "optional of noreturn used with if" {
}
test "optional of noreturn used with orelse" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
NoReturn.a = 64;
const val = NoReturn.testOrelse();
try expect(val == 123);
@ -419,7 +415,6 @@ test "alignment of wrapping an optional payload" {
}
test "Optional slice size is optimized" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

38
test/behavior/packed-struct.zig
View File

@ -5,38 +5,7 @@ const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const native_endian = builtin.cpu.arch.endian();
test "correct size of packed structs" {
// Stage2 has different packed struct semantics.
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
const T1 = packed struct { one: u8, three: [3]u8 };
try expectEqual(4, @sizeOf(T1));
try expectEqual(4 * 8, @bitSizeOf(T1));
const T2 = packed struct { three: [3]u8, one: u8 };
try expectEqual(4, @sizeOf(T2));
try expectEqual(4 * 8, @bitSizeOf(T2));
const T3 = packed struct { _1: u1, x: u7, _: u24 };
try expectEqual(4, @sizeOf(T3));
try expectEqual(4 * 8, @bitSizeOf(T3));
const T4 = packed struct { _1: u1, x: u7, _2: u8, _3: u16 };
try expectEqual(4, @sizeOf(T4));
try expectEqual(4 * 8, @bitSizeOf(T4));
const T5 = packed struct { _1: u1, x: u7, _2: u16, _3: u8 };
try expectEqual(4, @sizeOf(T5));
try expectEqual(4 * 8, @bitSizeOf(T5));
}
test "flags in packed structs" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const Flags1 = packed struct {
// first 8 bits
b0_0: u1,
@ -121,8 +90,6 @@ test "flags in packed structs" {
}
test "consistent size of packed structs" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const TxData1 = packed struct { data: u8, _23: u23, full: bool = false };
const TxData2 = packed struct { data: u9, _22: u22, full: bool = false };
@ -149,7 +116,6 @@ test "consistent size of packed structs" {
}
test "correct sizeOf and offsets in packed structs" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -218,7 +184,6 @@ test "correct sizeOf and offsets in packed structs" {
}
test "nested packed structs" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -285,7 +250,6 @@ test "regular in irregular packed struct" {
}
test "byte-aligned field pointer offsets" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -387,7 +351,6 @@ test "byte-aligned field pointer offsets" {
}
test "load pointer from packed struct" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@ -571,7 +534,6 @@ test "runtime init of unnamed packed struct type" {
}
test "packed struct passed to callconv(.C) function" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

1
test/behavior/packed_struct_explicit_backing_int.zig
View File

@ -5,7 +5,6 @@ const expectEqual = std.testing.expectEqual;
const native_endian = builtin.cpu.arch.endian();
test "packed struct explicit backing integer" {
assert(builtin.zig_backend != .stage1);
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

3
test/behavior/pointers.zig
View File

@ -135,9 +135,6 @@ test "peer type resolution with C pointers" {
}
test "peer type resolution with C pointer and const pointer" {
// stage1 incorrectly resolves to [*]u8
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var ptr_c: [*c]u8 = undefined;
const ptr_const: u8 = undefined;
try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8);

1
test/behavior/popcount.zig
View File

@ -65,7 +65,6 @@ fn testPopCountIntegers() !void {
}
test "@popCount vectors" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

7
test/behavior/ptrcast.zig
View File

@ -20,7 +20,6 @@ fn testReinterpretBytesAsInteger() !void {
}
test "reinterpret an array over multiple elements, with no well-defined layout" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -77,8 +76,6 @@ fn testReinterpretBytesAsExternStruct() !void {
}
test "reinterpret bytes of an extern struct (with under-aligned fields) into another" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try testReinterpretExternStructAsExternStruct();
comptime try testReinterpretExternStructAsExternStruct();
}
@ -101,8 +98,6 @@ fn testReinterpretExternStructAsExternStruct() !void {
}
test "reinterpret bytes of an extern struct into another" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try testReinterpretOverAlignedExternStructAsExternStruct();
comptime try testReinterpretOverAlignedExternStructAsExternStruct();
}
@ -127,7 +122,6 @@ fn testReinterpretOverAlignedExternStructAsExternStruct() !void {
}
test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
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_x86_64) return error.SkipZigTest; // TODO
@ -151,7 +145,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
}
test "lower reinterpreted comptime field ptr" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
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_x86_64) return error.SkipZigTest; // TODO

4
test/behavior/saturating_arithmetic.zig
View File

@ -149,10 +149,6 @@ test "saturating multiplication" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1 and builtin.cpu.arch == .wasm32) {
// https://github.com/ziglang/zig/issues/9660
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
// https://github.com/ziglang/zig/issues/9660
return error.SkipZigTest;

1
test/behavior/select.zig
View File

@ -32,7 +32,6 @@ fn selectVectors() !void {
}
test "@select arrays" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

2
test/behavior/shuffle.zig
View File

@ -71,7 +71,7 @@ test "@shuffle bool 2" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) {
if (builtin.zig_backend == .stage2_llvm) {
// https://github.com/ziglang/zig/issues/3246
return error.SkipZigTest;
}

53
test/behavior/sizeof_and_typeof.zig
View File

@ -101,52 +101,6 @@ test "@offsetOf" {
try expect(@ptrToInt(&a.i) - @ptrToInt(&a) == @offsetOf(A, "i"));
}
test "@offsetOf packed struct, array length not power of 2 or multiple of native pointer width in bytes" {
// Stage2 has different packed struct semantics.
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
const p3a_len = 3;
const P3 = packed struct {
a: [p3a_len]u8,
b: usize,
};
try std.testing.expect(0 == @offsetOf(P3, "a"));
try std.testing.expect(p3a_len == @offsetOf(P3, "b"));
const p5a_len = 5;
const P5 = packed struct {
a: [p5a_len]u8,
b: usize,
};
try std.testing.expect(0 == @offsetOf(P5, "a"));
try std.testing.expect(p5a_len == @offsetOf(P5, "b"));
const p6a_len = 6;
const P6 = packed struct {
a: [p6a_len]u8,
b: usize,
};
try std.testing.expect(0 == @offsetOf(P6, "a"));
try std.testing.expect(p6a_len == @offsetOf(P6, "b"));
const p7a_len = 7;
const P7 = packed struct {
a: [p7a_len]u8,
b: usize,
};
try std.testing.expect(0 == @offsetOf(P7, "a"));
try std.testing.expect(p7a_len == @offsetOf(P7, "b"));
const p9a_len = 9;
const P9 = packed struct {
a: [p9a_len]u8,
b: usize,
};
try std.testing.expect(0 == @offsetOf(P9, "a"));
try std.testing.expect(p9a_len == @offsetOf(P9, "b"));
// 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25 etc. are further cases
}
test "@bitOffsetOf" {
// Packed structs have fixed memory layout
try expect(@bitOffsetOf(P, "a") == 0);
@ -211,8 +165,6 @@ test "branching logic inside @TypeOf" {
}
test "@bitSizeOf" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try expect(@bitSizeOf(u2) == 2);
try expect(@bitSizeOf(u8) == @sizeOf(u8) * 8);
try expect(@bitSizeOf(struct {
@ -224,11 +176,6 @@ test "@bitSizeOf" {
}
test "@sizeOf comparison against zero" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the wrong answer for size of pointers to zero bit types
return error.SkipZigTest;
}
const S0 = struct {
f: *@This(),
};

32
test/behavior/slice.zig
View File

@ -182,7 +182,6 @@ test "slicing zero length array" {
const x = @intToPtr([*]i32, 0x1000)[0..0x500];
const y = x[0x100..];
test "compile time slice of pointer to hard coded address" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
try expect(@ptrToInt(x) == 0x1000);
@ -444,10 +443,7 @@ test "slice syntax resulting in pointer-to-array" {
var array: [2]u8 = [2]u8{ 1, 2 };
var slice: ?[]u8 = &array;
comptime try expect(@TypeOf(&array, slice) == ?[]u8);
if (builtin.zig_backend != .stage1) {
// stage1 is not passing this case
comptime try expect(@TypeOf(slice, &array) == ?[]u8);
}
comptime try expect(@TypeOf(slice, &array) == ?[]u8);
comptime try expect(@TypeOf(slice.?[0..2]) == *[2]u8);
}
@ -479,13 +475,7 @@ test "slice pointer-to-array null terminated" {
var slice: [:0]u8 = &array;
try expect(@TypeOf(slice[1..3]) == *[2]u8);
try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8);
if (builtin.zig_backend == .stage1) {
try expect(@TypeOf(slice[1..]) == [:0]u8);
} else {
// stage2 gives a more accurate, correct answer
try expect(@TypeOf(slice[1..]) == *[4:0]u8);
}
try expect(@TypeOf(slice[1..]) == *[4:0]u8);
}
var array = [5:0]u8{ 1, 2, 3, 4, 5 };
@ -509,12 +499,7 @@ test "slice pointer-to-array zero length" {
var array = [0:0]u8{};
var src_slice: [:0]u8 = &array;
var slice = src_slice[0..0];
if (builtin.zig_backend == .stage1) {
try expect(@TypeOf(slice) == *[0]u8);
} else {
// stage2 gives a more accurate, correct answer
try expect(@TypeOf(slice) == *[0:0]u8);
}
try expect(@TypeOf(slice) == *[0:0]u8);
}
}
@ -573,16 +558,11 @@ test "array concat of slices gives ptr to array" {
var b: []const u8 = "asdf";
const c = a ++ b;
try expect(std.mem.eql(u8, c, "aoeuasdf"));
if (builtin.zig_backend != .stage1) {
// spec change: array concat now returns pointer-to-array for slices
try expect(@TypeOf(c) == *const [8]u8);
}
try expect(@TypeOf(c) == *const [8]u8);
}
}
test "array mult of slice gives ptr to array" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest; // Stage 1 does not support multiplying slices
comptime {
var a: []const u8 = "aoeu";
const c = a ** 2;
@ -626,8 +606,6 @@ test "slice sentinel access at comptime" {
}
test "slicing array with sentinel as end index" {
// Doesn't work in stage1
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
@ -645,8 +623,6 @@ test "slicing array with sentinel as end index" {
}
test "slicing slice with sentinel as end index" {
// Doesn't work in stage1
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {

42
test/behavior/struct.zig
View File

@ -419,11 +419,8 @@ test "packed struct 24bits" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
comptime {
// stage1 gets the wrong answer for sizeof
if (builtin.zig_backend != .stage1) {
std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24));
std.debug.assert(@sizeOf(Foo96Bits) == @sizeOf(u96));
}
std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24));
std.debug.assert(@sizeOf(Foo96Bits) == @sizeOf(u96));
}
var value = Foo96Bits{
@ -497,10 +494,6 @@ const Bitfields = packed struct {
};
test "packed struct fields are ordered from LSB to MSB" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the wrong answer for a lot of targets
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -640,7 +633,6 @@ test "default struct initialization fields" {
}
test "packed array 24bits" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@ -698,25 +690,6 @@ const FooArray24Bits = packed struct {
c: u16,
};
test "aligned array of packed struct" {
// Stage2 has different packed struct semantics.
if (builtin.zig_backend != .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
comptime {
try expect(@sizeOf(FooStructAligned) == 2);
try expect(@sizeOf(FooArrayOfAligned) == 2 * 2);
}
var bytes = [_]u8{0xbb} ** @sizeOf(FooArrayOfAligned);
const ptr = &std.mem.bytesAsSlice(FooArrayOfAligned, bytes[0..])[0];
try expect(ptr.a[0].a == 0xbb);
try expect(ptr.a[0].b == 0xbb);
try expect(ptr.a[1].a == 0xbb);
try expect(ptr.a[1].b == 0xbb);
}
const FooStructAligned = packed struct {
a: u8,
b: u8,
@ -1150,7 +1123,6 @@ test "for loop over pointers to struct, getting field from struct pointer" {
}
test "anon init through error unions and optionals" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -1178,7 +1150,6 @@ test "anon init through error unions and optionals" {
}
test "anon init through optional" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -1199,7 +1170,6 @@ test "anon init through optional" {
}
test "anon init through error union" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -1220,7 +1190,6 @@ test "anon init through error union" {
}
test "typed init through error unions and optionals" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -1283,10 +1252,6 @@ test "loading a struct pointer perfoms a copy" {
}
test "packed struct aggregate init" {
if (builtin.zig_backend == .stage1) {
// stage1 fails this test on mips
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -1328,8 +1293,6 @@ test "packed struct field access via pointer" {
}
test "store to comptime field" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
{
const S = struct {
comptime a: [2]u32 = [2]u32{ 1, 2 },
@ -1364,7 +1327,6 @@ test "struct field init value is size of the struct" {
}
test "under-aligned struct field" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

5
test/behavior/truncate.zig
View File

@ -60,11 +60,6 @@ test "truncate on comptime integer" {
}
test "truncate on vectors" {
if (builtin.zig_backend == .stage1) {
// stage1 fails the comptime test
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

13
test/behavior/type.zig
View File

@ -229,7 +229,7 @@ test "Type.Vector" {
}
test "Type.AnyFrame" {
if (builtin.zig_backend != .stage1) {
if (true) {
// https://github.com/ziglang/zig/issues/6025
return error.SkipZigTest;
}
@ -246,8 +246,6 @@ fn add(a: i32, b: i32) i32 {
}
test "Type.ErrorSet" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try testing.expect(@Type(.{ .ErrorSet = null }) == anyerror);
// error sets don't compare equal so just check if they compile
@ -369,12 +367,7 @@ test "Type.Enum" {
try testing.expectEqual(@as(u8, 5), @enumToInt(Foo.b));
const Bar = @Type(.{
.Enum = .{
// stage2 only has auto layouts
.layout = if (builtin.zig_backend == .stage1)
.Extern
else
.Auto,
.layout = .Auto,
.tag_type = u32,
.fields = &.{
.{ .name = "a", .value = 1 },
@ -501,8 +494,6 @@ test "Type.Union from regular enum" {
}
test "Type.Fn" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (true) {
// https://github.com/ziglang/zig/issues/12360
return error.SkipZigTest;

41
test/behavior/type_info.zig
View File

@ -201,9 +201,6 @@ test "type info: error set single value" {
}
test "type info: error set merged" {
// #11022 forces ordering of error sets in stage2
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -305,8 +302,6 @@ const TestStruct = struct {
};
test "type info: packed struct info" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try testPackedStruct();
comptime try testPackedStruct();
}
@ -376,25 +371,21 @@ extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.C) usize;
extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
test "type info: generic function types" {
if (builtin.zig_backend != .stage1) {
// stage1 marks all args/return types as null if the function
// is generic at all. stage2 is more specific.
const G1 = @typeInfo(@TypeOf(generic1));
try expect(G1.Fn.args.len == 1);
try expect(G1.Fn.args[0].is_generic == true);
try expect(G1.Fn.args[0].arg_type == null);
try expect(G1.Fn.return_type == void);
const G1 = @typeInfo(@TypeOf(generic1));
try expect(G1.Fn.args.len == 1);
try expect(G1.Fn.args[0].is_generic == true);
try expect(G1.Fn.args[0].arg_type == null);
try expect(G1.Fn.return_type == void);
const G2 = @typeInfo(@TypeOf(generic2));
try expect(G2.Fn.args.len == 3);
try expect(G2.Fn.args[0].is_generic == false);
try expect(G2.Fn.args[0].arg_type == type);
try expect(G2.Fn.args[1].is_generic == true);
try expect(G2.Fn.args[1].arg_type == null);
try expect(G2.Fn.args[2].is_generic == false);
try expect(G2.Fn.args[2].arg_type == u8);
try expect(G2.Fn.return_type == void);
}
const G2 = @typeInfo(@TypeOf(generic2));
try expect(G2.Fn.args.len == 3);
try expect(G2.Fn.args[0].is_generic == false);
try expect(G2.Fn.args[0].arg_type == type);
try expect(G2.Fn.args[1].is_generic == true);
try expect(G2.Fn.args[1].arg_type == null);
try expect(G2.Fn.args[2].is_generic == false);
try expect(G2.Fn.args[2].arg_type == u8);
try expect(G2.Fn.return_type == void);
const G3 = @typeInfo(@TypeOf(generic3));
try expect(G3.Fn.args.len == 1);
@ -442,7 +433,7 @@ fn testVector() !void {
}
test "type info: anyframe and anyframe->T" {
if (builtin.zig_backend != .stage1) {
if (true) {
// https://github.com/ziglang/zig/issues/6025
return error.SkipZigTest;
}
@ -501,7 +492,7 @@ fn add(a: i32, b: i32) i32 {
}
test "type info for async frames" {
if (builtin.zig_backend != .stage1) {
if (true) {
// https://github.com/ziglang/zig/issues/6025
return error.SkipZigTest;
}

29
test/behavior/typename.zig
View File

@ -12,12 +12,6 @@ const expectStringStartsWith = std.testing.expectStringStartsWith;
// failures.
test "anon fn param" {
if (builtin.zig_backend == .stage1) {
// stage1 uses line/column for the names but we're moving away from that for
// incremental compilation purposes.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -43,12 +37,6 @@ test "anon fn param" {
}
test "anon field init" {
if (builtin.zig_backend == .stage1) {
// stage1 uses line/column for the names but we're moving away from that for
// incremental compilation purposes.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -84,11 +72,6 @@ test "basic" {
}
test "top level decl" {
if (builtin.zig_backend == .stage1) {
// stage1 fails to return fully qualified namespaces.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -208,11 +191,6 @@ pub fn expectEqualStringsIgnoreDigits(expected: []const u8, actual: []const u8)
}
test "local variable" {
if (builtin.zig_backend == .stage1) {
// stage1 fails to return fully qualified namespaces.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -231,7 +209,6 @@ test "local variable" {
}
test "comptime parameters not converted to anytype in function type" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@ -241,12 +218,6 @@ test "comptime parameters not converted to anytype in function type" {
}
test "anon name strategy used in sub expression" {
if (builtin.zig_backend == .stage1) {
// stage1 uses line/column for the names but we're moving away from that for
// incremental compilation purposes.
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

4
test/behavior/undefined.zig
View File

@ -76,10 +76,6 @@ test "assign undefined to struct with method" {
}
test "type name of undefined" {
if (builtin.zig_backend == .stage1) {
// stage1 gets the type name wrong
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const x = undefined;

5
test/behavior/union.zig
View File

@ -221,7 +221,6 @@ test "packed union generates correctly aligned type" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const U = packed union {
f1: *const fn () error{TestUnexpectedResult}!void,
@ -1002,7 +1001,6 @@ test "cast from pointer to anonymous struct to pointer to union" {
}
test "switching on non exhaustive union" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1197,7 +1195,6 @@ test "union tag is set when initiated as a temporary value at runtime" {
}
test "extern union most-aligned field is smaller" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1246,7 +1243,6 @@ test "return an extern union from C calling convention" {
}
test "noreturn field in union" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -1298,7 +1294,6 @@ test "noreturn field in union" {
}
test "union and enum field order doesn't match" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

41
test/behavior/vector.zig
View File

@ -6,12 +6,6 @@ const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test "implicit cast vector to array - bool" {
if (builtin.zig_backend == .stage1) {
// Regressed in LLVM 14:
// https://github.com/llvm/llvm-project/issues/55522
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -180,9 +174,7 @@ test "tuple to vector" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if ((builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) and
builtin.cpu.arch == .aarch64)
{
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// Regressed with LLVM 14:
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
@ -197,9 +189,7 @@ test "tuple to vector" {
}
try std.testing.expectEqual(v, Vec3{ 1, 1, 1 });
if (builtin.zig_backend != .stage1) {
try std.testing.expectEqual(v, .{ 1, 1, 1 });
}
try std.testing.expectEqual(v, .{ 1, 1, 1 });
}
};
try S.doTheTest();
@ -406,12 +396,6 @@ test "initialize vector which is a struct field" {
}
test "vector comparison operators" {
if (builtin.zig_backend == .stage1) {
// Regressed in LLVM 14:
// https://github.com/llvm/llvm-project/issues/55522
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@ -801,7 +785,6 @@ test "vector reduce operation" {
}
test "vector @reduce comptime" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -937,10 +920,6 @@ test "saturating shift-left" {
}
test "multiplication-assignment operator with an array operand" {
if (builtin.zig_backend == .stage1) {
// stage1 emits a compile error
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -961,10 +940,6 @@ test "multiplication-assignment operator with an array operand" {
}
test "@addWithOverflow" {
if (builtin.zig_backend == .stage1) {
// stage1 doesn't support vector args
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1011,10 +986,6 @@ test "@addWithOverflow" {
}
test "@subWithOverflow" {
if (builtin.zig_backend == .stage1) {
// stage1 doesn't support vector args
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1045,10 +1016,6 @@ test "@subWithOverflow" {
}
test "@mulWithOverflow" {
if (builtin.zig_backend == .stage1) {
// stage1 doesn't support vector args
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@ -1069,10 +1036,6 @@ test "@mulWithOverflow" {
}
test "@shlWithOverflow" {
if (builtin.zig_backend == .stage1) {
// stage1 doesn't support vector args
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO