@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Nurul Huda (Apon).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/c/fcntl.zig

@@ -12,11 +12,12 @@ comptime {
         symbol(&fallocateLinux, "fallocate");
         symbol(&posix_fadviseLinux, "posix_fadvise");
         symbol(&posix_fallocateLinux, "posix_fallocate");
+        symbol(&teeLinux, "tee");
     }
 }
 
 fn fallocateLinux(fd: c_int, mode: c_int, offset: off_t, len: off_t) callconv(.c) c_int {
-    return errno(linux.fallocate(fd, mode, offset, len));
+    return errno(linux.fallocate(fd, @bitCast(mode), offset, len));
 }
 
 fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callconv(.c) c_int {
@@ -26,3 +27,7 @@ fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callc
 fn posix_fallocateLinux(fd: c_int, offset: off_t, len: off_t) callconv(.c) c_int {
     return errno(linux.fallocate(fd, 0, offset, len));
 }
+
+fn teeLinux(src: c_int, dest: c_int, len: usize, flags: c_uint) callconv(.c) isize {
+    return errno(linux.tee(src, dest, len, flags));
+}

package/c/inttypes.zig

@@ -24,13 +24,3 @@ fn imaxdiv(a: intmax_t, b: intmax_t) callconv(.c) imaxdiv_t {
         .rem = @rem(a, b),
     };
 }
-
-test imaxabs {
-    const val: intmax_t = -10;
-    try std.testing.expectEqual(10, imaxabs(val));
-}
-
-test imaxdiv {
-    const expected: imaxdiv_t = .{ .quot = 9, .rem = 0 };
-    try std.testing.expectEqual(expected, imaxdiv(9, 1));
-}

package/c/math.zig

@@ -2,10 +2,6 @@ const builtin = @import("builtin");
 
 const std = @import("std");
 const math = std.math;
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectApproxEqAbs = std.testing.expectApproxEqAbs;
-const expectApproxEqRel = std.testing.expectApproxEqRel;
 
 const symbol = @import("../c.zig").symbol;
 
@@ -35,33 +31,49 @@ comptime {
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        symbol(&coshf, "coshf");
+        symbol(&frexpf, "frexpf");
+        symbol(&frexpl, "frexpl");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
-        symbol(&modff, "modff");
         symbol(&modfl, "modfl");
-        symbol(&nan, "nan");
-        symbol(&nanf, "nanf");
+    }
+
+    if ((builtin.target.isMinGW() and @sizeOf(f64) != @sizeOf(c_longdouble)) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&atanl, "atanl");
+        symbol(&copysignl, "copysignl");
+        symbol(&fdiml, "fdiml");
         symbol(&nanl, "nanl");
+    }
+
+    if ((builtin.target.isMinGW() and builtin.cpu.arch == .x86) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&acosf, "acosf");
+        symbol(&atanf, "atanf");
+        symbol(&coshf, "coshf");
+        symbol(&modff, "modff");
         symbol(&tanhf, "tanhf");
     }
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&acos, "acos");
-        symbol(&acosf, "acosf");
         symbol(&acoshf, "acoshf");
         symbol(&asin, "asin");
         symbol(&atan, "atan");
-        symbol(&atanf, "atanf");
-        symbol(&atanl, "atanl");
         symbol(&cbrt, "cbrt");
         symbol(&cbrtf, "cbrtf");
         symbol(&cosh, "cosh");
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
+        symbol(&fdim, "fdim");
+        symbol(&fdimf, "fdimf");
+        symbol(&finite, "finite");
+        symbol(&finitef, "finitef");
+        symbol(&frexp, "frexp");
         symbol(&hypot, "hypot");
+        symbol(&lrint, "lrint");
+        symbol(&lrintf, "lrintf");
         symbol(&modf, "modf");
-        symbol(&pow, "pow");
+        symbol(&nan, "nan");
+        symbol(&nanf, "nanf");
         symbol(&pow10, "pow10");
         symbol(&pow10f, "pow10f");
         symbol(&tanh, "tanh");
@@ -71,9 +83,8 @@ comptime {
         symbol(&copysign, "copysign");
         symbol(&copysignf, "copysignf");
         symbol(&rint, "rint");
+        symbol(&rintf, "rintf");
     }
-
-    symbol(&copysignl, "copysignl");
 }
 
 fn acos(x: f64) callconv(.c) f64 {
@@ -101,13 +112,9 @@ fn atanf(x: f32) callconv(.c) f32 {
 }
 
 fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
-    return switch (@typeInfo(@TypeOf(x)).float.bits) {
-        16 => math.atan(@as(f16, @floatCast(x))),
-        32 => math.atan(@as(f32, @floatCast(x))),
-        64 => math.atan(@as(f64, @floatCast(x))),
-        80 => math.atan(@as(f80, @floatCast(x))),
-        128 => math.atan(@as(f128, @floatCast(x))),
-        else => unreachable,
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.atan(x),
+        else => math.atan(x),
     };
 }
 
@@ -128,7 +135,10 @@ fn copysignf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.copysign(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.copysign(x, y),
+        else => math.copysign(x, y),
+    };
 }
 
 fn cosh(x: f64) callconv(.c) f64 {
@@ -147,6 +157,75 @@ fn exp10f(x: f32) callconv(.c) f32 {
     return math.pow(f32, 10.0, x);
 }
 
+fn fdimGeneric(comptime T: type, x: T, y: T) T {
+    if (math.isNan(x))
+        return x;
+
+    if (math.isNan(y))
+        return y;
+
+    if (x > y)
+        return x - y;
+    return 0;
+}
+
+fn fdim(x: f64, y: f64) callconv(.c) f64 {
+    return fdimGeneric(f64, x, y);
+}
+
+fn fdimf(x: f32, y: f32) callconv(.c) f32 {
+    return fdimGeneric(f32, x, y);
+}
+
+fn fdiml(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.fdim(x, y),
+        else => fdimGeneric(c_longdouble, x, y),
+    };
+}
+
+fn finite(x: f64) callconv(.c) c_int {
+    return @intFromBool(math.isFinite(x));
+}
+
+fn finitef(x: f32) callconv(.c) c_int {
+    return @intFromBool(math.isFinite(x));
+}
+
+fn frexpGeneric(comptime T: type, x: T, e: *c_int) T {
+    // libc expects `*e` to be unspecified in this case; an unspecified C value
+    // should be a valid value of the relevant type, yet Zig's std
+    // implementation sets it to `undefined` -- which can even be nonsense
+    // according to the type (int). Therefore, we're setting it to a valid
+    // int value in Zig -- a zero.
+    //
+    // This mirrors the handling of infinities, where libc also expects
+    // unspecified for the value of `*e` and Zig std sets it to a zero.
+    if (math.isNan(x)) {
+        e.* = 0;
+        return x;
+    }
+
+    const r = math.frexp(x);
+    e.* = r.exponent;
+    return r.significand;
+}
+
+fn frexp(x: f64, e: *c_int) callconv(.c) f64 {
+    return frexpGeneric(f64, x, e);
+}
+
+fn frexpf(x: f32, e: *c_int) callconv(.c) f32 {
+    return frexpGeneric(f32, x, e);
+}
+
+fn frexpl(x: c_longdouble, e: *c_int) callconv(.c) c_longdouble {
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.frexp(x, e),
+        else => frexpGeneric(c_longdouble, x, e),
+    };
+}
+
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }
@@ -156,19 +235,30 @@ fn hypotf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.hypot(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.hypot(x, y),
+        else => math.hypot(x, y),
+    };
 }
 
 fn isnan(x: f64) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanf(x: f32) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanl(x: c_longdouble) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
+}
+
+fn lrint(x: f64) callconv(.c) c_long {
+    return @intFromFloat(rint(x));
+}
+
+fn lrintf(x: f32) callconv(.c) c_long {
+    return @intFromFloat(rintf(x));
 }
 
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
@@ -204,60 +294,10 @@ fn modff(x: f32, iptr: *f32) callconv(.c) f32 {
 }
 
 fn modfl(x: c_longdouble, iptr: *c_longdouble) callconv(.c) c_longdouble {
-    return modfGeneric(c_longdouble, x, iptr);
-}
-
-fn testModf(comptime T: type) !void {
-    // Choose the appropriate `modf` impl to test based on type
-    const f = switch (T) {
-        f32 => modff,
-        f64 => modf,
-        c_longdouble => modfl,
-        else => @compileError("modf not implemented for " ++ @typeName(T)),
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.modf(x, iptr),
+        else => modfGeneric(c_longdouble, x, iptr),
     };
-
-    var int: T = undefined;
-    const iptr = ∫
-    const eps_val: comptime_float = @max(1e-6, math.floatEps(T));
-
-    const normal_frac = f(@as(T, 1234.567), iptr);
-    // Account for precision error
-    const expected = 1234.567 - @as(T, 1234);
-    try expectApproxEqAbs(expected, normal_frac, eps_val);
-    try expectApproxEqRel(@as(T, 1234.0), iptr.*, eps_val);
-
-    // When `x` is a NaN, NaN is returned and `*iptr` is set to NaN
-    const nan_frac = f(math.nan(T), iptr);
-    try expect(math.isNan(nan_frac));
-    try expect(math.isNan(iptr.*));
-
-    // When `x` is positive infinity, +0 is returned and `*iptr` is set to
-    // positive infinity
-    const pos_zero_frac = f(math.inf(T), iptr);
-    try expect(math.isPositiveZero(pos_zero_frac));
-    try expect(math.isPositiveInf(iptr.*));
-
-    // When `x` is negative infinity, -0 is returned and `*iptr` is set to
-    // negative infinity
-    const neg_zero_frac = f(-math.inf(T), iptr);
-    try expect(math.isNegativeZero(neg_zero_frac));
-    try expect(math.isNegativeInf(iptr.*));
-
-    // Return -0 when `x` is a negative integer
-    const nz_frac = f(@as(T, -1000.0), iptr);
-    try expect(math.isNegativeZero(nz_frac));
-    try expectEqual(@as(T, -1000.0), iptr.*);
-
-    // Return +0 when `x` is a positive integer
-    const pz_frac = f(@as(T, 1000.0), iptr);
-    try expect(math.isPositiveZero(pz_frac));
-    try expectEqual(@as(T, 1000.0), iptr.*);
-}
-
-test "modf" {
-    try testModf(f32);
-    try testModf(f64);
-    try testModf(c_longdouble);
 }
 
 fn nan(_: [*:0]const c_char) callconv(.c) f64 {
@@ -272,10 +312,6 @@ fn nanl(_: [*:0]const c_char) callconv(.c) c_longdouble {
     return math.nan(c_longdouble);
 }
 
-fn pow(x: f64, y: f64) callconv(.c) f64 {
-    return math.pow(f64, x, y);
-}
-
 fn pow10(x: f64) callconv(.c) f64 {
     return exp10(x);
 }
@@ -285,7 +321,7 @@ fn pow10f(x: f32) callconv(.c) f32 {
 }
 
 fn rint(x: f64) callconv(.c) f64 {
-    const toint: f64 = 1.0 / @as(f64, math.floatEps(f64));
+    const toint: f64 = 1.0 / math.floatEps(f64);
     const a: u64 = @bitCast(x);
     const e = a >> 52 & 0x7ff;
     const s = a >> 63;
@@ -305,39 +341,27 @@ fn rint(x: f64) callconv(.c) f64 {
     return y;
 }
 
-test "rint" {
-    // Positive numbers round correctly
-    try expectEqual(@as(f64, 42.0), rint(42.2));
-    try expectEqual(@as(f64, 42.0), rint(41.8));
-
-    // Negative numbers round correctly
-    try expectEqual(@as(f64, -6.0), rint(-5.9));
-    try expectEqual(@as(f64, -6.0), rint(-6.1));
-
-    // No rounding needed test
-    try expectEqual(@as(f64, 5.0), rint(5.0));
-    try expectEqual(@as(f64, -10.0), rint(-10.0));
-    try expectEqual(@as(f64, 0.0), rint(0.0));
+fn rintf(x: f32) callconv(.c) f32 {
+    const toint: f32 = 1.0 / math.floatEps(f32);
+    const a: u32 = @bitCast(x);
+    const e = a >> 23 & 0xff;
+    const s = a >> 31;
+    var y: f32 = undefined;
 
-    // Very large numbers return unchanged
-    const large: f64 = 9007199254740992.0; // 2^53
-    try expectEqual(large, rint(large));
-    try expectEqual(-large, rint(-large));
-
-    // Small positive numbers round to zero
-    const pos_result = rint(0.3);
-    try expectEqual(@as(f64, 0.0), pos_result);
-    try expect(@as(u64, @bitCast(pos_result)) == 0);
+    if (e >= 0x7f + 23) {
+        return x;
+    }
 
-    // Small negative numbers round to negative zero
-    const neg_result = rint(-0.3);
-    try expectEqual(@as(f64, 0.0), neg_result);
-    const bits: u64 = @bitCast(neg_result);
-    try expect((bits >> 63) == 1);
+    if (s == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
 
-    // Exact half rounds to nearest even (banker's rounding)
-    try expectEqual(@as(f64, 2.0), rint(2.5));
-    try expectEqual(@as(f64, 4.0), rint(3.5));
+    if (y == 0) {
+        return if (s == 1) -0.0 else 0;
+    }
+    return y;
 }
 
 fn tanh(x: f64) callconv(.c) f64 {

package/c/pthread.zig

@@ -0,0 +1,57 @@
+const builtin = @import("builtin");
+
+const std = @import("std");
+const c = std.c;
+
+const symbol = @import("../c.zig").symbol;
+
+comptime {
+    if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC() or builtin.target.isMinGW()) {
+        symbol(&pthread_spin_init, "pthread_spin_init");
+        symbol(&pthread_spin_destroy, "pthread_spin_destroy");
+        symbol(&pthread_spin_trylock, "pthread_spin_trylock");
+        symbol(&pthread_spin_lock, "pthread_spin_lock");
+        symbol(&pthread_spin_unlock, "pthread_spin_unlock");
+    }
+}
+
+const SpinLock = enum(c.pthread_spinlock_t) {
+    unlocked = if (builtin.target.isMinGW()) -1 else 0,
+    locked = if (builtin.target.isMinGW()) 0 else @intFromEnum(c.E.BUSY),
+};
+
+fn pthread_spin_init(s: *c.pthread_spinlock_t, pshared: c_int) callconv(.c) c_int {
+    _ = pshared;
+    const spin: *SpinLock = @ptrCast(s);
+    spin.* = .unlocked;
+    return 0;
+}
+
+fn pthread_spin_destroy(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    spin.* = undefined;
+    return 0;
+}
+
+fn pthread_spin_trylock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    return if (@cmpxchgStrong(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| @intFromEnum(c.E.BUSY) else 0;
+}
+
+fn pthread_spin_lock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    if (builtin.single_threaded and @atomicLoad(SpinLock, spin, .monotonic) == .locked) return @intFromEnum(c.E.DEADLK);
+
+    while (@cmpxchgWeak(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| {
+        std.atomic.spinLoopHint();
+    }
+    return 0;
+}
+
+fn pthread_spin_unlock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+
+    // "The results are undefined if the lock is not held by the calling thread"
+    std.debug.assert(@atomicRmw(SpinLock, spin, .Xchg, .unlocked, .release) == .locked);
+    return 0;
+}

package/c/search.zig

@@ -9,6 +9,7 @@ comptime {
     }
 }
 
+/// Not defined in `std.c` because C headers don't either.
 const Node = extern struct {
     next: ?*Node,
     prev: ?*Node,
@@ -38,30 +39,3 @@ fn remque(element: *anyopaque) callconv(.c) void {
     if (e.next) |next| next.prev = e.prev;
     if (e.prev) |prev| prev.next = e.next;
 }
-
-test "insque and remque" {
-    var first = Node{ .next = null, .prev = null };
-    var second = Node{ .next = null, .prev = null };
-    var third = Node{ .next = null, .prev = null };
-
-    insque(&first, null);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-    try std.testing.expectEqual(@as(?*Node, null), first.prev);
-
-    insque(&second, &first);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    insque(&third, &first);
-    try std.testing.expectEqual(@as(?*Node, &third), first.next);
-    try std.testing.expectEqual(@as(?*Node, &second), third.next);
-    try std.testing.expectEqual(@as(?*Node, &first), third.prev);
-    try std.testing.expectEqual(@as(?*Node, &third), second.prev);
-
-    remque(&third);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    remque(&second);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-}

package/c/stdlib/drand48.zig

@@ -90,60 +90,3 @@ fn srand48(seedval: c_long) callconv(.c) void {
     const xi = (@as(u32, @truncate(@as(c_ulong, @bitCast(seedval)))) << 16) | 0x330E;
     lcg = .init(xi, default_multiplier, default_addend);
 }
-
-test erand48 {
-    var xsubi: [3]c_ushort = .{ 37174, 64810, 11603 };
-
-    try std.testing.expectApproxEqAbs(0.8965, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 22537, 47966, 58735 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.3375, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37344, 32911, 22119 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.6475, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 23659, 29872, 42445 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5005, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31642, 7875, 32802 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5065, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 64669, 14399, 33170 }, &xsubi);
-}
-
-test jrand48 {
-    var xsubi: [3]c_ushort = .{ 25175, 11052, 45015 };
-
-    try std.testing.expectEqual(1699503220, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 2326, 23668, 25932 }, &xsubi);
-
-    try std.testing.expectEqual(-992276007, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 41577, 4569, 50395 }, &xsubi);
-
-    try std.testing.expectEqual(-19535776, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31936, 59488, 65237 }, &xsubi);
-
-    try std.testing.expectEqual(79438377, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 40395, 8745, 1212 }, &xsubi);
-
-    try std.testing.expectEqual(-1258917728, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37242, 28832, 46326 }, &xsubi);
-}
-
-test nrand48 {
-    var xsubi: [3]c_ushort = .{ 546, 33817, 23389 };
-
-    try std.testing.expectEqual(914920692, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 29829, 10728, 27921 }, &xsubi);
-
-    try std.testing.expectEqual(754104482, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 6828, 28997, 23013 }, &xsubi);
-
-    try std.testing.expectEqual(609453945, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58183, 3826, 18599 }, &xsubi);
-
-    try std.testing.expectEqual(1878644360, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 36678, 44304, 57331 }, &xsubi);
-
-    try std.testing.expectEqual(2114923686, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58585, 22861, 64542 }, &xsubi);
-}

package/c/stdlib.zig

@@ -294,103 +294,3 @@ fn bsearch(key: *const anyopaque, base: *const anyopaque, n: usize, size: usize,
     }
     return null;
 }
-
-test abs {
-    const val: c_int = -10;
-    try std.testing.expectEqual(10, abs(val));
-}
-
-test labs {
-    const val: c_long = -10;
-    try std.testing.expectEqual(10, labs(val));
-}
-
-test llabs {
-    const val: c_longlong = -10;
-    try std.testing.expectEqual(10, llabs(val));
-}
-
-test div {
-    const expected: div_t = .{ .quot = 5, .rem = 5 };
-    try std.testing.expectEqual(expected, div(55, 10));
-}
-
-test ldiv {
-    const expected: ldiv_t = .{ .quot = -6, .rem = 2 };
-    try std.testing.expectEqual(expected, ldiv(38, -6));
-}
-
-test lldiv {
-    const expected: lldiv_t = .{ .quot = 1, .rem = 2 };
-    try std.testing.expectEqual(expected, lldiv(5, 3));
-}
-
-test atoi {
-    try std.testing.expectEqual(0, atoi(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoi(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoi(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoi(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoi(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoi(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoi(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoi(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoi(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoi(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_int)}))));
-    try std.testing.expectEqual(std.math.minInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_int)}))));
-}
-
-test atol {
-    try std.testing.expectEqual(0, atol(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atol(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atol(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atol(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atol(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atol(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atol(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atol(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atol(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atol(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_long)}))));
-    try std.testing.expectEqual(std.math.minInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_long)}))));
-}
-
-test atoll {
-    try std.testing.expectEqual(0, atoll(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoll(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoll(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoll(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoll(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoll(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoll(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoll(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoll(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoll(@ptrCast("   +32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_longlong)}))));
-    try std.testing.expectEqual(std.math.minInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_longlong)}))));
-}
-
-// FIXME: We cannot test strtol, strtoll, strtoul, etc.. here as it must modify errno and libc is not linked in tests
-
-test bsearch {
-    const Comparison = struct {
-        pub fn compare(a: *const anyopaque, b: *const anyopaque) callconv(.c) c_int {
-            const a_u16: *const u16 = @ptrCast(@alignCast(a));
-            const b_u16: *const u16 = @ptrCast(@alignCast(b));
-
-            return switch (std.math.order(a_u16.*, b_u16.*)) {
-                .gt => 1,
-                .eq => 0,
-                .lt => -1,
-            };
-        }
-    };
-
-    const items: []const u16 = &.{ 0, 5, 7, 9, 10, 200, 512, 768 };
-
-    try std.testing.expectEqual(@as(?*anyopaque, null), bsearch(&@as(u16, 2000), items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-
-    for (items) |*value| {
-        try std.testing.expectEqual(@as(*const anyopaque, value), bsearch(value, items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-    }
-}