srctree

}

}

 

var r = Isaac64.init(0);

 

// from reference implementation

}

}

 

var r = Isaac64.init(0);

 

// from reference implementation

 

}

}

 

var r = Pcg.init(0);

const s0: u64 = 0x9394bf54ce5d79de;

const s1: u64 = 0x84e9c579ef59bbf7;

}

}

 

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 = RomuTrio.init(0);

 

}

}

 

const buf0 = @as([24]u8, @bitCast([3]u64{ 16294208416658607535, 13964609475759908645, 4703697494102998476 }));

const resulting_state = .{ .x = 16294208416658607535, .y = 13964609475759908645, .z = 4703697494102998476 };

var r = RomuTrio.init(0);

 

}

}

 

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

var r = Sfc64.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 = Xoroshiro128.init(0);

r.s[0] = 0xaeecf86f7878dd75;

r.s[1] = 0x01cd153642e72622;

 

}

}

 

if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;

 

var r = Xoshiro256.init(0);

}

}

 

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.

if (parse(big_invalid)) |ver| std.debug.panic("expected error, found {}", .{ver}) else |_| {}

}

 

// SemVer 2 spec 11.2 example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1.

try expect(order(try parse("1.0.0"), try parse("2.0.0")) == .lt);

try expect(order(try parse("2.0.0"), try parse("2.1.0")) == .lt);

 

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;

 

}

};

 

var mutex = Mutex{};

var cond = Condition{};

 

}

 

// Inspired from: https://github.com/Amanieu/parking_lot/pull/129

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

}

 

// Tests issue #12877

// This test requires spawning threads

if (builtin.single_threaded) {

 

}

};

 

var value = atomic.Value(u32).init(0);

 

// Try waits with invalid values.

Futex.wake(&value, std.math.maxInt(u32));

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

for (paddles) |p| try testing.expectEqual(p.current, num_iterations);

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

}

};

 

var deadline = Deadline.init(100 * std.time.ns_per_ms);

var futex_word = atomic.Value(u32).init(0);

 

 

}

};

 

var mutex = Mutex{};

 

try testing.expect(mutex.tryLock());

}

};

 

// This test requires spawning threads.

if (builtin.single_threaded) {

return error.SkipZigTest;

for (runners) |r| try testing.expectEqual(r.counter.get(), num_increments);

}

 

// This test requires spawning threads.

if (builtin.single_threaded) {

return error.SkipZigTest;

 

}

};

 

// make sure the event is unset

var event = ResetEvent{};

try testing.expectEqual(false, event.isSet());

try testing.expectEqual(true, event.isSet());

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

try ctx.input();

}

 

// This test requires spawning threads

if (builtin.single_threaded) {

return error.SkipZigTest;

 

try testing.expectEqual(rwl, DefaultRwLock{});

}

 

var rwl = RwLock{};

 

rwl.lock();

rwl.unlock();

}

 

if (builtin.single_threaded)

return;

 

 

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 result;

}

 

{

var list = ArrayList(i32).init(testing.allocator);

defer list.deinit();

}

}

 

const a = testing.allocator;

{

var list = try ArrayList(i8).initCapacity(a, 200);

}

}

 

const a = testing.allocator;

{

var array = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.failing_allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

const a = testing.allocator;

{

var list = ArrayList(i32).init(a);

}

}

 

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

defer arena.deinit();

const a = arena.allocator();

sub_items: ArrayListUnmanaged(ItemUnmanaged),

};

 

const a = std.testing.allocator;

{

var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(a) };

}

}

 

const a = testing.allocator;

 

{

}

}

 

const a = testing.allocator;

 

{

try testing.expect(mem.eql(i32, list.items, &.{ 3, 3, 3, 3 }));

}

 

const a = std.testing.allocator;

{

var list = ArrayList(u8).init(a);

}

}

 

// Shrink the list after every insertion to ensure that a memory growth

// will be triggered in the next operation.

const a = std.testing.allocator;

}

}

 

const a = testing.allocator;

 

 

}

 

const a = testing.allocator;

 

 

}

 

const a = testing.allocator;

{

var list = ArrayList(u8).init(a);

}

}

 

const a = testing.allocator;

{

var list = std.ArrayListAligned(u8, 8).init(a);

}

}

 

// An ArrayList on zero-sized types should not need to allocate

const a = testing.failing_allocator;

 

try testing.expectEqual(count, 3);

}

 

const a = testing.allocator;

 

var list = ArrayList(?u32).init(a);

try testing.expect(list.popOrNull() == null);

}

 

const a = testing.allocator;

 

var list = ArrayList(u32).init(a);

try testing.expectEqual(const_list.getLast(), 2);

}

 

const a = testing.allocator;

 

var list = ArrayList(u32).init(a);

 

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

}

 

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

self.hash_map.allocator.free(value);

}

}

};

 

var bufset = BufSet.init(std.testing.allocator);

defer bufset.deinit();

 

try bufset.insert("z");

}

 

const allocator = std.testing.allocator;

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

defer arena.deinit();

 

_ = inflate;

}

 

if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;

 

var cmp_buf: [64 * 1024]u8 = undefined; // compressed data buffer

try testing.expectEqualSlices(u8, expected_plain, out.items);

}

 

try testDecompress(.zlib, &[_]u8{

0x08, 0xd7, 0x63, 0xf8, 0xcf, 0xc0, 0xc0, 0x00, 0xc1, 0xff,

0xff, 0x43, 0x30, 0x03, 0x03, 0xc3, 0xff, 0xff, 0xff, 0x01,

});

}

 

// Truncated header

try testing.expectError(

error.EndOfStream,

);

}

 

// Truncated header

try testing.expectError(

error.EndOfStream,

}, "");

}

 

if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;

 

const plain_data = [_]u8{ 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a };

 

}

 

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

var cb: Self = .{};

 

cb.writeAll("a salad; ");

try testing.expectEqualStrings("a salad; a salsal", cb.read());

}

 

var cb: Self = .{};

 

cb.writeAll("a b c ");

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);

try testing.expectEqual(@as(usize, 200), cb.read().len); // read the rest

}

 

var cb: Self = .{};

cb.wp = cb.buffer.len - 15;

cb.rp = cb.wp;

try testing.expect(cb.wp == cb.rp);

}

 

var cb: Self = .{};

cb.wp = cb.buffer.len - 15;

cb.rp = cb.wp;

 

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;

 

.{ .extra_bits = 13, .base_scaled = 0x6000, .code = 29, .base = 24577 },

};

 

try expect(@sizeOf(Token) == 4);

}

 

// testing table https://datatracker.ietf.org/doc/html/rfc1951#page-12

var c = Token.initMatch(1, 4).lengthEncoding();

try expect(c.code == 258);

try expect(c.extra_bits == 0);

try expect(c.extra_length == 130 - 115);

}

 

var c = Token.initMatch(1, 4).distanceEncoding();

try expect(c.code == 0);

try expect(c.extra_bits == 0);

try expect(c.extra_distance == 192 - 129);

}

 

for (match_lengths, 0..) |ml, i| {

try expect(@as(u16, ml.base_scaled) + 3 == ml.base);

try expect(i + 257 == ml.code);

 

};

}

 

var fbs = std.io.fixedBufferStream(&[_]u8{ 0xf3, 0x48, 0xcd, 0xc9, 0x00, 0x00 });

var br = bitReader(fbs.reader());

const F = BitReader(@TypeOf(fbs.reader())).flag;

try testing.expectEqual(@as(u16, 0xc), try br.readN(4, 0));

}

 

const data = [_]u8{

0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, // deflate data block type 1

0x2f, 0xca, 0x49, 0xe1, 0x02, 0x00,

try testing.expectEqual(@as(u16, 0xddcc), try br.readF(u16, 0));

}

 

const data = [_]u8{

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

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

try testing.expectEqual(@as(u64, 0x00_00_00_00_00_08_07_06), br.bits);

}

 

const data = [_]u8{

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

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

try testing.expectEqualSlices(u8, data[0..16], &out);

}

 

const fixed_codes = @import("huffman_encoder.zig").fixed_codes;

 

var fbs = std.io.fixedBufferStream(&fixed_codes);

 

const testCases = @import("testdata/block_writer.zig").testCases;

 

// tests if the writeBlock encoding has changed.

inline for (0..testCases.len) |i| {

try testBlock(testCases[i], .write_block);

}

}

 

// tests if the writeBlockDynamic encoding has changed.

inline for (0..testCases.len) |i| {

try testBlock(testCases[i], .write_dyn_block);

}

}

 

inline for (0..testCases.len) |i| {

try testBlock(testCases[i], .write_huffman_block);

}

 

var code: u16 = 0;

var idx: u16 = 0;

for (&self.symbols, 0..) |*sym, pos| {

if (sym.code_bits == 0) continue; // skip unused

sym.code = code;

 

idx = next_idx;

code = next_code;

}

}

 

/// Given the list of code lengths check that it represents a canonical

};

}

 

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

const code_lens = [_]u4{ 4, 3, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 3, 2 };

var h: CodegenDecoder = .{};

try testing.expectEqual(16, (try h.find(@intCast(c))).symbol);

}

 

const LiteralEncoder = @import("huffman_encoder.zig").LiteralEncoder;

 

for (1..286) |j| { // for all different number of codes

};

 

const c = enc.codes[symbol];

}

 

// find each symbol by code

 

const s_code: u15 = @bitReverse(@as(u15, @intCast(c.code)));

const s = try dec.find(s_code);

}

}

}

 

return a.freq < b.freq;

}

 

var freqs: [19]u16 = [_]u16{

8, // 0

1, // 1

try testing.expectEqual(@as(u16, 0x3f), enc.codes[16].code);

}

 

const enc = fixedLiteralEncoder();

for (enc.codes) |c| {

switch (c.len) {

}

}

 

const enc = fixedDistanceEncoder();

for (enc.codes) |c| {

const v = @bitReverse(@as(u5, @intCast(c.code)));

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

}

 

const ReverseBitsTest = struct {

in: u16,

bit_count: u5,

}

}

 

var al = std.ArrayList(u8).init(testing.allocator);

defer al.deinit();

var bw = std.io.bitWriter(.little, al.writer());

 

};

}

 

const cases = [_]struct {

in: []const u8,

out: []const u8,

}

}

 

const cases = [_]struct {

in: []const u8,

out: []const u8,

}

}

 

const cases = [_]struct {

in: []const u8,

out: []const u8,

}

}

 

const cases = [_]struct {

input: []const u8,

out: []const u8 = "",

}

}

 

const input = @embedFile("testdata/fuzz/bug_18966.input");

const expect = @embedFile("testdata/fuzz/bug_18966.expect");

 

 

return std.testing.expectError(expected, testDecompress(compressed));

}

 

try testDecompressEqual(

"",

&[_]u8{

);

}

 

try testDecompressEqual(

"Hello world\n",

&[_]u8{

);

}

 

try testDecompressEqual(

"Hello world\n",

&[_]u8{

);

}

 

try testDecompressEqual(

"Hello\nWorld!\n",

@embedFile("testdata/good-unknown_size-with_eopm.lzma"),

);

}

 

try testDecompressEqual(

"Hello\nWorld!\n",

@embedFile("testdata/good-known_size-without_eopm.lzma"),

);

}

 

try testDecompressEqual(

"Hello\nWorld!\n",

@embedFile("testdata/good-known_size-with_eopm.lzma"),

);

}

 

try testDecompressError(

error.CorruptInput,

@embedFile("testdata/bad-too_big_size-with_eopm.lzma"),

);

}

 

try testDecompressError(

error.CorruptInput,

@embedFile("testdata/bad-too_small_size-without_eopm-3.lzma"),

 

const expectEqualSlices = std.testing.expectEqualSlices;

const expectError = std.testing.expectError;

 

const allocator = testing.allocator;

var vec2d = try Vec2D(i32).init(allocator, 1, .{ 2, 3 });

defer vec2d.deinit(allocator);

try expectEqualSlices(i32, &.{ 1, 1, 1 }, try vec2d.get(1));

}

 

const allocator = testing.allocator;

try expectError(

error.Overflow,

);

}

 

const allocator = testing.allocator;

var vec2d = try Vec2D(i32).init(allocator, 0, .{ 2, 3 });

defer vec2d.deinit(allocator);

try expectEqualSlices(i32, &.{ 7, 7, 7 }, try vec2d.get(1));

}

 

var data = [_]i32{ 0, 1, 2, 3, 4, 5, 6, 7 };

const vec2d = Vec2D(i32){

.data = &data,

try expectEqualSlices(i32, &.{ 6, 7 }, try vec2d.get(3));

}

 

var data = [_]i32{ 0, 1, 2, 3, 4, 5, 6, 7 };

var vec2d = Vec2D(i32){

.data = &data,

try expectEqualSlices(i32, &.{ 6, 7 }, try vec2d.get(3));

}

 

const allocator = testing.allocator;

var matrix = try Vec2D(i32).init(allocator, 0, .{ 3, 4 });

defer matrix.deinit(allocator);

try expectError(error.Overflow, matrix.getMut(row));

}

 

const allocator = testing.allocator;

var matrix = try Vec2D(i32).init(allocator, 0, .{ 3, 5 });

defer matrix.deinit(allocator);

 

try std.testing.expectEqualSlices(u8, expected, buf);

}

 

const uncompressed = @embedFile("testdata/rfc8478.txt");

const compressed3 = @embedFile("testdata/rfc8478.txt.zst.3");

const compressed19 = @embedFile("testdata/rfc8478.txt.zst.19");

try std.testing.expectEqualSlices(u8, uncompressed, buffer);

}

 

// default stack size for wasm32 is too low for Decompressor - slightly

// over 1MiB stack space is needed via the --stack CLI flag

if (@import("builtin").target.cpu.arch == .wasm32) return error.SkipZigTest;

 

E,

};

 

const map = ComptimeStringMap(TestEnum, .{

.{ "these", .D },

.{ "have", .A },

try std.testing.expect(null == map.get("NOTHING"));

}

 

const KV = struct { []const u8, TestEnum };

const map = ComptimeStringMap(TestEnum, [_]KV{

.{ "these", .D },

try testMap(map);

}

 

const KV = struct { []const u8, TestEnum };

const slice: []const KV = &[_]KV{

.{ "these", .D },

try std.testing.expect(null == map.get("averylongstringthathasnomatches"));

}

 

const KV = struct { []const u8 };

const slice: []const KV = &[_]KV{

.{"these"},

try std.testing.expect(null == map.get("NOTHING"));

}

 

const map = ComptimeStringMap(void, .{

.{"these"},

.{"have"},

try std.testing.expect(map.has("ThESe"));

}

 

const m1 = ComptimeStringMap(usize, .{});

try std.testing.expect(null == m1.get("anything"));

 

try std.testing.expect(null == m2.get("anything"));

}

 

const map = ComptimeStringMap(TestEnum, .{

.{ "redundant", .D },

.{ "theNeedle", .A },

try std.testing.expectEqual(TestEnum.A, map.get("theNeedle").?);

}

 

const map = ComptimeStringMapWithEql(TestEnum, .{

.{ "redundant", .D },

.{ "theNeedle", .A },

try std.testing.expectEqual(TestEnum.A, map.get("theNeedle").?);

}

 

const map = std.ComptimeStringMap(type, .{

.{ "a", struct {

pub const foo = 1;

 

try std.testing.expectEqualSlices(u8, &xp.toBytes(), &expected);

}

 

var s: [32]u8 = [_]u8{1} ++ [_]u8{0} ** 31;

const small_order_ss: [7][32]u8 = .{

.{

 

};

};

 

var seed: [32]u8 = undefined;

_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");

const key_pair = try Ed25519.KeyPair.create(seed);

try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key.toBytes())}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");

}

 

var seed: [32]u8 = undefined;

_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");

const key_pair = try Ed25519.KeyPair.create(seed);

try std.testing.expectError(error.SignatureVerificationFailed, sig.verify("TEST", key_pair.public_key));

}

 

var i: usize = 0;

while (i < 100) : (i += 1) {

const key_pair = try Ed25519.KeyPair.create(null);

}

}

 

const Vec = struct {

msg_hex: *const [64:0]u8,

public_key_hex: *const [64:0]u8,

}

}

 

const BlindKeyPair = Ed25519.key_blinding.BlindKeyPair;

 

// Create a standard Ed25519 key pair

try std.testing.expectEqualSlices(u8, &pk.toBytes(), &kp.public_key.toBytes());

}

 

const kp = try Ed25519.KeyPair.create(null);

 

var signer = try kp.signer(null);

try verifier.verify();

}

 

const kp = try Ed25519.KeyPair.create(null);

const kp2 = try Ed25519.KeyPair.fromSecretKey(kp.secret_key);

try std.testing.expectEqualSlices(u8, &kp.secret_key.toBytes(), &kp2.secret_key.toBytes());

 

 

const htest = @import("../test.zig");

 

const s = [_]u8{170} ++ [_]u8{0} ** 31;

var b = Edwards25519.basePoint;

const pk = try b.mul(s);

}

}

 

var s1: [32]u8 = undefined;

var s2: [32]u8 = undefined;

crypto.random.bytes(&s1);

try std.testing.expectError(error.IdentityElement, p.sub(q).add(q).sub(p).rejectIdentity());

}

 

var r = [32]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };

var p = Edwards25519.fromUniform(r);

try htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]);

}

 

// Test vectors from draft-irtf-cfrg-hash-to-curve-12

var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc");

try htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895839a", p.toBytes()[0..]);

 

try htest.assertEqual("42fa27c8f5a1ae0aa38bb59d5938e5145622ba5dedd11d11736fa2f9502d7367", p.toBytes()[0..]);

}

 

const s = [_]u8{0} ** 31 ++ [_]u8{255};

const p1 = try Edwards25519.basePoint.mulPublic(s);

const p2 = try Edwards25519.basePoint.mul(s);

 

 

const htest = @import("../test.zig");

 

var sk: [32]u8 = undefined;

var pk_expected: [32]u8 = undefined;

_ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");

try std.testing.expectEqual(pk_calculated, pk_expected);

}

 

const secret_key = [32]u8{ 0xa5, 0x46, 0xe3, 0x6b, 0xf0, 0x52, 0x7c, 0x9d, 0x3b, 0x16, 0x15, 0x4b, 0x82, 0x46, 0x5e, 0xdd, 0x62, 0x14, 0x4c, 0x0a, 0xc1, 0xfc, 0x5a, 0x18, 0x50, 0x6a, 0x22, 0x44, 0xba, 0x44, 0x9a, 0xc4 };

const public_key = [32]u8{ 0xe6, 0xdb, 0x68, 0x67, 0x58, 0x30, 0x30, 0xdb, 0x35, 0x94, 0xc1, 0xa4, 0x24, 0xb1, 0x5f, 0x7c, 0x72, 0x66, 0x24, 0xec, 0x26, 0xb3, 0x35, 0x3b, 0x10, 0xa9, 0x03, 0xa6, 0xd0, 0xab, 0x1c, 0x4c };

 

try std.testing.expectEqual(output, expected_output);

}

 

const secret_key = [32]u8{ 0x4b, 0x66, 0xe9, 0xd4, 0xd1, 0xb4, 0x67, 0x3c, 0x5a, 0xd2, 0x26, 0x91, 0x95, 0x7d, 0x6a, 0xf5, 0xc1, 0x1b, 0x64, 0x21, 0xe0, 0xea, 0x01, 0xd4, 0x2c, 0xa4, 0x16, 0x9e, 0x79, 0x18, 0xba, 0x0d };

const public_key = [32]u8{ 0xe5, 0x21, 0x0f, 0x12, 0x78, 0x68, 0x11, 0xd3, 0xf4, 0xb7, 0x95, 0x9d, 0x05, 0x38, 0xae, 0x2c, 0x31, 0xdb, 0xe7, 0x10, 0x6f, 0xc0, 0x3c, 0x3e, 0xfc, 0x4c, 0xd5, 0x49, 0xc7, 0x15, 0xa4, 0x93 };

 

try std.testing.expectEqual(output, expected_output);

}

 

const initial_value = [32]u8{ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

const expected_output = [32]u8{ 0x42, 0x2c, 0x8e, 0x7a, 0x62, 0x27, 0xd7, 0xbc, 0xa1, 0x35, 0x0b, 0x3e, 0x2b, 0xb7, 0x27, 0x9f, 0x78, 0x97, 0xb8, 0x7b, 0xb6, 0x85, 0x4b, 0x78, 0x3c, 0x60, 0xe8, 0x03, 0x11, 0xae, 0x30, 0x79 };

 

try std.testing.expectEqual(k, expected_output);

}

 

// These iteration tests are slow so we always skip them. Results have been verified.

if (true) {

return error.SkipZigTest;

try std.testing.expectEqual(k, expected_output);

}

 

if (true) {

return error.SkipZigTest;

}

 

};

}

 

const aeads = [_]type{ ChaCha20Poly1305, XChaCha20Poly1305 };

const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";

const ad = "Additional data";

}

 

// https://tools.ietf.org/html/rfc7539#section-2.4.2

const expected_result = [_]u8{

0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80,

0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81,

}

 

// https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7

const expected_result = [_]u8{

0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,

0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,

try testing.expectEqualSlices(u8, &expected_result, &result);

}

 

const expected_result = [_]u8{

0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,

0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,

try testing.expectEqualSlices(u8, &expected_result, &result);

}

 

const expected_result = [_]u8{

0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,

0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,

try testing.expectEqualSlices(u8, &expected_result, &result);

}

 

const expected_result = [_]u8{

0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,

0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,

try testing.expectEqualSlices(u8, &expected_result, &result);

}

 

const expected_result = [_]u8{

0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,

0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,

}

}

 

const key = [_]u8{69} ** 32;

const nonce = [_]u8{42} ** 24;

const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";

 

};

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const Scheme = EcdsaP384Sha384;

try sig2.verify(msg, kp.public_key);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const Scheme = EcdsaSecp256k1Sha256oSha256;

try sig2.verify(msg, kp.public_key);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);

try sig2.verify(msg, kp.public_key);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);

result: enum { valid, invalid, acceptable },

};

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const vectors = [_]TestVector{

try sig.verify(msg, pk);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const Scheme = EcdsaP384Sha384;

 

 

const htest = @import("test.zig");

 

var out: [HmacMd5.mac_length]u8 = undefined;

HmacMd5.create(out[0..], "", "");

try htest.assertEqual("74e6f7298a9c2d168935f58c001bad88", out[0..]);

try htest.assertEqual("80070713463e7749b90c2dc24911e275", out[0..]);

}

 

var out: [HmacSha1.mac_length]u8 = undefined;

HmacSha1.create(out[0..], "", "");

try htest.assertEqual("fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", out[0..]);

try htest.assertEqual("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", out[0..]);

}

 

var out: [sha2.HmacSha256.mac_length]u8 = undefined;

sha2.HmacSha256.create(out[0..], "", "");

try htest.assertEqual("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad", out[0..]);

 

 

const htest = @import("test.zig");

 

try htest.assertEqualHash(Md5, "d41d8cd98f00b204e9800998ecf8427e", "");

try htest.assertEqualHash(Md5, "0cc175b9c0f1b6a831c399e269772661", "a");

try htest.assertEqualHash(Md5, "900150983cd24fb0d6963f7d28e17f72", "abc");

try htest.assertEqualHash(Md5, "57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890");

}

 

var h = Md5.init(.{});

var out: [16]u8 = undefined;

 

try htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]);

}

 

var block = [_]u8{0} ** Md5.block_length;

var out: [Md5.digest_length]u8 = undefined;

 

 

}

};

 

const expected_mac = "\xa8\x06\x1d\xc1\x30\x51\x36\xc6\xc2\x2b\x8b\xaf\x0c\x01\x27\xa9";

 

const msg = "Cryptographic Forum Research Group";

try std.testing.expectEqualSlices(u8, expected_mac, &mac);

}

 

const expected_mac = [_]u8{ 25, 13, 249, 42, 164, 57, 99, 60, 149, 181, 74, 74, 13, 63, 121, 6 };

const msg = [_]u8{ 253, 193, 249, 146, 70, 6, 214, 226, 131, 213, 241, 116, 20, 24, 210, 224, 65, 151, 255, 104, 133 };

const key = [_]u8{ 190, 63, 95, 57, 155, 103, 77, 170, 7, 98, 106, 44, 117, 186, 90, 185, 109, 118, 184, 24, 69, 41, 166, 243, 119, 132, 151, 61, 52, 43, 64, 250 };

 

@memset(@as([]volatile T, s), 0);

}

 

var a: [100]u8 = undefined;

var b: [100]u8 = undefined;

random.bytes(a[0..]);

try testing.expect(timingSafeEql([100]u8, a, b));

}

 

if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;

 

var a: [100]u8 = undefined;

try testing.expect(timingSafeEql(@Vector(100, u8), v1, v3));

}

 

var a = [_]u8{10} ** 32;

var b = [_]u8{10} ** 32;

try testing.expectEqual(timingSafeCompare(u8, &a, &b, .big), .eq);

try testing.expectEqual(timingSafeCompare(u8, &a, &b, .little), .lt);

}

 

const len = 32;

var a: [len]u8 = undefined;

var b: [len]u8 = undefined;

}

}

 

var a = [_]u8{0xfe} ** 8;

var b = [_]u8{0xfe} ** 8;

 

 

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;

try testing.expectEqual(false, array[2]);

}

 

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

var runtime_b = "b";

_ = &runtime_b;

};

}

 

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();

try testing.expect(full.differenceWith(black).eql(red));

}

 

const E = enum {};

const empty = EnumSet(E).initEmpty();

const full = EnumSet(E).initFull();

try std.testing.expect(empty.eql(full.complement()));

}

 

const Direction = enum { up, down, left, right };

const diag_move = init: {

var move = EnumSet(Direction).initEmpty();

}

}

 

ensureIndexer(struct {

pub const Key = u32;

pub const count: comptime_int = 8;

}

}

 

const E = enum(u2) { b = 1, a = 0, c = 2 };

const Indexer = EnumIndexer(E);

ensureIndexer(Indexer);

try testing.expectEqual(E.c, Indexer.keyForIndex(2));

}

 

const E = enum(u4) { c = 6, a = 4, b = 5 };

const Indexer = EnumIndexer(E);

ensureIndexer(Indexer);

try testing.expectEqual(E.c, Indexer.keyForIndex(2));

}

 

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

const Indexer = EnumIndexer(E);

ensureIndexer(Indexer);

try testing.expectEqual(E.c, Indexer.keyForIndex(2));

}

 

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

const Indexer = EnumIndexer(E);

ensureIndexer(Indexer);

try testing.expectEqual(E.c, Indexer.keyForIndex(2));

}

 

const E = enum {};

const Indexer = EnumIndexer(E);

ensureIndexer(Indexer);

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

}

 

const E = enum {

X,

Y,

 

 

// See https://github.com/tiehuis/parse-number-fxx-test-data for a wider-selection of test-data.

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

try testing.expectError(error.InvalidCharacter, parseFloat(T, ""));

try testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));

}

}

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);

 

}

}

 

try expectEqual(@as(u16, @bitCast(try parseFloat(f16, "65504"))), 0x7bff);

try expectEqual(@as(u32, @bitCast(try parseFloat(f32, "3.4028234664E38"))), 0x7f7f_ffff);

try expectEqual(@as(u64, @bitCast(try parseFloat(f64, "1.7976931348623157E308"))), 0x7fef_ffff_ffff_ffff);

try expectEqual(@as(u128, @bitCast(try parseFloat(f128, "1.1897314953572317650857593266280070162E4932"))), 0x7ffe_ffff_ffff_ffff_ffff_ffff_ffff_ffff);

}

 

try expectEqual(try parseFloat(f128, "9007199254740993.0"), 9007199254740993.0);

}

 

try testing.expect(math.isNan(try parseFloat(f32, "nAn")));

try testing.expect(math.isPositiveInf(try parseFloat(f32, "iNf")));

try testing.expect(math.isPositiveInf(try parseFloat(f32, "+Inf")));

try testing.expect(math.isNegativeInf(try parseFloat(f32, "-iNf")));

}

try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0"));

try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "-0x0"));

try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0p42"));

try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0.00000p666"));

}

 

try testing.expectEqual(try parseFloat(f16, "0x1p0"), 1.0);

try testing.expectEqual(try parseFloat(f16, "-0x1p-1"), -0.5);

try testing.expectEqual(try parseFloat(f16, "0x10p+10"), 16384.0);

try testing.expectEqual(try parseFloat(f16, "-0x1p-24"), -math.floatTrueMin(f16));

}

 

try testing.expectError(error.InvalidCharacter, parseFloat(f32, "0x"));

try testing.expectEqual(try parseFloat(f32, "0x1p0"), 1.0);

try testing.expectEqual(try parseFloat(f32, "-0x1p-1"), -0.5);

try testing.expectEqual(try parseFloat(f32, "-0x1P-149"), -math.floatTrueMin(f32));

}

 

try testing.expectEqual(try parseFloat(f64, "0x1p0"), 1.0);

try testing.expectEqual(try parseFloat(f64, "-0x1p-1"), -0.5);

try testing.expectEqual(try parseFloat(f64, "0x10p+10"), 16384.0);

try testing.expectEqual(try parseFloat(f64, "0x1p-1074"), math.floatTrueMin(f64));

try testing.expectEqual(try parseFloat(f64, "-0x1p-1074"), -math.floatTrueMin(f64));

}

try testing.expectEqual(try parseFloat(f128, "0x1p0"), 1.0);

try testing.expectEqual(try parseFloat(f128, "-0x1p-1"), -0.5);

try testing.expectEqual(try parseFloat(f128, "0x10p+10"), 16384.0);

 

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(total, sum);

}

 

var map = AutoHashMap(i32, i32).init(std.testing.allocator);

defer map.deinit();

 

try testing.expect(initial_capacity == map.capacity());

}

 

var map = AutoHashMap(i32, i32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expect(!map.contains(1));

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(map.capacity(), 128);

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(map.capacity(), 256);

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(map.count(), 0);

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

const Map = AutoHashMap(u32, u32);

const n = 1000 * 1000;

var map = Map.init(std.heap.page_allocator);

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

}

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(sum, 20);

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(map.unmanaged.count(), limit);

}

 

var map = AutoHashMap(u32, u32).init(std.testing.allocator);

defer map.deinit();

 

try expectEqual(sum, 30);

}

 

var map = AutoHashMap(i32, i32).init(std.testing.allocator);

defer map.deinit();

 

try testing.expect(map.remove(3) == true);

}

 

const AdaptedContext = struct {

fn eql(self: @This(), adapted_key: []const u8, test_key: u64) bool {

_ = self;

}

}

 

var map = AutoHashMap(u64, u64).init(testing.allocator);

defer map.deinit();

 

try testing.expectEqual(capacity, map.capacity());

}

 

var map = AutoHashMap(i32, u64).init(testing.allocator);

defer map.deinit();

 

try testing.expect(map.count() == 0);

}

 

var map = AutoHashMap(u0, u64).init(testing.allocator);

defer map.deinit();

 

try testing.expect(map.count() == 0);

}

 

var map = AutoHashMapUnmanaged(u64, void){};

defer map.deinit(testing.allocator);

 

 

}

};

 

var arena_allocator = ArenaAllocator.init(std.testing.allocator);

defer arena_allocator.deinit();

// provides some variance in the allocated data

}

}

 

var arena_allocator = ArenaAllocator.init(std.testing.allocator);

defer arena_allocator.deinit();

const a = arena_allocator.allocator();

 

};

}

 

var pool = MemoryPool(u32).init(std.testing.allocator);

defer pool.deinit();

 

try std.testing.expect(p2 == p4);

}

 

var pool = try MemoryPool(u32).initPreheated(std.testing.allocator, 4);

defer pool.deinit();

 

_ = try pool.create();

}

 

const failer = std.testing.failing_allocator;

try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initPreheated(failer, 5));

}

 

var pool = try MemoryPoolExtra(u32, .{ .growable = false }).initPreheated(std.testing.allocator, 4);

defer pool.deinit();

 

try std.testing.expectError(error.OutOfMemory, pool.create());

}

 

const Foo = struct {

data: u64 align(16),

};

_ = foo;

}

 

const Foo = struct {

data: u64,

};

 

try testing.expectError(error.EndOfStream, reader.readByte());

}

 

var fis = std.io.fixedBufferStream("foobar");

const reader = fis.reader();

try testing.expectEqual(true, try reader.isBytes("foo"));

try testing.expectEqual(false, try reader.isBytes("qux"));

}

 

var fis = std.io.fixedBufferStream("foobar");

const reader = fis.reader();

try reader.skipBytes(3, .{});

try testing.expectError(error.EndOfStream, reader.skipBytes(1, .{}));

}

 

const a = std.testing.allocator;

var list = std.ArrayList(u8).init(a);

defer list.deinit();

try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterArrayList(&list, '\n', 5));

}

 

const a = std.testing.allocator;

var list = std.ArrayList(u8).init(a);

defer list.deinit();

try std.testing.expectEqualStrings("", list.items);

}

 

const a = std.testing.allocator;

var list = std.ArrayList(u8).init(a);

defer list.deinit();

try std.testing.expectEqualStrings("67", list.items);

}

 

const a = std.testing.allocator;

var list = std.ArrayList(u8).init(a);

defer list.deinit();

try std.testing.expectEqualStrings("1234", list.items);

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("0000\n1234\n");

try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterAlloc(a, '\n', 5));

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("\n");

}

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("1234567\n");

try std.testing.expectEqualStrings("67", result);

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("1234");

try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterAlloc(a, '\n', 5));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("0000\n1234\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("1234", try reader.readUntilDelimiter(&buf, '\n'));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("12345\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234567\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("67", try reader.readUntilDelimiter(&buf, '\n'));

}

 

{

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("");

}

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234\n");

const reader = fis.reader();

try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("12345");

const reader = fis.reader();

try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("0000\n12345");

const reader = fis.reader();

try std.testing.expectEqualStrings("12345", &buf);

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("0000\n1234\n");

try std.testing.expect((try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)) == null);

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("\n");

}

}

 

const a = std.testing.allocator;

 

var fis = std.io.fixedBufferStream("1234567\n");

try std.testing.expectEqualStrings("67", result);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("0000\n1234\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("12345\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234567\n");

const reader = fis.reader();

try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("");

const reader = fis.reader();

try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234\n");

const reader = fis.reader();

try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234");

const reader = fis.reader();

try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("1234567");

const reader = fis.reader();

try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);

}

 

var buf: [5]u8 = undefined;

var fis = std.io.fixedBufferStream("0000\n12345");

const reader = fis.reader();

try std.testing.expectEqualStrings("12345", &buf);

}

 

const input_string = "some_string_with_delimiter!";

var input_fbs = std.io.fixedBufferStream(input_string);

const reader = input_fbs.reader();

try std.testing.expectError(error.StreamTooLong, reader.streamUntilDelimiter(writer, '!', 5));

}

 

const test_string = "abcdefg";

var fis = std.io.fixedBufferStream(test_string);

const reader = fis.reader();

try testing.expectEqualStrings(array.slice(), test_string);

}

 

const test_string = "abcdefg";

var fis = std.io.fixedBufferStream(test_string);

const reader = fis.reader();

 

return .{ .unbuffered_reader = reader };

}

 

const OneByteReadReader = struct {

str: []const u8,

curr: usize,

fn smallBufferedReader(underlying_stream: anytype) BufferedReader(8, @TypeOf(underlying_stream)) {

return .{ .unbuffered_reader = underlying_stream };

}

const BlockReader = struct {

block: []const u8,

reads_allowed: usize,

 

};

}

 

const OneByteReadReader = struct {

str: []const u8,

curr: usize,

try testing.expectEqualSlices(u8, str, res);

}

 

const BlockReader = struct {

block: []const u8,

reads_allowed: usize,

}

}

 

// output has same bytes as consumer

const data = [_]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ** 12;

var in = io.fixedBufferStream(&data);

}

}

 

// output is lookahead bytes behind consumer

inline for (1..8) |lookahead| {

const data = [_]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ** 12;

}

}

 

const data = [_]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ** 2;

var in = io.fixedBufferStream(&data);

var out = std.ArrayList(u8).init(testing.allocator);

 

return .{ .child_reader = reader };

}

 

const bytes = "yay" ** 100;

var fbs = io.fixedBufferStream(bytes);

 

 

return .{ .bytes_written = 0, .child_stream = child_stream };

}

 

var counting_stream = countingWriter(std.io.null_writer);

const stream = counting_stream.writer();

 

 

}

}

 

var buf: [255]u8 = undefined;

var fbs = fixedBufferStream(&buf);

const stream = fbs.writer();

try testing.expectEqualSlices(u8, "HelloWorld!", fbs.getWritten());

}

 

comptime {

var buf: [255]u8 = undefined;

var fbs = fixedBufferStream(&buf);

}

}

 

var buffer: [10]u8 = undefined;

var fbs = fixedBufferStream(&buffer);

 

try testing.expectError(error.NoSpaceLeft, fbs.writer().writeAll("H"));

}

 

const bytes = [_]u8{ 1, 2, 3, 4, 5, 6, 7 };

var fbs = fixedBufferStream(&bytes);

 

 

}

};

 

std.testing.refAllDecls(StreamSource);

}

 

var buffer: [64]u8 = undefined;

var source = StreamSource{ .buffer = std.io.fixedBufferStream(&buffer) };

 

try std.testing.expectEqualStrings("Hello, World!", source.buffer.getWritten());

}

 

const buffer: [64]u8 = "Hello, World!".* ++ ([1]u8{0xAA} ** 51);

var source = StreamSource{ .const_buffer = std.io.fixedBufferStream(&buffer) };

 

 

try expectEqualTokens(expected_token, try scanner_or_reader.next());

}

 

var scanner = JsonScanner.initCompleteInput(std.testing.allocator, example_document_str);

defer scanner.deinit();

 

try testAllTypes(&tiny_json_reader, false);

}

 

var scanner = JsonScanner.initCompleteInput(std.testing.allocator, "[102, 111, 111 }");

defer scanner.deinit();

try expectNext(&scanner, .array_begin);

try std.testing.expectError(error.SyntaxError, scanner.next());

}

 

var scanner = JsonScanner.initCompleteInput(std.testing.allocator, "{ \"key\": }");

defer scanner.deinit();

try expectNext(&scanner, .object_begin);

}

}

 

try std.testing.expectEqual(true, try validate(std.testing.allocator, "{}"));

try std.testing.expectEqual(true, try validate(std.testing.allocator, "[]"));

try std.testing.expectEqual(false, try validate(std.testing.allocator, "[{[[[[{}]]]]}]"));

 

return log2_val + 1;

}

 

try testing.expect(log2_int_ceil(u32, 1) == 0);

try testing.expect(log2_int_ceil(u32, 2) == 1);

try testing.expect(log2_int_ceil(u32, 3) == 2);

 

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(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon));

}

 

try expect(math.isNan(acos32(-2)));

try expect(math.isNan(acos32(1.5)));

}

 

try expect(math.isNan(acos64(-2)));

try expect(math.isNan(acos64(1.5)));

}

 

}

}

 

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(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon));

}

 

try expect(math.isNan(acosh32(math.nan(f32))));

try expect(math.isNan(acosh32(0.5)));

}

 

try expect(math.isNan(acosh64(math.nan(f64))));

try expect(math.isNan(acosh64(0.5)));

}

 

}

}

 

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));

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

}

 

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

try expect(math.isNegativeZero(asin32(-0.0)));

try expect(math.isNan(asin32(-2)));

try expect(math.isNan(asin32(1.5)));

}

 

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

try expect(math.isNegativeZero(asin64(-0.0)));

try expect(math.isNan(asin64(-2)));

 

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(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon));

}

 

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

try expect(math.isNegativeZero(asinh32(-0.0)));

try expect(math.isPositiveInf(asinh32(math.inf(f32))));

try expect(math.isNan(asinh32(math.nan(f32))));

}

 

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

try expect(math.isNegativeZero(asinh64(-0.0)));

try expect(math.isPositiveInf(asinh64(math.inf(f64))));

 

}

}

 

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));

try expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));

}

 

const epsilon = 0.000001;

 

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

try expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));

}

 

const epsilon = 0.000001;

 

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

 

}

}

 

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));

try expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.isNan(atan2_32(1.0, math.nan(f32))));

try expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(math.isNan(atan2_64(1.0, math.nan(f64))));

 

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));

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

}

 

try expect(math.isPositiveInf(atanh_32(1)));

try expect(math.isNegativeInf(atanh_32(-1)));

try expect(math.isNan(atanh_32(1.5)));

try expect(math.isNan(atanh_32(math.nan(f32))));

}

 

try expect(math.isPositiveInf(atanh_64(1)));

try expect(math.isNegativeInf(atanh_64(-1)));

try expect(math.isNan(atanh_64(1.5)));

 

// They will still run on larger than this and should pass, but the multi-limb code-paths

// may be untested in some cases.

 

comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;

var a = try Managed.initSet(testing.allocator, s);

defer a.deinit();

}

}

 

var a = try Managed.initSet(testing.allocator, -10);

defer a.deinit();

 

try testing.expect(a.isPositive() == false);

}

 

var a = try Managed.initSet(testing.allocator, @as(u7, 45));

defer a.deinit();

 

try testing.expect(a.isPositive() == true);

}

 

var a = try Managed.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);

defer a.deinit();

 

try testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);

}

 

var a = try Managed.initSet(testing.allocator, 10);

defer a.deinit();

 

try testing.expect((try a.to(u8)) == 10);

}

 

var a = try Managed.initSet(testing.allocator, @as(i64, minInt(i64)));

defer a.deinit();

 

try testing.expect((try a.to(i64)) == minInt(i64));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));

defer a.deinit();

try a.set(@as(DoubleLimb, 0));

try testing.expectEqual(@as(DoubleLimb, 0), try a.to(DoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff);

defer a.deinit();

 

try testing.expectError(error.TargetTooSmall, a.to(u8));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

try a.ensureCapacity(8);

try testing.expect(a.len() == 1);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

try a.ensureCapacity(8);

try testing.expect(a.len() == 1);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect(a.isOdd());

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect(a.sizeInBaseUpperBound(2) >= 5033);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(i9)) == -129);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect(a.fits(u65));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(u128)) == 120317241209124781241290847124);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == -1023);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(u128)) == 120317241209124781241290847124);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(u32)) == 0xabcdef);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

try testing.expectError(error.InvalidCharacter, a.setString(10, "x"));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

try testing.expectError(error.InvalidBase, a.setString(45, "10"));

}

 

const test_types = [_]type{

u64,

i64,

}

}

 

var a = try Managed.initSet(testing.allocator, 120317241209124781241290847124);

defer a.deinit();

 

try testing.expect(mem.eql(u8, as, es));

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff);

defer a.deinit();

 

try testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45, .lower));

}

 

var a = try Managed.initSet(testing.allocator, -0b1011);

defer a.deinit();

 

try testing.expect(mem.eql(u8, as, es));

}

 

var a = try Managed.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);

defer a.deinit();

 

try testing.expect(mem.eql(u8, as, es));

}

 

var a = try Managed.initSet(testing.allocator, -123907434);

defer a.deinit();

 

try testing.expect(mem.eql(u8, as, es));

}

 

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

defer a.deinit();

 

try testing.expect(mem.eql(u8, as, es));

}

 

var a = try Managed.initSet(testing.allocator, 1234);

defer a.deinit();

var b = try a.clone();

try testing.expect((try b.to(u32)) == 1234);

}

 

var a = try Managed.initSet(testing.allocator, 1234);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5678);

try testing.expect((try b.to(u32)) == 1234);

}

 

var a = try Managed.initSet(testing.allocator, -10);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == -10);

}

 

var a = try Managed.initSet(testing.allocator, -11);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 10);

try testing.expect(a.order(b) == .lt);

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef);

try testing.expect(b.orderAbs(a) == .gt);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 1);

try testing.expect(b.orderAbs(a) == .lt);

}

 

var a = try Managed.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);

try testing.expect(a.order(b) == .lt);

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xffffffff1);

try testing.expect(!a.eql(b));

}

 

var a = try Managed.initSet(testing.allocator, -5);

defer a.deinit();

 

try testing.expect((try a.to(u32)) == 5);

}

 

var a = try Managed.initSet(testing.allocator, 5);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == 5);

}

 

var a = try Managed.initSet(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5);

try testing.expect((try c.to(u32)) == 55);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 1);

try testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);

}

 

var op1: u128 = 0xefefefef7f7f7f7f;

var op2: u128 = 0xfefefefe9f9f9f9f;

// These must be runtime-known to prevent this comparison being tautological, as the

try testing.expect((try c.to(u128)) == op1 + op2);

}

 

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

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0);

try testing.expect((try c.to(u32)) == 0);

}

 

const op1 = 0xffffffff777777771;

var a = try Managed.initSet(testing.allocator, op1);

defer a.deinit();

try testing.expect((try a.to(u128)) == op1);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == -3);

}

 

var a = try Managed.initSet(testing.allocator, 50);

defer a.deinit();

 

try testing.expect((try b.to(u32)) == 55);

}

 

var a = try Managed.initSet(testing.allocator, 123);

defer a.deinit();

 

try testing.expect((try b.to(u32)) == 154);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(u17));

defer a.deinit();

 

try testing.expect((try a.to(u17)) == 9);

}

 

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

defer a.deinit();

 

try testing.expect((try a.to(u17)) == 1);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb) - 1);

}

 

var a = try Managed.initSet(testing.allocator, 10);

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb) - 88);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(i21));

defer a.deinit();

 

try testing.expect((try a.to(i21)) == minInt(i21));

}

 

var a = try Managed.initSet(testing.allocator, minInt(i21));

defer a.deinit();

 

try testing.expect((try a.to(i21)) == maxInt(i21));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == -2);

}

 

var a = try Managed.initSet(testing.allocator, minInt(SignedDoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == maxInt(SignedDoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(u17) - 5);

defer a.deinit();

 

try testing.expect((try a.to(u17)) == maxInt(u17));

}

 

var a = try Managed.initSet(testing.allocator, 123);

defer a.deinit();

 

try testing.expect((try a.to(u17)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, 10);

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(i14));

defer a.deinit();

 

try testing.expect((try a.to(i14)) == maxInt(i14));

}

 

var a = try Managed.initSet(testing.allocator, minInt(i21));

defer a.deinit();

 

try testing.expect((try a.to(i21)) == minInt(i21));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == maxInt(SignedDoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, minInt(SignedDoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == minInt(SignedDoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5);

try testing.expect((try c.to(u32)) == 45);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 1);

try testing.expect((try c.to(Limb)) == maxInt(Limb));

}

 

var op1: u128 = 0xefefefefefefefefefefefef;

var op2: u128 = 0xabababababababababababab;

_ = .{ &op1, &op2 };

try testing.expect((try c.to(u128)) == op1 - op2);

}

 

var a = try Managed.initSet(testing.allocator, 0x11efefefefefefefefefefefef);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0x11efefefefefefefefefefefef);

try testing.expect((try c.to(u32)) == 0);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == -1);

}

 

var a = try Managed.initSet(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5);

try testing.expect((try c.to(u64)) == 250);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 2);

try testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var op1: u256 = 0x998888efefefefefefefef;

try testing.expect((try c.to(u256)) == op1 * op2);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 2);

try testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 2);

try testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(Limb) * maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, 0xefefefefefefefef);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0);

try testing.expect((try c.to(u32)) == 0);

}

 

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

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0);

try testing.expect((try c.to(u32)) == 0);

}

 

var a = try Managed.initCapacity(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initCapacity(testing.allocator, 100);

try testing.expect(b.eql(c));

}

 

var a = try Managed.initSet(testing.allocator, 1234);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5678);

try testing.expect((try c.to(u17)) == 59836);

}

 

var a = try Managed.initSet(testing.allocator, 1234);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -5678);

try testing.expect((try c.to(i17)) == -59836);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var op1: u256 = 0x998888efefefefefefefef;

try testing.expect((try c.to(u256)) == (op1 * op2) & ((1 << 65) - 1));

}

 

switch (builtin.zig_backend) {

.stage2_c => return error.SkipZigTest,

else => {},

try testing.expect((try c.to(SignedDoubleLimb)) == minInt(SignedDoubleLimb) + 2);

}

 

var a = try Managed.initCapacity(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initCapacity(testing.allocator, 100);

try testing.expect(b.eql(c));

}

 

var a = try Managed.initSet(testing.allocator, 50);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5);

try testing.expect((try r.to(u32)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, 49);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 5);

try testing.expect((try r.to(u32)) == 4);

}

 

// assumes usize is <= 64 bits.

var a = try Managed.initSet(testing.allocator, 1 << 52);

defer a.deinit();

try testing.expect((try r.to(u32)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, (1 << 52) | (1 << 33));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, (1 << 35));

try testing.expect((try r.to(u64)) == 8589934592);

}

 

var op1: u128 = 0xffffeeeeddddcccc;

var op2: u128 = 34;

_ = .{ &op1, &op2 };

try testing.expect((try r.to(u64)) == 0);

}

 

var op1: u128 = 0xffffeeeeddddcccf;

var op2: u128 = 34;

_ = .{ &op1, &op2 };

try testing.expect((try r.to(u64)) == 3);

}

 

var op1: u128 = 0xfefefefefefefefefefefefefefefefe;

var op2: u128 = 0xefab8;

_ = .{ &op1, &op2 };

try testing.expect((try r.to(u32)) == 0x3e4e);

}

 

var a = try Managed.initSet(testing.allocator, 0x0078f432);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0x01000000);

try testing.expect((try r.to(u64)) == 0x0078f432);

}

 

var a = try Managed.initSet(testing.allocator, 10);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 10);

try testing.expect((try r.to(u64)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, 3);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 10);

try testing.expect((try b.to(u64)) == 3);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

const op1 = 0x1ffffffff0078f432;

try testing.expect((try r.to(u128)) == op1);

}

 

const u: i32 = 5;

const v: i32 = 3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = -5;

const v: i32 = 3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = 5;

const v: i32 = -3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = -5;

const v: i32 = -3;

 

try testing.expect((try r.to(i32)) == er);

}

 

var one = try Managed.initSet(testing.allocator, 1);

defer one.deinit();

var x = try Managed.initSet(testing.allocator, std.math.pow(u128, 2, 64));

try testing.expect(r.order(one) == std.math.Order.lt);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try mod.to(i32)) == 0);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect(std.mem.eql(u8, mods, "870000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect(std.mem.eql(u8, ress, "1a974a5c9734476ff5a3604bcc678a756beacfc21b4427d1f2c1f56f5d4e411a162c56136e20000000000000000000000000000000"));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try res.to(i32)) == 0);

}

 

const u: i32 = 5;

const v: i32 = 3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = -5;

const v: i32 = 3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = 5;

const v: i32 = -3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = -5;

const v: i32 = -3;

 

try testing.expect((try r.to(i32)) == er);

}

 

const u: i32 = -0x80000000;

const v: i32 = 1;

 

try testing.expect((try r.to(i32)) == 0);

}

 

const u: i32 = -2;

const v: i32 = 12;

 

try testing.expect((try r.to(i32)) == 10);

}

 

const u: i32 = 10;

const v: i32 = 12;

 

try testing.expect((try r.to(i32)) == 10);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);

try testing.expect((try r.to(u128)) == 0x28de0acacd806823638);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);

try testing.expect((try r.to(u128)) == 0);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111);

try testing.expect((try r.to(u128)) == 0x44444443444444431111111111111111);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);

try testing.expect((try r.to(u256)) == 0x1111111111111111111110b12222222222222222282);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000);

try testing.expect(r.eqlZero());

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);

try testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);

try testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);

try testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

var b = try Managed.init(testing.allocator);

try testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

var b = try Managed.init(testing.allocator);

try testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(u47));

defer a.deinit();

 

try testing.expect((try a.to(u17)) == maxInt(u17));

}

 

var a = try Managed.initSet(testing.allocator, 0x1_0000);

defer a.deinit();

 

try testing.expect((try a.to(i17)) == minInt(i17));

}

 

var a = try Managed.initSet(testing.allocator, (maxInt(Limb) + 1) | 0x1234_5678_9ABC_DEF0);

defer a.deinit();

 

try testing.expect((try a.to(u27)) == 0x2BC_DEF0);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) << 10);

defer a.deinit();

 

try testing.expect((try a.to(i11)) == minInt(i11));

}

 

const bits = @typeInfo(SignedDoubleLimb).Int.bits;

const Int = std.meta.Int(.unsigned, bits - 1);

 

try testing.expect((try a.to(Int)) == maxInt(Int));

}

 

var a = try Managed.initSet(testing.allocator, 3 << @bitSizeOf(Limb));

defer a.deinit();

 

try testing.expect((try a.to(std.meta.Int(.signed, @bitSizeOf(Limb) + 1))) == -1 << @bitSizeOf(Limb));

}

 

var a = try Managed.initSet(testing.allocator, -@as(SignedDoubleLimb, maxInt(Limb) + 1));

defer a.deinit();

 

try testing.expect((try a.to(i17)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, 1);

defer a.deinit();

try a.shiftLeft(&a, 1023);

try testing.expect((try b.to(i1)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, 0xBBBB_BBBB);

defer a.deinit();

 

try testing.expect((try a.to(i17)) == maxInt(i17));

}

 

var a = try Managed.initSet(testing.allocator, -1_234_567);

defer a.deinit();

 

try testing.expect((try a.to(i17)) == minInt(i17));

}

 

var a = try Managed.initSet(testing.allocator, maxInt(i17) - 1);

defer a.deinit();

 

try testing.expect((try a.to(i17)) == maxInt(i17) - 1);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) << @bitSizeOf(SignedDoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == maxInt(SignedDoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, 0xFEFE_FEFE);

defer a.deinit();

 

try testing.expect((try a.to(u23)) == maxInt(u23));

}

 

var a = try Managed.initSet(testing.allocator, -1);

defer a.deinit();

 

try testing.expect(a.eqlZero());

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) << @bitSizeOf(DoubleLimb));

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb));

}

 

var a = try Managed.initSet(testing.allocator, 0xffff0000);

defer a.deinit();

try a.shiftRight(&a, 16);

try testing.expect((try a.to(u32)) == 0xffff);

}

 

var a = try Managed.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333);

defer a.deinit();

try a.shiftRight(&a, 67);

try testing.expect(a.eqlZero());

}

 

var a = try Managed.initSet(testing.allocator, 0xffff);

defer a.deinit();

try a.shiftLeft(&a, 16);

try testing.expect((try a.to(u64)) == 0xffff0000);

}

 

var a = try Managed.initSet(testing.allocator, 0x1fffe0001dddc222);

defer a.deinit();

try a.shiftLeft(&a, 67);

try testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);

}

 

var a = try Managed.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.to(i32)) == -1); // -10 >> 1232 == -1

}

 

var a = try Managed.initSet(testing.allocator, 0xffff);

defer a.deinit();

try a.shiftLeftSat(&a, 16, .unsigned, 21);

try testing.expect((try a.to(u64)) == 0x1fffff);

}

 

var a = try Managed.initSet(testing.allocator, 1);

defer a.deinit();

try a.shiftLeftSat(&a, 16, .unsigned, 21);

try testing.expect((try a.to(u64)) == 0x10000);

}

 

var a = try Managed.initSet(testing.allocator, 16);

defer a.deinit();

try a.shiftLeftSat(&a, @bitSizeOf(DoubleLimb) - 3, .unsigned, @bitSizeOf(DoubleLimb) - 1);

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb) >> 1);

}

 

var a = try Managed.initSet(testing.allocator, 1);

defer a.deinit();

try a.shiftLeftSat(&a, 10, .unsigned, 10);

try testing.expect((try a.to(u10)) == maxInt(u10));

}

 

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

defer a.deinit();

try a.shiftLeftSat(&a, 1, .unsigned, 0);

try testing.expect((try a.to(u64)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, -100);

defer a.deinit();

try a.shiftLeftSat(&a, 0, .unsigned, 0);

try testing.expect((try a.to(u64)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, -100);

defer a.deinit();

try a.shiftLeftSat(&a, 3, .signed, 10);

try testing.expect((try a.to(i10)) == minInt(i10));

}

 

var a = try Managed.initSet(testing.allocator, 100);

defer a.deinit();

try a.shiftLeftSat(&a, 3, .signed, 10);

try testing.expect((try a.to(i10)) == maxInt(i10));

}

 

if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

 

var x: SignedDoubleLimb = 1;

try testing.expect((try a.to(SignedDoubleLimb)) == x <<| shift);

}

 

if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

 

var x: SignedDoubleLimb = -1;

try testing.expect((try a.to(SignedDoubleLimb)) == x <<| shift);

}

 

var x: u10 = 123;

_ = &x;

 

try testing.expect((try a.to(u10)) == ~x);

}

 

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

defer a.deinit();

 

try testing.expect((try a.to(DoubleLimb)) == maxInt(DoubleLimb));

}

 

var x: i11 = -456;

_ = &x;

 

try testing.expect((try a.to(i11)) == ~x);

}

 

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

defer a.deinit();

 

try testing.expect((try a.to(SignedDoubleLimb)) == -1);

}

 

// This test requires int sizes greater than 128 bits.

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

try testing.expectEqual((try res.to(Signed)), ~@as(Signed, maxInt(Limb)));

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xeeeeeeee22222222);

try testing.expect((try a.to(u64)) == 0xeeeeeeee00000000);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, maxInt(Limb));

try testing.expect((try a.to(u128)) == 0);

}

 

var a = try Managed.initSet(testing.allocator, -0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xeeeeeeee22222222);

try testing.expect((try a.to(u64)) == 0x22222222);

}

 

var a = try Managed.initSet(testing.allocator, -maxInt(Limb) - 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, maxInt(Limb));

try testing.expect(a.eqlZero());

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xeeeeeeee22222222);

try testing.expect((try a.to(u64)) == 0x1111111111111110);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -maxInt(Limb) - 1);

try testing.expect(a.eqlZero());

}

 

var a = try Managed.initSet(testing.allocator, -0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xeeeeeeee22222222);

try testing.expect((try a.to(i128)) == -0xffffffff33333332);

}

 

var a = try Managed.initSet(testing.allocator, -maxInt(Limb) - 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -maxInt(Limb) - 2);

try testing.expect((try a.to(i128)) == -maxInt(Limb) * 2 - 2);

}

 

var a = try Managed.initSet(testing.allocator, -maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -2);

try testing.expect((try a.to(SignedDoubleLimb)) == -maxInt(Limb) - 1);

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xeeeeeeee22222222);

try testing.expect((try a.to(u64)) == 0x1111111133333333);

}

 

var x: DoubleLimb = maxInt(Limb) + 1;

var y: DoubleLimb = maxInt(Limb);

_ = .{ &x, &y };

try testing.expect((try a.to(DoubleLimb)) == x ^ y);

}

 

var a = try Managed.initSet(testing.allocator, 0x6b03e381328a3154);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0x45fd3acef9191fad);

try testing.expect((try a.to(i64)) == -0x2efed94fcb932ef9);

}

 

var a = try Managed.initSet(testing.allocator, -0x9849c6e7a10d66d0e4260d4846254c32);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xf2194e7d1c855272a997fcde16f6d5a8);

try testing.expect((try a.to(i128)) == -0x6a50889abd8834a24db1f19650d3999a);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb));

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -1);

try testing.expect((try a.to(SignedDoubleLimb)) == -(maxInt(Limb) + 1));

}

 

var a = try Managed.initSet(testing.allocator, -0x8e48bd5f755ef1f3);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0x4dd4fa576f3046ac);

try testing.expect((try a.to(u64)) == 0xc39c47081a6eb759);

}

 

var a = try Managed.initSet(testing.allocator, -0x684e5da8f500ec8ca7204c33ccc51c9c);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xcb07736a7b62289c78d967c3985eebeb);

try testing.expect((try a.to(u128)) == 0xa3492ec28e62c410dff92bf0549bf771);

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xeeeeeeee22222222);

try testing.expect((try a.to(u64)) == 0xffffffff33333333);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, maxInt(Limb));

try testing.expect((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) + maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, -0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xeeeeeeee22222222);

try testing.expect((try a.to(i64)) == -0x1111111111111111);

}

 

var a = try Managed.initSet(testing.allocator, -maxInt(Limb) - 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 1);

try testing.expect((try a.to(SignedDoubleLimb)) == -maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xeeeeeeee22222222);

try testing.expect((try a.to(i64)) == -0x22222221);

}

 

var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -1);

try testing.expect((try a.to(SignedDoubleLimb)) == -1);

}

 

var a = try Managed.initSet(testing.allocator, -0xffffffff11111111);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -0xeeeeeeee22222222);

try testing.expect((try a.to(i128)) == -0xeeeeeeee00000001);

}

 

var a = try Managed.initSet(testing.allocator, -maxInt(Limb) - 1);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, -maxInt(Limb));

try testing.expect((try a.to(SignedDoubleLimb)) == -maxInt(Limb));

}

 

var a = try Managed.initSet(testing.allocator, 5);

defer a.deinit();

 

try testing.expect(a.order(d) != .gt);

}

 

var a = try Managed.initSet(testing.allocator, 17);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 97);

try testing.expect((try r.to(u32)) == 1);

}

 

var a = try Managed.initSet(testing.allocator, 4864);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 3458);

try testing.expect((try r.to(u32)) == 38);

}

 

var a = try Managed.initSet(testing.allocator, 0xffffffffffffffff);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 0xffffffffffffffff7777);

try testing.expect((try r.to(u32)) == 4369);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);

try testing.expect(answer == 0xf000000ff00000fff0000ffff000fffff00ffffff1);

}

 

var a = try Managed.initSet(testing.allocator, 1897056385327307);

defer a.deinit();

var b = try Managed.initSet(testing.allocator, 2251799813685248);

try testing.expect((try r.to(u64)) == 1);

}

 

const allocator = testing.allocator;

const limbs_buf = try allocator.alloc(Limb, 8);

defer allocator.free(limbs_buf);

try testing.expect(a.toConst().eql(a_managed.toConst()));

}

 

var a = try Managed.initSet(testing.allocator, 123423453456);

defer a.deinit();

 

try testing.expect(a.toConst().eql(b.toConst()));

}

 

{

var a = try Managed.initSet(testing.allocator, -3);

defer a.deinit();

}

}

 

var r = try Managed.init(testing.allocator);

defer r.deinit();

var a = try Managed.init(testing.allocator);

try testing.expectEqual(@as(i32, 0x100_0000), try r.to(i32));

}

 

// Note these happen to be two consecutive Fibonacci sequence numbers, the

// first two whose sum exceeds 2**64.

var a = try Managed.initSet(testing.allocator, 7540113804746346429);

try testing.expect(a.toConst().orderAgainstScalar(19740274219868223167) == .eq);

}

 

// Note these happen to be two consecutive Fibonacci sequence numbers, the

// second of which is the first such number to exceed 2**192.

var a = try Managed.initSet(testing.allocator, 5611500259351924431073312796924978741056961814867751431689);

try byteSwapTest(i48, 0x123456789abc, @as(i48, @bitCast(@as(u48, 0xbc9a78563412))));

}

 

var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));

defer a.deinit();

 

}

}

 

var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));

defer a.deinit();

 

}

}

 

var zero = try Managed.init(testing.allocator);

defer zero.deinit();

try zero.setString(10, "0");

}

}

 

const a = std.math.big.int.Const{

.limbs = &.{0},

.positive = true,

try std.testing.expectEqual(std.math.Order.eq, a.order(b));

}

 

const allocator = testing.allocator;

var a = try Managed.initSet(allocator, 1);

defer a.deinit();

try testing.expectEqual(@as(i32, 0), try res.to(i32));

}

 

const allocator = testing.allocator;

var a = try Managed.initSet(allocator, 1);

defer a.deinit();

try testing.expectError(error.SqrtOfNegativeNumber, res.sqrt(&a));

}

 

const allocator = testing.allocator;

var a = try Managed.initSet(allocator, 1);

defer a.deinit();

 

}

}

 

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

defer a.deinit();

 

try testing.expect(a5 == 0x11112222333344441234567887654321);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(i32)) == 1);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(u128)) == 70368744177664);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(u128)) == 100000000000000000000000000000000000);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.toFloat(f64)) == 72.141593120712409172417410926841290461290467124);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var prng = std.Random.DefaultPrng.init(0x5EED);

}

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(u32)) == 1);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(i32)) == 1);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

 

try testing.expect((try a.q.to(i32)) == 1);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try b.q.to(u32)) == 23);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.order(b)) == .eq);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.orderAbs(b)) == .lt);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.order(b)) == .eq);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.order(r)) == .eq);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.order(r)) == .eq);

}

 

var a = try Rational.init(testing.allocator);

defer a.deinit();

var b = try Rational.init(testing.allocator);

try testing.expect((try a.order(r)) == .eq);

}

 

{

var a = try Rational.init(testing.allocator);

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)));

try expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon));

}

 

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

try expect(@as(u32, @bitCast(cbrt32(-0.0))) == @as(u32, 0x80000000));

try expect(math.isPositiveInf(cbrt32(math.inf(f32))));

try expect(math.isNan(cbrt32(math.nan(f32))));

}

 

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

try expect(math.isNegativeZero(cbrt64(-0.0)));

try expect(math.isPositiveInf(cbrt64(math.inf(f64))));

 

 

const epsilon = 0.0001;

 

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

const b = Complex(f32).init(2, 7);

const c = a.add(b);

try testing.expect(c.re == 7 and c.im == 10);

}

 

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

const b = Complex(f32).init(2, 7);

const c = a.sub(b);

try testing.expect(c.re == 3 and c.im == -4);

}

 

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

const b = Complex(f32).init(2, 7);

const c = a.mul(b);

try testing.expect(c.re == -11 and c.im == 41);

}

 

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

const b = Complex(f32).init(2, 7);

const c = a.div(b);

math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon));

}

 

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

const c = a.conjugate();

 

try testing.expect(c.re == 5 and c.im == -3);

}

 

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

const c = a.neg();

 

try testing.expect(c.re == -5 and c.im == -3);

}

 

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

const c = a.mulbyi();

 

try testing.expect(c.re == -3 and c.im == 5);

}

 

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

const c = a.reciprocal();

 

math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon));

}

 

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

const c = a.magnitude();

 

 

 

const epsilon = 0.0001;

 

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

const c = abs(a);

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

 

 

const epsilon = 0.0001;

 

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

const c = acos(a);

 

 

 

const epsilon = 0.0001;

 

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

const c = acosh(a);

 

 

 

const epsilon = 0.0001;

 

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

const c = arg(a);

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

 

 

const epsilon = 0.0001;

 

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

const c = asin(a);

 

 

 

const epsilon = 0.0001;

 

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

const c = asinh(a);

 

 

 

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 @as(T, @bitCast(mag | sgn));

}

 

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);

 

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(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon));

}

 

try expect(cosh32(0.0) == 1.0);

try expect(cosh32(-0.0) == 1.0);

try expect(math.isPositiveInf(cosh32(math.inf(f32))));

try expect(math.isNan(cosh32(math.nan(f32))));

}

 

try expect(cosh64(0.0) == 1.0);

try expect(cosh64(-0.0) == 1.0);

try expect(math.isPositiveInf(cosh64(math.inf(f64))));

 

}

}

 

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)));

try expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon));

}

 

try expect(math.isPositiveInf(expm1_32(math.inf(f32))));

try expect(expm1_32(-math.inf(f32)) == -1.0);

try expect(math.isNan(expm1_32(math.nan(f32))));

}

 

try expect(math.isPositiveInf(expm1_64(math.inf(f64))));

try expect(expm1_64(-math.inf(f64)) == -1.0);

try expect(math.isNan(expm1_64(math.nan(f64))));

 

}

}

 

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| {

try expect(std.math.isNan(gamma(T, -std.math.nan(T))));

try expect(std.math.isNan(gamma(T, std.math.nan(T))));

}

}

 

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

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

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

}

}

 

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

try expect(std.math.isNan(lgamma(T, -std.math.nan(T))));

try expect(std.math.isNan(lgamma(T, std.math.nan(T))));

 

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));

try expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon));

}

 

try expect(math.isPositiveInf(hypot32(math.inf(f32), 0.0)));

try expect(math.isPositiveInf(hypot32(-math.inf(f32), 0.0)));

try expect(math.isPositiveInf(hypot32(0.0, math.inf(f32))));

try expect(math.isNan(hypot32(0.0, math.nan(f32))));

}

 

try expect(math.isPositiveInf(hypot64(math.inf(f64), 0.0)));

try expect(math.isPositiveInf(hypot64(-math.inf(f64), 0.0)));

try expect(math.isPositiveInf(hypot64(0.0, math.inf(f64))));

 

return @as(TBits, @bitCast(x)) & remove_sign < @as(TBits, @bitCast(math.inf(T)));

}

 

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

// normals

try expect(isFinite(@as(T, 1.0)));

 

return x == -math.inf(@TypeOf(x));

}

 

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

try expect(!isInf(@as(T, 0.0)));

try expect(!isInf(@as(T, -0.0)));

}

}

 

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

try expect(!isPositiveInf(@as(T, 0.0)));

try expect(!isPositiveInf(@as(T, -0.0)));

}

}

 

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

try expect(!isNegativeInf(@as(T, 0.0)));

try expect(!isNegativeInf(@as(T, -0.0)));

 

return isNan(x) and (@as(U, @bitCast(x)) & quiet_signal_bit_mask == 0);

}

 

inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {

try expect(isNan(math.nan(T)));

try expect(isNan(-math.nan(T)));

}

}

 

inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {

// TODO: Signalling NaN values get converted to quiet NaN values in

// some cases where they shouldn't such that this can fail.

 

return value & remove_sign >= (increment_exp << 1);

}

 

// TODO add `c_longdouble' when math.inf(T) supports it

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

const TBits = std.meta.Int(.unsigned, @bitSizeOf(T));

 

}

}

 

// subnormals

try expect(ldexp(@as(f16, 0x1.1FFp14), -14 - 9 - 15) == math.floatTrueMin(f16));

try expect(ldexp(@as(f32, 0x1.3FFFFFp-1), -126 - 22) == math.floatTrueMin(f32));

 

}

}

 

try expect(log(u8, 2, 0x1) == 0);

try expect(log(u8, 2, 0x2) == 1);

try expect(log(u16, 2, 0x72) == 6);

try expect(log(u64, 2, 0x7FF0123456789ABC) == 62);

}

 

const epsilon = 0.000001;

 

try expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon));

try expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));

}

 

try expect(log(f32, 2, 0.2301974) == math.log2(@as(f32, 0.2301974)));

try expect(log(f32, 10, 0.2301974) == math.log10(@as(f32, 0.2301974)));

 

 

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));

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

}

 

try expect(math.isPositiveInf(log1p_32(math.inf(f32))));

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

try expect(math.isNegativeZero(log1p_32(-0.0)));

try expect(math.isNan(log1p_32(math.nan(f32))));

}

 

try expect(math.isPositiveInf(log1p_64(math.inf(f64))));

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

try expect(math.isNegativeZero(log1p_64(-0.0)));

 

}

}

 

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

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

 

 

return exponent;

}

 

// Test all unsigned integers with 2, 3, ..., 64 bits.

// We cannot test 0 or 1 bits since base must be > 1.

inline for (2..64 + 1) |bits| {

}

}

 

const types = [_]type{ u2, u3, u4, u8, u16 };

inline for (types) |T| {

var n: T = 0;

}

}

 

const types = [_]type{ u4, u5, u6, u8, u16 };

inline for (types) |T| {

var n: T = 0;

}

}

 

const x = 59049; // 9 ** 5;

comptime {

if (math.log_int(comptime_int, 9, x) != 5) {

 

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;

 

try expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon));

}

 

var r: modf32_result = undefined;

 

r = modf32(math.inf(f32));

try expect(math.isNan(r.ipart) and math.isNan(r.fpart));

}

 

var r: modf64_result = undefined;

 

r = modf64(math.inf(f64));

 

}

}

 

try expect(nextAfter(i0, 0, 0) == 0);

try expect(nextAfter(u0, 0, 0) == 0);

try expect(nextAfter(i1, 0, 0) == 0);

}

}

 

@setEvalBranchQuota(2000);

 

// normal -> normal

 

return r.fpart == 0.0 and @as(i64, @intFromFloat(r.ipart)) & 1 == 1;

}

 

try expect(isOddInteger(math.maxInt(i64) * 2) == false);

try expect(isOddInteger(math.maxInt(i64) * 2 + 1) == false);

try expect(isOddInteger(1 << 53) == false);

try expect(isOddInteger(15.0) == true);

}

 

const epsilon = 0.000001;

 

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

try expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon));

}

 

const epsilon = 0.000001;

 

try expect(pow(f32, 4, 0.0) == 1.0);

try expect(math.isNan(pow(f32, -12.4, 78.5)));

}

 

try expect(math.isPositiveInf(pow(f64, 2, 1 << 32)));

try expect(pow(f64, 2, -(1 << 32)) == 0);

try expect(math.isNegativeInf(pow(f64, -2, (1 << 32) + 1)));

 

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));

try testing.expectError(error.Underflow, powi(i42, 34, -6));

}

 

try testing.expectError(error.Overflow, powi(i8, -2, 8));

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

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

try testing.expect((try powi(u42, 34, 0)) == 1);

}

 

try testing.expectError(error.Overflow, powi(u0, 0, 0));

try testing.expectError(error.Overflow, powi(i0, 0, 0));

try testing.expectError(error.Overflow, powi(i1, 0, 0));

 

/// Zig only supports binary base IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.

pub const scalbn = @import("ldexp.zig").ldexp;

 

// Verify we are using base 2.

try expect(scalbn(@as(f16, 1.5), 4) == 24.0);

try expect(scalbn(@as(f32, 1.5), 4) == 24.0);

 

return @as(TBits, @bitCast(x)) >> (@bitSizeOf(T) - 1) != 0;

}

 

inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {

try expect(!signbit(@as(T, 0.0)));

try expect(!signbit(@as(T, 1.0)));

 

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));

try expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon));

}

 

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

try expect(math.isNegativeZero(sinh32(-0.0)));

try expect(math.isPositiveInf(sinh32(math.inf(f32))));

try expect(math.isNan(sinh32(math.nan(f32))));

}

 

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

try expect(math.isNegativeZero(sinh64(-0.0)));

try expect(math.isPositiveInf(sinh64(math.inf(f64))));

 

}

}

 

try expect(sqrt_int(u32, 3) == 1);

try expect(sqrt_int(u32, 4) == 2);

try expect(sqrt_int(u32, 5) == 2);

 

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));

try expect(math.approxEqAbs(f64, tanh64(-37.45), -1.0, epsilon));

}

 

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

try expect(math.isNegativeZero(tanh32(-0.0)));

try expect(tanh32(math.inf(f32)) == 1.0);

try expect(math.isNan(tanh32(math.nan(f32))));

}

 

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

try expect(math.isNegativeZero(tanh64(-0.0)));

try expect(tanh64(math.inf(f64)) == 1.0);

 

}

}

 

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,

 

thread_id.* = Thread.getCurrentId();

}

 

if (builtin.single_threaded) return error.SkipZigTest;

 

var thread_current_id: Thread.Id = undefined;

 

 

const PDQ = PriorityDequeue(u32, void, lessThanComparison);

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 54), queue.removeMin());

}

 

const S = struct {

size: u32,

};

try expectEqual(@as(u32, 54), queue.removeMin().size);

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 7), queue.removeMax());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 2), queue.removeMin());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.removeMax());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.removeMaxOrNull() == null);

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 9), queue.removeMin());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 2), queue.removeMax());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.peekMin().? == 2);

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.peekMax().? == 9);

}

 

var queue = PDQ.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 };

}

}

 

var queue = PDQ.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 };

}

}

 

var queue = PDQ.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 };

}

}

 

var queue = PDQ.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 };

}

}

 

const items = [0]u32{};

const queue_items = try testing.allocator.dupe(u32, &items);

var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});

try expect(queue.removeMinOrNull() == null);

}

 

const items = [1]u32{1};

const queue_items = try testing.allocator.dupe(u32, &items);

var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});

try expect(queue.removeMinOrNull() == null);

}

 

const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };

const queue_items = try testing.allocator.dupe(u32, items[0..]);

var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});

}

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 5), queue.removeMin());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 5), queue.removeMin());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.removeMax());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.removeMax());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectError(error.ElementNotFound, queue.update(1, 1));

}

 

var queue = PDQ.init(testing.allocator, {});

var map = std.AutoHashMap(u32, void).init(testing.allocator);

defer {

try expectEqual(@as(usize, 0), map.count());

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(queue.removeMinOrNull(), null);

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(it.next(), null);

}

 

var queue = PDQ.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.removeMaxOrNull() == null);

}

 

var prng = std.Random.DefaultPrng.init(0x12345678);

const random = prng.random();

 

}

}

 

var prng = std.Random.DefaultPrng.init(0x87654321);

const random = prng.random();

 

}

}

 

var prng = std.Random.DefaultPrng.init(0x87654321);

const random = prng.random();

 

 

const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);

 

const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };

 

var queue = CPDQ.init(testing.allocator, context[0..]);

 

var all_cmps_unique = true;

 

var depq = PriorityDequeue(u32, void, struct {

fn uniqueLessThan(_: void, a: u32, b: u32) Order {

all_cmps_unique = all_cmps_unique and (a != b);

 

const PQlt = PriorityQueue(u32, void, lessThan);

const PQgt = PriorityQueue(u32, void, greaterThan);

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 54), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 2), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.removeOrNull() == null);

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 9), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 2), queue.peek().?);

}

 

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 };

}

}

 

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 };

}

}

 

const items = [0]u32{};

const queue_items = try testing.allocator.dupe(u32, &items);

var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});

try expect(queue.removeOrNull() == null);

}

 

const items = [1]u32{1};

const queue_items = try testing.allocator.dupe(u32, &items);

var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});

try expect(queue.removeOrNull() == null);

}

 

const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };

const heap_items = try testing.allocator.dupe(u32, items[0..]);

var queue = PQlt.fromOwnedSlice(testing.allocator, heap_items[0..], {});

}

}

 

var queue = PQgt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 7), queue.remove());

}

 

var queue = PQgt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

var map = std.AutoHashMap(u32, void).init(testing.allocator);

defer {

try expectEqual(@as(usize, 0), map.count());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(queue.removeOrNull(), null);

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(it.next(), null);

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expect(queue.removeOrNull() == null);

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 5), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 5), queue.remove());

}

 

var queue = PQgt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.remove());

}

 

var queue = PQgt.init(testing.allocator, {});

defer queue.deinit();

 

try expectEqual(@as(u32, 1), queue.remove());

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

try expectError(error.ElementNotFound, queue.update(1, 1));

}

 

var queue = PQlt.init(testing.allocator, {});

defer queue.deinit();

 

 

const CPQlt = PriorityQueue(usize, []const u32, contextLessThan);

 

const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };

 

var queue = CPQlt.init(testing.allocator, context[0..]);

 

};

}

 

try testSegmentedList(0);

try testSegmentedList(1);

try testSegmentedList(2);

try list.setCapacity(testing.allocator, 0);

}

 

var list = SegmentedList(i32, 1){};

defer list.deinit(testing.allocator);

 

 

const TestTreap = Treap(u64, std.math.order);

const TestNode = TestTreap.Node;

 

var treap = TestTreap{};

var nodes: [10]TestNode = undefined;

 

 

return @intFromEnum(op);

}

 

// Ensure our opcodes values remain intact as certain values are skipped due to them being reserved

const i32_const = opcode(.i32_const);

const end = opcode(.end);

return @intFromEnum(value);

}

 

const _i32 = valtype(.i32);

const _i64 = valtype(.i64);

const _f32 = valtype(.f32);