std: disable failing tests, add zig2 build test-std to CI

ci/zinc/linux_test.sh

@@ -59,6 +59,7 @@ stage2/bin/zig build -Dtarget=arm-linux-musleabihf # test building self-hosted f
 # * https://github.com/ziglang/zig/issues/11367 (and corresponding workaround in compiler source)
 # * https://github.com/ziglang/zig/pull/11492#issuecomment-1112871321
 stage2/bin/zig build test-behavior -fqemu -fwasmtime
+stage2/bin/zig test lib/std/std.zig --zig-lib-dir lib
 
 $ZIG build test-behavior         -fqemu -fwasmtime -Domit-stage2
 $ZIG build test-compiler-rt      -fqemu -fwasmtime

lib/std/bit_set.zig

@@ -1330,6 +1330,7 @@ fn testStaticBitSet(comptime Set: type) !void {
 }
 
 test "IntegerBitSet" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     try testStaticBitSet(IntegerBitSet(0));
     try testStaticBitSet(IntegerBitSet(1));
     try testStaticBitSet(IntegerBitSet(2));
@@ -1341,6 +1342,7 @@ test "IntegerBitSet" {
 }
 
 test "ArrayBitSet" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     if (@import("builtin").cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/9879
         return error.SkipZigTest;
@@ -1355,6 +1357,7 @@ test "ArrayBitSet" {
 }
 
 test "DynamicBitSetUnmanaged" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const allocator = std.testing.allocator;
     var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
@@ -1395,6 +1398,7 @@ test "DynamicBitSetUnmanaged" {
 }
 
 test "DynamicBitSet" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const allocator = std.testing.allocator;
     var a = try DynamicBitSet.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());

lib/std/crypto/argon2.zig

@@ -897,6 +897,7 @@ test "kdf" {
 }
 
 test "phc format hasher" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const allocator = std.testing.allocator;
     const password = "testpass";
 
@@ -912,6 +913,7 @@ test "phc format hasher" {
 }
 
 test "password hash and password verify" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const allocator = std.testing.allocator;
     const password = "testpass";
 

lib/std/crypto/bcrypt.zig

@@ -802,6 +802,7 @@ test "bcrypt crypt format" {
 }
 
 test "bcrypt phc format" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const hash_options = HashOptions{
         .params = .{ .rounds_log = 5 },
         .encoding = .phc,

lib/std/crypto/phc_encoding.zig

@@ -260,6 +260,7 @@ fn kvSplit(str: []const u8) !struct { key: []const u8, value: []const u8 } {
 }
 
 test "phc format - encoding/decoding" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const Input = struct {
         str: []const u8,
         HashResult: type,

lib/std/crypto/scrypt.zig

@@ -683,6 +683,7 @@ test "unix-scrypt" {
 }
 
 test "crypt format" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const str = "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D";
     const params = try crypt_format.deserialize(crypt_format.HashResult(32), str);
     var buf: [str.len]u8 = undefined;

lib/std/fmt.zig

@@ -2225,6 +2225,7 @@ test "float.scientific.precision" {
 }
 
 test "float.special" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     try expectFmt("f64: nan", "f64: {}", .{math.nan_f64});
     // negative nan is not defined by IEE 754,
     // and ARM thus normalizes it to positive nan
@@ -2236,6 +2237,7 @@ test "float.special" {
 }
 
 test "float.hexadecimal.special" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     try expectFmt("f64: nan", "f64: {x}", .{math.nan_f64});
     // negative nan is not defined by IEE 754,
     // and ARM thus normalizes it to positive nan

lib/std/json.zig

@@ -1355,6 +1355,7 @@ pub const Value = union(enum) {
 };
 
 test "Value.jsonStringify" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     {
         var buffer: [10]u8 = undefined;
         var fbs = std.io.fixedBufferStream(&buffer);

lib/std/math/copysign.zig

@@ -13,6 +13,7 @@ pub fn copysign(magnitude: anytype, sign: @TypeOf(magnitude)) @TypeOf(magnitude)
 }
 
 test "math.copysign" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
         try expect(copysign(@as(T, 1.0), @as(T, 1.0)) == 1.0);
         try expect(copysign(@as(T, 2.0), @as(T, -2.0)) == -2.0);

lib/std/math/signbit.zig

@@ -10,6 +10,7 @@ pub fn signbit(x: anytype) bool {
 }
 
 test "math.signbit" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
         try expect(!signbit(@as(T, 0.0)));
         try expect(!signbit(@as(T, 1.0)));

lib/std/mem.zig

@@ -2080,6 +2080,7 @@ fn testReadIntImpl() !void {
 }
 
 test "writeIntSlice" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     try testWriteIntImpl();
     comptime try testWriteIntImpl();
 }

lib/std/os/linux/io_uring.zig

@@ -2154,6 +2154,7 @@ test "timeout (after a number of completions)" {
 }
 
 test "timeout_remove" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
     var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
@@ -2950,6 +2951,7 @@ test "provide_buffers: read" {
 }
 
 test "remove_buffers" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {

lib/std/priority_queue.zig

@@ -286,6 +286,7 @@ const PQlt = PriorityQueue(u32, void, lessThan);
 const PQgt = PriorityQueue(u32, void, greaterThan);
 
 test "std.PriorityQueue: add and remove min heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -304,6 +305,7 @@ test "std.PriorityQueue: add and remove min heap" {
 }
 
 test "std.PriorityQueue: add and remove same min heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -353,6 +355,7 @@ test "std.PriorityQueue: peek" {
 }
 
 test "std.PriorityQueue: sift up with odd indices" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -367,6 +370,7 @@ test "std.PriorityQueue: sift up with odd indices" {
 }
 
 test "std.PriorityQueue: addSlice" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -412,6 +416,7 @@ test "std.PriorityQueue: fromOwnedSlice" {
 }
 
 test "std.PriorityQueue: add and remove max heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQgt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -430,6 +435,7 @@ test "std.PriorityQueue: add and remove max heap" {
 }
 
 test "std.PriorityQueue: add and remove same max heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQgt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -470,6 +476,7 @@ test "std.PriorityQueue: iterator" {
 }
 
 test "std.PriorityQueue: remove at index" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -505,6 +512,7 @@ test "std.PriorityQueue: iterator while empty" {
 }
 
 test "std.PriorityQueue: shrinkAndFree" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -528,6 +536,7 @@ test "std.PriorityQueue: shrinkAndFree" {
 }
 
 test "std.PriorityQueue: update min heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -543,6 +552,7 @@ test "std.PriorityQueue: update min heap" {
 }
 
 test "std.PriorityQueue: update same min heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -559,6 +569,7 @@ test "std.PriorityQueue: update same min heap" {
 }
 
 test "std.PriorityQueue: update max heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQgt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -574,6 +585,7 @@ test "std.PriorityQueue: update max heap" {
 }
 
 test "std.PriorityQueue: update same max heap" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQgt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -590,6 +602,7 @@ test "std.PriorityQueue: update same max heap" {
 }
 
 test "std.PriorityQueue: siftUp in remove" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     var queue = PQlt.init(testing.allocator, {});
     defer queue.deinit();
 
@@ -610,6 +623,7 @@ fn contextLessThan(context: []const u32, a: usize, b: usize) Order {
 const CPQlt = PriorityQueue(usize, []const u32, contextLessThan);
 
 test "std.PriorityQueue: add and remove min heap with contextful comparator" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
 
     var queue = CPQlt.init(testing.allocator, context[0..]);

lib/std/tz.zig

@@ -214,6 +214,7 @@ pub const Tz = struct {
 };
 
 test "slim" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const data = @embedFile("tz/asia_tokyo.tzif");
     var in_stream = std.io.fixedBufferStream(data);
 
@@ -227,6 +228,7 @@ test "slim" {
 }
 
 test "fat" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     const data = @embedFile("tz/antarctica_davis.tzif");
     var in_stream = std.io.fixedBufferStream(data);
 
@@ -239,6 +241,7 @@ test "fat" {
 }
 
 test "legacy" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
     // Taken from Slackware 8.0, from 2001
     const data = @embedFile("tz/europe_vatican.tzif");
     var in_stream = std.io.fixedBufferStream(data);