srctree

}

}

 

var r = Isaac64.init(0);

 

// from reference implementation

 

}

}

 

var r = Pcg.init(0);

const s0: u64 = 0x9394bf54ce5d79de;

const s1: u64 = 0x84e9c579ef59bbf7;

 

}

}

 

// Unfortunately there does not seem to be an official test sequence.

var r = RomuTrio.init(0);

 

 

}

}

 

// Unfortunately there does not seem to be an official test sequence.

var r = Sfc64.init(0);

 

 

}

}

 

var r = Xoroshiro128.init(0);

r.s[0] = 0xaeecf86f7878dd75;

r.s[1] = 0x01cd153642e72622;

 

}

}

 

var r = Xoshiro256.init(0);

 

const seq = [_]u64{

 

const expect = std.testing.expect;

const expectError = std.testing.expectError;

 

// Many of these test strings are from https://github.com/semver/semver.org/issues/59#issuecomment-390854010.

 

// Valid version strings should be accepted.

 

event.set();

}

 

if (builtin.single_threaded) return error.SkipZigTest;

 

var value: usize = 0;

try std.testing.expectEqual(value, 1);

}

 

if (builtin.single_threaded) return error.SkipZigTest;

 

var value: usize = 0;

 

}

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

 

sem.cond.signal();

}

 

if (builtin.single_threaded) {

return error.SkipZigTest;

}

try testing.expect(n == num_threads);

}

 

var sem = Semaphore{};

try testing.expectEqual(0, sem.permits);

 

 

return self.cloneWithAllocator(self.allocator());

}

 

fn free(self: *const BufSet, value: []const u8) void {

self.hash_map.allocator.free(value);

}

try bufset.insert("z");

}

 

test "clone with arena" {

const allocator = std.testing.allocator;

var arena = std.heap.ArenaAllocator.init(allocator);

 

}

 

// example from: https://youtu.be/SJPvNi4HrWQ?t=3558

var cb: Self = .{};

 

cb.writeAll("a salad; ");

try testing.expectEqualStrings("a b c b c b c d", cb.read());

}

 

var cb: Self = .{};

 

cb.writeAll("0123456789");

try testing.expectEqualStrings("", cb.read());

}

 

var cb: Self = .{};

 

const data = "0123456789abcdef" ** (1024 / 16);

 

return @intCast((v *% prime4) >> consts.lookup.shift);

}

 

const data = [_]u8{

0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,

0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,

try expect(h.chain[2 + 8] == 2);

}

 

const data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";

 

// one by one

 

return self.buffer[@intCast(self.fp)..self.rp];

}

 

const data = "Blah blah blah blah blah!";

var win: Self = .{};

try expect(win.write(data) == data.len);

try expect(win.match(15, 20, 4) == 0);

}

 

var win: Self = .{};

win.wp = Self.buffer_len - 11;

win.rp = Self.buffer_len - 111;

 

return r >> @as(math.Log2Int(T), @intCast(@typeInfo(T).Int.bits - n));

}

 

const ReverseBitsTest = struct {

in: u16,

bit_count: u5,

 

return directEnumArrayDefault(E, Data, null, max_unused_slots, init_values);

}

 

const E = enum(i4) { a = 4, b = 6, c = 2 };

var runtime_false: bool = false;

_ = &runtime_false;

return result;

}

 

const E = enum(i4) { a = 4, b = 6, c = 2 };

var runtime_false: bool = false;

_ = &runtime_false;

};

}

 

const A = enum(u1) { a = 0, b = 1 };

const B = enum(u1) { a = 1, b = 0 };

try testing.expectEqual(A.a, nameCast(A, .a));

};

}

 

const Ball = enum { red, green, blue };

 

const empty = EnumMultiset(Ball).initEmpty();

}

}

 

ensureIndexer(struct {

pub const Key = u32;

pub const count: comptime_int = 8;

try testing.expectEqual(0, Indexer.count);

}

 

const E = enum {

X,

Y,

 

return 2 * (df + w);

}

 

try expect(acos(@as(f32, 0.0)) == acos32(0.0));

try expect(acos(@as(f64, 0.0)) == acos64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon));

try expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon));

 

}

}

 

try expect(acosh(@as(f32, 1.5)) == acosh32(1.5));

try expect(acosh(@as(f64, 1.5)) == acosh64(1.5));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon));

try expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon));

 

}

}

 

try expect(asin(@as(f32, 0.0)) == asin32(0.0));

try expect(asin(@as(f64, 0.0)) == asin64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon));

 

return if (s != 0) -rx else rx;

}

 

try expect(asinh(@as(f32, 0.0)) == asinh32(0.0));

try expect(asinh(@as(f64, 0.0)) == asinh64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon));

 

}

}

 

try expect(@as(u32, @bitCast(atan(@as(f32, 0.2)))) == @as(u32, @bitCast(atan32(0.2))));

try expect(atan(@as(f64, 0.2)) == atan64(0.2));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));

try expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));

 

}

}

 

const y32: f32 = 0.2;

const x32: f32 = 0.21;

const y64: f64 = 0.2;

try expect(atan2(y64, x64) == atan2_64(0.2, 0.21));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon));

 

return if (s != 0) -y else y;

}

 

try expect(atanh(@as(f32, 0.0)) == atanh_32(0.0));

try expect(atanh(@as(f64, 0.0)) == atanh_64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon));

 

}

}

 

var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321);

defer a.deinit();

 

 

return t + t * q;

}

 

try expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0));

try expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.isPositiveZero(cbrt32(0.0)));

try expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.isPositiveZero(cbrt64(0.0)));

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = atan(a);

 

try testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));

}

 

const a = Complex(f64).init(5, 3);

const c = atan(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = atanh(a);

 

 

return Complex(T).init(z.re, -z.im);

}

 

const a = Complex(f32).init(5, 3);

const c = a.conjugate();

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = cos(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = cosh(a);

 

try testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));

}

 

const a = Complex(f64).init(5, 3);

const c = cosh(a);

 

 

}

}

 

const tolerance_f32 = @sqrt(math.floatEps(f32));

 

{

}

}

 

const tolerance_f64 = @sqrt(math.floatEps(f64));

 

{

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = log(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const b = Complex(f32).init(2.3, -1.3);

const c = pow(a, b);

 

return Complex(T).init(z.re, z.im);

}

 

const a = Complex(f32).init(5, 3);

const c = proj(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = sin(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = sinh(a);

 

try testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));

}

 

const a = Complex(f64).init(5, 3);

const c = sinh(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = sqrt(a);

 

try testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));

}

 

const a = Complex(f64).init(5, 3);

const c = sqrt(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = tan(a);

 

 

 

const epsilon = 0.0001;

 

const a = Complex(f32).init(5, 3);

const c = tanh(a);

 

try testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));

}

 

const a = Complex(f64).init(5, 3);

const c = tanh(a);

 

 

return expo2(ax);

}

 

try expect(cosh(@as(f32, 1.5)) == cosh32(1.5));

try expect(cosh(@as(f64, 1.5)) == cosh64(1.5));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon));

try expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon));

 

}

}

 

try expect(expm1(@as(f32, 0.0)) == expm1_32(0.0));

try expect(expm1(@as(f64, 0.0)) == expm1_64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.isPositiveZero(expm1_32(0.0)));

try expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.isPositiveZero(expm1_64(0.0)));

 

}

}

 

const inf_u16: u16 = 0x7C00;

const inf_u32: u32 = 0x7F800000;

const inf_u64: u64 = 0x7FF0000000000000;

try expectEqual(inf_u128, @as(u128, @bitCast(inf(f128))));

}

 

const qnan_u16: u16 = 0x7E00;

const qnan_u32: u32 = 0x7FC00000;

const qnan_u64: u64 = 0x7FF8000000000000;

try expectEqual(qnan_u128, @as(u128, @bitCast(nan(f128))));

}

 

// TODO: https://github.com/ziglang/zig/issues/14366

if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;

 

 

const expectEqual = std.testing.expectEqual;

const expectApproxEqRel = std.testing.expectApproxEqRel;

 

inline for (&.{ f32, f64 }) |T| {

const eps = @sqrt(std.math.floatEps(T));

try expectApproxEqRel(@as(T, 120), gamma(T, 6), eps);

}

}

 

inline for (&.{ f32, f64 }) |T| {

const eps = @sqrt(std.math.floatEps(T));

try expectApproxEqRel(@as(T, @log(24.0)), lgamma(T, 5), eps);

 

return z * @sqrt(ly + lx + hy + hx);

}

 

const x32: f32 = 0.0;

const y32: f32 = -1.2;

const x64: f64 = 0.0;

try expect(hypot(x64, y64) == hypot64(0.0, -1.2));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon));

try expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon));

 

return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;

}

 

try expect(log1p(@as(f32, 0.0)) == log1p_32(0.0));

try expect(log1p(@as(f64, 0.0)) == log1p_64(0.0));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon));

 

}

}

 

// https://github.com/ziglang/zig/issues/13703

if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;

 

 

return result;

}

 

const a = modf(@as(f32, 1.0));

const b = modf32(1.0);

// NOTE: No struct comparison on generic return type function? non-named, makes sense, but still.

try expectEqual(a, b);

}

 

const epsilon = 0.000001;

var r: modf32_result = undefined;

 

try expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon));

}

 

const epsilon = 0.000001;

var r: modf64_result = undefined;

 

 

return acc;

}

 

try testing.expectError(error.Overflow, powi(i8, -66, 6));

try testing.expectError(error.Overflow, powi(i16, -13, 13));

try testing.expectError(error.Overflow, powi(i32, -32, 21));

 

return 2 * h * expo2(ax);

}

 

try expect(sinh(@as(f32, 1.5)) == sinh32(1.5));

try expect(sinh(@as(f64, 1.5)) == sinh64(1.5));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon));

 

return if (sign) -t else t;

}

 

try expect(tanh(@as(f32, 1.5)) == tanh32(1.5));

try expect(tanh(@as(f64, 1.5)) == tanh64(1.5));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon));

try expect(math.approxEqAbs(f32, tanh32(-37.45), -1.0, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon));

 

}

}

 

const E1 = enum {

A,

B,

};

}

 

try testing.expect(alignment(u8) == 1);

try testing.expect(alignment(*align(1) u8) == 1);

try testing.expect(alignment(*align(2) u8) == 2);

};

}

 

try testing.expect(Child([1]u8) == u8);

try testing.expect(Child(*u8) == u8);

try testing.expect(Child([]u8) == u8);

@compileError("Expected pointer, slice, array or vector type, found '" ++ @typeName(T) ++ "'");

}

 

try testing.expect(Elem([1]u8) == u8);

try testing.expect(Elem([*]u8) == u8);

try testing.expect(Elem([]u8) == u8);

};

}

 

const S1 = struct {};

const S2 = packed struct {};

const S3 = extern struct {};

};

}

 

const E1 = enum {

A,

 

@compileError("'" ++ @typeName(T) ++ "' has no declaration '" ++ decl_name ++ "'");

}

 

const E1 = enum {

A,

 

};

}

 

const E1 = enum {

A,

};

return fields(T)[@intFromEnum(field)];

}

 

const E1 = enum {

A,

};

return fieldInfo(T, field).type;

}

 

const S = struct {

a: u8,

b: u16,

};

}

 

const E1 = enum { A, B };

const E2 = error{A};

const S1 = struct {

};

}

 

const E1 = enum { A, B };

const E2 = error{A};

 

);

}

 

try expectEqualEnum(enum {}, FieldEnum(struct {}));

try expectEqualEnum(enum { a }, FieldEnum(struct { a: u8 }));

try expectEqualEnum(enum { a, b, c }, FieldEnum(struct { a: u8, b: void, c: f32 }));

});

}

 

const A = struct {

pub const a: u8 = 0;

};

};

}

 

const E = enum(u8) {

C = 33,

D,

return @as(Tag(T), u);

}

 

const UE = enum {

Int,

Float,

return TagPayloadByName(U, @tagName(tag));

}

 

const Event = union(enum) {

Moved: struct {

from: i32,

}

}

 

const S = struct {

a: u32,

b: f64,

try testing.expect(!eql(v1, v3));

}

 

const E1 = enum {

A,

};

});

}

 

try testing.expectEqual(f16, Float(16));

try testing.expectEqual(f32, Float(32));

try testing.expectEqual(f64, Float(64));

}

};

 

TupleTester.assertTuple(.{}, ArgsTuple(fn () void));

TupleTester.assertTuple(.{u32}, ArgsTuple(fn (a: u32) []const u8));

TupleTester.assertTuple(.{ u32, f16 }, ArgsTuple(fn (a: u32, b: f16) noreturn));

TupleTester.assertTuple(.{u32}, ArgsTuple(fn (comptime a: u32) []const u8));

}

 

TupleTester.assertTuple(.{}, Tuple(&[_]type{}));

TupleTester.assertTuple(.{u32}, Tuple(&[_]type{u32}));

TupleTester.assertTuple(.{ u32, f16 }, Tuple(&[_]type{ u32, f16 }));

return if (error_union) |_| false else |_| true;

}

 

try std.testing.expect(isError(math.divTrunc(u8, 5, 0)));

try std.testing.expect(!isError(math.divTrunc(u8, 5, 5)));

}

return @typeInfo(@TypeOf(@field(T, name))) == .Fn;

}

 

const S1 = struct {

pub fn foo() void {}

};

};

}

 

try std.testing.expect(!hasMethod(u32, "foo"));

try std.testing.expect(!hasMethod([]u32, "len"));

try std.testing.expect(!hasMethod(struct { u32, u64 }, "len"));

};

}

 

const TestStruct1 = struct {

a: u32,

b: u32,