From b61e53cc40869504ea75fcfd90379f7d3048b82d Mon Sep 17 00:00:00 2001 From: daurnimator Date: Fri, 14 Feb 2020 18:59:07 +1100 Subject: [PATCH 1/4] std: bigint.deinit() shouldn't need a mutable pointer --- lib/std/math/big/int.zig | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig index 7d8d3a195b..e85e8d292d 100644 --- a/lib/std/math/big/int.zig +++ b/lib/std/math/big/int.zig @@ -137,10 +137,9 @@ pub const Int = struct { } /// Frees all memory associated with an Int. - pub fn deinit(self: *Int) void { + pub fn deinit(self: Int) void { self.assertWritable(); self.allocator.?.free(self.limbs); - self.* = undefined; } /// Clones an Int and returns a new Int with the same value. The new Int is a deep copy and From f20ba7c32c1b06104dd91c0c654ac1d0fc0a9c1e Mon Sep 17 00:00:00 2001 From: daurnimator Date: Fri, 14 Feb 2020 18:59:25 +1100 Subject: [PATCH 2/4] std: increase memory available to testing allocator --- lib/std/testing.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/std/testing.zig b/lib/std/testing.zig index 8a4491d1d7..348f651a88 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -12,7 +12,7 @@ pub var allocator_instance = LeakCountAllocator.init(&base_allocator_instance.al pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator; pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]); -var allocator_mem: [512 * 1024]u8 = undefined; +var allocator_mem: [1024 * 1024]u8 = undefined; /// This function is intended to be used only in tests. It prints diagnostics to stderr /// and then aborts when actual_error_union is not expected_error. From ca41567924d0576be9a000076d29ec5f46a93e95 Mon Sep 17 00:00:00 2001 From: daurnimator Date: Fri, 14 Feb 2020 18:59:40 +1100 Subject: [PATCH 3/4] std: use testing.allocator in big int tests --- lib/std/math/big/int.zig | 732 ++++++++++++++++++++++++++------------- 1 file changed, 487 insertions(+), 245 deletions(-) diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig index e85e8d292d..d42d9fc676 100644 --- a/lib/std/math/big/int.zig +++ b/lib/std/math/big/int.zig @@ -1360,13 +1360,10 @@ pub const Int = struct { // They will still run on larger than this and should pass, but the multi-limb code-paths // may be untested in some cases. -var buffer: [64 * 8192]u8 = undefined; -var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]); -const al = &fixed.allocator; - test "big.int comptime_int set" { comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab; - var a = try Int.initSet(al, s); + var a = try Int.initSet(testing.allocator, s); + defer a.deinit(); const s_limb_count = 128 / Limb.bit_count; @@ -1380,39 +1377,45 @@ test "big.int comptime_int set" { } test "big.int comptime_int set negative" { - var a = try Int.initSet(al, -10); + var a = try Int.initSet(testing.allocator, -10); + defer a.deinit(); testing.expect(a.limbs[0] == 10); testing.expect(a.isPositive() == false); } test "big.int int set unaligned small" { - var a = try Int.initSet(al, @as(u7, 45)); + var a = try Int.initSet(testing.allocator, @as(u7, 45)); + defer a.deinit(); testing.expect(a.limbs[0] == 45); testing.expect(a.isPositive() == true); } test "big.int comptime_int to" { - const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab); + const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab); + defer a.deinit(); testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab); } test "big.int sub-limb to" { - const a = try Int.initSet(al, 10); + const a = try Int.initSet(testing.allocator, 10); + defer a.deinit(); testing.expect((try a.to(u8)) == 10); } test "big.int to target too small error" { - const a = try Int.initSet(al, 0xffffffff); + const a = try Int.initSet(testing.allocator, 0xffffffff); + defer a.deinit(); testing.expectError(error.TargetTooSmall, a.to(u8)); } test "big.int normalize" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); try a.ensureCapacity(8); a.limbs[0] = 1; @@ -1439,7 +1442,8 @@ test "big.int normalize" { } test "big.int normalize multi" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); try a.ensureCapacity(8); a.limbs[0] = 1; @@ -1468,7 +1472,9 @@ test "big.int normalize multi" { } test "big.int parity" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); + try a.set(0); testing.expect(a.isEven()); testing.expect(!a.isOdd()); @@ -1479,7 +1485,8 @@ test "big.int parity" { } test "big.int bitcount + sizeInBase" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); try a.set(0b100); testing.expect(a.bitCountAbs() == 3); @@ -1506,7 +1513,8 @@ test "big.int bitcount + sizeInBase" { } test "big.int bitcount/to" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); try a.set(0); testing.expect(a.bitCountTwosComp() == 0); @@ -1536,7 +1544,8 @@ test "big.int bitcount/to" { } test "big.int fits" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); try a.set(0); testing.expect(a.fits(u0)); @@ -1563,82 +1572,100 @@ test "big.int fits" { } test "big.int string set" { - var a = try Int.init(al); - try a.setString(10, "120317241209124781241290847124"); + var a = try Int.init(testing.allocator); + defer a.deinit(); + try a.setString(10, "120317241209124781241290847124"); testing.expect((try a.to(u128)) == 120317241209124781241290847124); } test "big.int string negative" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); + try a.setString(10, "-1023"); testing.expect((try a.to(i32)) == -1023); } test "big.int string set bad char error" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); testing.expectError(error.InvalidCharForDigit, a.setString(10, "x")); } test "big.int string set bad base error" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); testing.expectError(error.InvalidBase, a.setString(45, "10")); } test "big.int string to" { - const a = try Int.initSet(al, 120317241209124781241290847124); + const a = try Int.initSet(testing.allocator, 120317241209124781241290847124); + defer a.deinit(); - const as = try a.toString(al, 10); + const as = try a.toString(testing.allocator, 10); + defer testing.allocator.free(as); const es = "120317241209124781241290847124"; testing.expect(mem.eql(u8, as, es)); } test "big.int string to base base error" { - const a = try Int.initSet(al, 0xffffffff); + const a = try Int.initSet(testing.allocator, 0xffffffff); + defer a.deinit(); - testing.expectError(error.InvalidBase, a.toString(al, 45)); + testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45)); } test "big.int string to base 2" { - const a = try Int.initSet(al, -0b1011); + const a = try Int.initSet(testing.allocator, -0b1011); + defer a.deinit(); - const as = try a.toString(al, 2); + const as = try a.toString(testing.allocator, 2); + defer testing.allocator.free(as); const es = "-1011"; testing.expect(mem.eql(u8, as, es)); } test "big.int string to base 16" { - const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab); + const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab); + defer a.deinit(); - const as = try a.toString(al, 16); + const as = try a.toString(testing.allocator, 16); + defer testing.allocator.free(as); const es = "efffffff00000001eeeeeeefaaaaaaab"; testing.expect(mem.eql(u8, as, es)); } test "big.int neg string to" { - const a = try Int.initSet(al, -123907434); + const a = try Int.initSet(testing.allocator, -123907434); + defer a.deinit(); - const as = try a.toString(al, 10); + const as = try a.toString(testing.allocator, 10); + defer testing.allocator.free(as); const es = "-123907434"; testing.expect(mem.eql(u8, as, es)); } test "big.int zero string to" { - const a = try Int.initSet(al, 0); + const a = try Int.initSet(testing.allocator, 0); + defer a.deinit(); - const as = try a.toString(al, 10); + const as = try a.toString(testing.allocator, 10); + defer testing.allocator.free(as); const es = "0"; testing.expect(mem.eql(u8, as, es)); } test "big.int clone" { - var a = try Int.initSet(al, 1234); + var a = try Int.initSet(testing.allocator, 1234); + defer a.deinit(); const b = try a.clone(); + defer b.deinit(); testing.expect((try a.to(u32)) == 1234); testing.expect((try b.to(u32)) == 1234); @@ -1649,8 +1676,10 @@ test "big.int clone" { } test "big.int swap" { - var a = try Int.initSet(al, 1234); - var b = try Int.initSet(al, 5678); + var a = try Int.initSet(testing.allocator, 1234); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5678); + defer b.deinit(); testing.expect((try a.to(u32)) == 1234); testing.expect((try b.to(u32)) == 5678); @@ -1662,53 +1691,65 @@ test "big.int swap" { } test "big.int to negative" { - var a = try Int.initSet(al, -10); + var a = try Int.initSet(testing.allocator, -10); + defer a.deinit(); testing.expect((try a.to(i32)) == -10); } test "big.int compare" { - var a = try Int.initSet(al, -11); - var b = try Int.initSet(al, 10); + var a = try Int.initSet(testing.allocator, -11); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 10); + defer b.deinit(); testing.expect(a.cmpAbs(b) == 1); testing.expect(a.cmp(b) == -1); } test "big.int compare similar" { - var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee); - var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef); + var a = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef); + defer b.deinit(); testing.expect(a.cmpAbs(b) == -1); testing.expect(b.cmpAbs(a) == 1); } test "big.int compare different limb size" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, 1); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 1); + defer b.deinit(); testing.expect(a.cmpAbs(b) == 1); testing.expect(b.cmpAbs(a) == -1); } test "big.int compare multi-limb" { - var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef); - var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee); + var a = try Int.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee); + defer b.deinit(); testing.expect(a.cmpAbs(b) == 1); testing.expect(a.cmp(b) == -1); } test "big.int equality" { - var a = try Int.initSet(al, 0xffffffff1); - var b = try Int.initSet(al, -0xffffffff1); + var a = try Int.initSet(testing.allocator, 0xffffffff1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, -0xffffffff1); + defer b.deinit(); testing.expect(a.eqAbs(b)); testing.expect(!a.eq(b)); } test "big.int abs" { - var a = try Int.initSet(al, -5); + var a = try Int.initSet(testing.allocator, -5); + defer a.deinit(); a.abs(); testing.expect((try a.to(u32)) == 5); @@ -1718,7 +1759,8 @@ test "big.int abs" { } test "big.int negate" { - var a = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 5); + defer a.deinit(); a.negate(); testing.expect((try a.to(i32)) == -5); @@ -1728,20 +1770,26 @@ test "big.int negate" { } test "big.int add single-single" { - var a = try Int.initSet(al, 50); - var b = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 50); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.add(a, b); testing.expect((try c.to(u32)) == 55); } test "big.int add multi-single" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, 1); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 1); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.add(a, b); testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); @@ -1753,20 +1801,26 @@ test "big.int add multi-single" { test "big.int add multi-multi" { const op1 = 0xefefefef7f7f7f7f; const op2 = 0xfefefefe9f9f9f9f; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.add(a, b); testing.expect((try c.to(u128)) == op1 + op2); } test "big.int add zero-zero" { - var a = try Int.initSet(al, 0); - var b = try Int.initSet(al, 0); + var a = try Int.initSet(testing.allocator, 0); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.add(a, b); testing.expect((try c.to(u32)) == 0); @@ -1774,8 +1828,10 @@ test "big.int add zero-zero" { test "big.int add alias multi-limb nonzero-zero" { const op1 = 0xffffffff777777771; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, 0); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0); + defer b.deinit(); try a.add(a, b); @@ -1783,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" { } test "big.int add sign" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); - const one = try Int.initSet(al, 1); - const two = try Int.initSet(al, 2); - const neg_one = try Int.initSet(al, -1); - const neg_two = try Int.initSet(al, -2); + const one = try Int.initSet(testing.allocator, 1); + defer one.deinit(); + const two = try Int.initSet(testing.allocator, 2); + defer two.deinit(); + const neg_one = try Int.initSet(testing.allocator, -1); + defer neg_one.deinit(); + const neg_two = try Int.initSet(testing.allocator, -2); + defer neg_two.deinit(); try a.add(one, two); testing.expect((try a.to(i32)) == 3); @@ -1804,20 +1865,26 @@ test "big.int add sign" { } test "big.int sub single-single" { - var a = try Int.initSet(al, 50); - var b = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 50); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.sub(a, b); testing.expect((try c.to(u32)) == 45); } test "big.int sub multi-single" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, 1); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 1); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.sub(a, b); testing.expect((try c.to(Limb)) == maxInt(Limb)); @@ -1827,32 +1894,43 @@ test "big.int sub multi-multi" { const op1 = 0xefefefefefefefefefefefef; const op2 = 0xabababababababababababab; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.sub(a, b); testing.expect((try c.to(u128)) == op1 - op2); } test "big.int sub equal" { - var a = try Int.initSet(al, 0x11efefefefefefefefefefefef); - var b = try Int.initSet(al, 0x11efefefefefefefefefefefef); + var a = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.sub(a, b); testing.expect((try c.to(u32)) == 0); } test "big.int sub sign" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); - const one = try Int.initSet(al, 1); - const two = try Int.initSet(al, 2); - const neg_one = try Int.initSet(al, -1); - const neg_two = try Int.initSet(al, -2); + const one = try Int.initSet(testing.allocator, 1); + defer one.deinit(); + const two = try Int.initSet(testing.allocator, 2); + defer two.deinit(); + const neg_one = try Int.initSet(testing.allocator, -1); + defer neg_one.deinit(); + const neg_two = try Int.initSet(testing.allocator, -2); + defer neg_two.deinit(); try a.sub(one, two); testing.expect((try a.to(i32)) == -1); @@ -1871,20 +1949,26 @@ test "big.int sub sign" { } test "big.int mul single-single" { - var a = try Int.initSet(al, 50); - var b = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 50); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.mul(a, b); testing.expect((try c.to(u64)) == 250); } test "big.int mul multi-single" { - var a = try Int.initSet(al, maxInt(Limb)); - var b = try Int.initSet(al, 2); + var a = try Int.initSet(testing.allocator, maxInt(Limb)); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 2); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.mul(a, b); testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb)); @@ -1893,18 +1977,23 @@ test "big.int mul multi-single" { test "big.int mul multi-multi" { const op1 = 0x998888efefefefefefefef; const op2 = 0x333000abababababababab; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.mul(a, b); testing.expect((try c.to(u256)) == op1 * op2); } test "big.int mul alias r with a" { - var a = try Int.initSet(al, maxInt(Limb)); - var b = try Int.initSet(al, 2); + var a = try Int.initSet(testing.allocator, maxInt(Limb)); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 2); + defer b.deinit(); try a.mul(a, b); @@ -1912,8 +2001,10 @@ test "big.int mul alias r with a" { } test "big.int mul alias r with b" { - var a = try Int.initSet(al, maxInt(Limb)); - var b = try Int.initSet(al, 2); + var a = try Int.initSet(testing.allocator, maxInt(Limb)); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 2); + defer b.deinit(); try a.mul(b, a); @@ -1921,7 +2012,8 @@ test "big.int mul alias r with b" { } test "big.int mul alias r with a and b" { - var a = try Int.initSet(al, maxInt(Limb)); + var a = try Int.initSet(testing.allocator, maxInt(Limb)); + defer a.deinit(); try a.mul(a, a); @@ -1929,31 +2021,41 @@ test "big.int mul alias r with a and b" { } test "big.int mul a*0" { - var a = try Int.initSet(al, 0xefefefefefefefef); - var b = try Int.initSet(al, 0); + var a = try Int.initSet(testing.allocator, 0xefefefefefefefef); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.mul(a, b); testing.expect((try c.to(u32)) == 0); } test "big.int mul 0*0" { - var a = try Int.initSet(al, 0); - var b = try Int.initSet(al, 0); + var a = try Int.initSet(testing.allocator, 0); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0); + defer b.deinit(); - var c = try Int.init(al); + var c = try Int.init(testing.allocator); + defer c.deinit(); try c.mul(a, b); testing.expect((try c.to(u32)) == 0); } test "big.int div single-single no rem" { - var a = try Int.initSet(al, 50); - var b = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 50); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u32)) == 10); @@ -1961,11 +2063,15 @@ test "big.int div single-single no rem" { } test "big.int div single-single with rem" { - var a = try Int.initSet(al, 49); - var b = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 49); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u32)) == 9); @@ -1976,11 +2082,15 @@ test "big.int div multi-single no rem" { const op1 = 0xffffeeeeddddcccc; const op2 = 34; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u64)) == op1 / op2); @@ -1991,11 +2101,15 @@ test "big.int div multi-single with rem" { const op1 = 0xffffeeeeddddcccf; const op2 = 34; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u64)) == op1 / op2); @@ -2006,11 +2120,15 @@ test "big.int div multi>2-single" { const op1 = 0xfefefefefefefefefefefefefefefefe; const op2 = 0xefab8; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == op1 / op2); @@ -2018,11 +2136,15 @@ test "big.int div multi>2-single" { } test "big.int div single-single q < r" { - var a = try Int.initSet(al, 0x0078f432); - var b = try Int.initSet(al, 0x01000000); + var a = try Int.initSet(testing.allocator, 0x0078f432); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x01000000); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u64)) == 0); @@ -2030,11 +2152,15 @@ test "big.int div single-single q < r" { } test "big.int div single-single q == r" { - var a = try Int.initSet(al, 10); - var b = try Int.initSet(al, 10); + var a = try Int.initSet(testing.allocator, 10); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 10); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u64)) == 1); @@ -2042,8 +2168,10 @@ test "big.int div single-single q == r" { } test "big.int div q=0 alias" { - var a = try Int.initSet(al, 3); - var b = try Int.initSet(al, 10); + var a = try Int.initSet(testing.allocator, 3); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 10); + defer b.deinit(); try Int.divTrunc(&a, &b, a, b); @@ -2054,11 +2182,15 @@ test "big.int div q=0 alias" { test "big.int div multi-multi q < r" { const op1 = 0x1ffffffff0078f432; const op2 = 0x1ffffffff01000000; - var a = try Int.initSet(al, op1); - var b = try Int.initSet(al, op2); + var a = try Int.initSet(testing.allocator, op1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, op2); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0); @@ -2069,11 +2201,15 @@ test "big.int div trunc single-single +/+" { const u: i32 = 5; const v: i32 = 3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); // n = q * d + r @@ -2089,11 +2225,15 @@ test "big.int div trunc single-single -/+" { const u: i32 = -5; const v: i32 = 3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); // n = q * d + r @@ -2109,11 +2249,15 @@ test "big.int div trunc single-single +/-" { const u: i32 = 5; const v: i32 = -3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); // n = q * d + r @@ -2129,11 +2273,15 @@ test "big.int div trunc single-single -/-" { const u: i32 = -5; const v: i32 = -3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); // n = q * d + r @@ -2149,11 +2297,15 @@ test "big.int div floor single-single +/+" { const u: i32 = 5; const v: i32 = 3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divFloor(&q, &r, a, b); // n = q * d + r @@ -2169,11 +2321,15 @@ test "big.int div floor single-single -/+" { const u: i32 = -5; const v: i32 = 3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divFloor(&q, &r, a, b); // n = q * d + r @@ -2189,11 +2345,15 @@ test "big.int div floor single-single +/-" { const u: i32 = 5; const v: i32 = -3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divFloor(&q, &r, a, b); // n = q * d + r @@ -2209,11 +2369,15 @@ test "big.int div floor single-single -/-" { const u: i32 = -5; const v: i32 = -3; - var a = try Int.initSet(al, u); - var b = try Int.initSet(al, v); + var a = try Int.initSet(testing.allocator, u); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, v); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divFloor(&q, &r, a, b); // n = q * d + r @@ -2226,11 +2390,15 @@ test "big.int div floor single-single -/-" { } test "big.int div multi-multi with rem" { - var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999); - var b = try Int.initSet(al, 0x99990000111122223333); + var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x99990000111122223333); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); @@ -2238,11 +2406,15 @@ test "big.int div multi-multi with rem" { } test "big.int div multi-multi no rem" { - var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361); - var b = try Int.initSet(al, 0x99990000111122223333); + var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x99990000111122223333); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); @@ -2250,11 +2422,15 @@ test "big.int div multi-multi no rem" { } test "big.int div multi-multi (2 branch)" { - var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111); - var b = try Int.initSet(al, 0x86666666555555554444444433333333); + var a = try Int.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x86666666555555554444444433333333); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0x10000000000000000); @@ -2262,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" { } test "big.int div multi-multi (3.1/3.3 branch)" { - var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111); - var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171); + var a = try Int.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0xfffffffffffffffffff); @@ -2274,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" { } test "big.int div multi-single zero-limb trailing" { - var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000); - var b = try Int.initSet(al, 0x10000000000000000); + var a = try Int.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x10000000000000000); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); - var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000); + var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000); + defer expected.deinit(); testing.expect(q.eq(expected)); testing.expect(r.eqZero()); } test "big.int div multi-multi zero-limb trailing (with rem)" { - var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); - var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000); + var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0x10000000000000000); - const rs = try r.toString(al, 16); + const rs = try r.toString(testing.allocator, 16); + defer testing.allocator.free(rs); testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000")); } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" { - var a = try Int.initSet(al, 0x8666666655555555888888877777777611111111111111110000000000000000); - var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000); + var a = try Int.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); testing.expect((try q.to(u128)) == 0x1); - const rs = try r.toString(al, 16); + const rs = try r.toString(testing.allocator, 16); + defer testing.allocator.free(rs); testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000")); } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" { - var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); - var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000); + var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000); + defer b.deinit(); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); - const qs = try q.toString(al, 16); + const qs = try q.toString(testing.allocator, 16); + defer testing.allocator.free(qs); testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f")); - const rs = try r.toString(al, 16); + const rs = try r.toString(testing.allocator, 16); + defer testing.allocator.free(rs); testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000")); } test "big.int div multi-multi fuzz case #1" { - var a = try Int.init(al); - var b = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); + var b = try Int.init(testing.allocator); + defer b.deinit(); try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff"); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); - const qs = try q.toString(al, 16); + const qs = try q.toString(testing.allocator, 16); + defer testing.allocator.free(qs); testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1")); - const rs = try r.toString(al, 16); + const rs = try r.toString(testing.allocator, 16); + defer testing.allocator.free(rs); testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1")); } test "big.int div multi-multi fuzz case #2" { - var a = try Int.init(al); - var b = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); + var b = try Int.init(testing.allocator); + defer b.deinit(); try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000"); try b.setString(16, "ffc0000000000000000000000000000000000000000000000000"); - var q = try Int.init(al); - var r = try Int.init(al); + var q = try Int.init(testing.allocator); + defer q.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try Int.divTrunc(&q, &r, a, b); - const qs = try q.toString(al, 16); + const qs = try q.toString(testing.allocator, 16); + defer testing.allocator.free(qs); testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4")); - const rs = try r.toString(al, 16); + const rs = try r.toString(testing.allocator, 16); + defer testing.allocator.free(rs); testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000")); } test "big.int shift-right single" { - var a = try Int.initSet(al, 0xffff0000); + var a = try Int.initSet(testing.allocator, 0xffff0000); + defer a.deinit(); try a.shiftRight(a, 16); testing.expect((try a.to(u32)) == 0xffff); } test "big.int shift-right multi" { - var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333); + var a = try Int.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333); + defer a.deinit(); try a.shiftRight(a, 67); testing.expect((try a.to(u64)) == 0x1fffe0001dddc222); } test "big.int shift-left single" { - var a = try Int.initSet(al, 0xffff); + var a = try Int.initSet(testing.allocator, 0xffff); + defer a.deinit(); try a.shiftLeft(a, 16); testing.expect((try a.to(u64)) == 0xffff0000); } test "big.int shift-left multi" { - var a = try Int.initSet(al, 0x1fffe0001dddc222); + var a = try Int.initSet(testing.allocator, 0x1fffe0001dddc222); + defer a.deinit(); try a.shiftLeft(a, 67); testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000); } test "big.int shift-right negative" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); - try a.shiftRight(try Int.initSet(al, -20), 2); + try a.shiftRight(try Int.initSet(testing.allocator, -20), 2); + defer a.deinit(); testing.expect((try a.to(i32)) == -20 >> 2); - try a.shiftRight(try Int.initSet(al, -5), 10); + try a.shiftRight(try Int.initSet(testing.allocator, -5), 10); + defer a.deinit(); testing.expect((try a.to(i32)) == -5 >> 10); } test "big.int shift-left negative" { - var a = try Int.init(al); + var a = try Int.init(testing.allocator); + defer a.deinit(); - try a.shiftRight(try Int.initSet(al, -10), 1232); + try a.shiftRight(try Int.initSet(testing.allocator, -10), 1232); + defer a.deinit(); testing.expect((try a.to(i32)) == -10 >> 1232); } test "big.int bitwise and simple" { - var a = try Int.initSet(al, 0xffffffff11111111); - var b = try Int.initSet(al, 0xeeeeeeee22222222); + var a = try Int.initSet(testing.allocator, 0xffffffff11111111); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); + defer b.deinit(); try a.bitAnd(a, b); @@ -2420,8 +2644,10 @@ test "big.int bitwise and simple" { } test "big.int bitwise and multi-limb" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, maxInt(Limb)); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, maxInt(Limb)); + defer b.deinit(); try a.bitAnd(a, b); @@ -2429,8 +2655,10 @@ test "big.int bitwise and multi-limb" { } test "big.int bitwise xor simple" { - var a = try Int.initSet(al, 0xffffffff11111111); - var b = try Int.initSet(al, 0xeeeeeeee22222222); + var a = try Int.initSet(testing.allocator, 0xffffffff11111111); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); + defer b.deinit(); try a.bitXor(a, b); @@ -2438,8 +2666,10 @@ test "big.int bitwise xor simple" { } test "big.int bitwise xor multi-limb" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, maxInt(Limb)); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, maxInt(Limb)); + defer b.deinit(); try a.bitXor(a, b); @@ -2447,8 +2677,10 @@ test "big.int bitwise xor multi-limb" { } test "big.int bitwise or simple" { - var a = try Int.initSet(al, 0xffffffff11111111); - var b = try Int.initSet(al, 0xeeeeeeee22222222); + var a = try Int.initSet(testing.allocator, 0xffffffff11111111); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); + defer b.deinit(); try a.bitOr(a, b); @@ -2456,8 +2688,10 @@ test "big.int bitwise or simple" { } test "big.int bitwise or multi-limb" { - var a = try Int.initSet(al, maxInt(Limb) + 1); - var b = try Int.initSet(al, maxInt(Limb)); + var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, maxInt(Limb)); + defer b.deinit(); try a.bitOr(a, b); @@ -2466,11 +2700,19 @@ test "big.int bitwise or multi-limb" { } test "big.int var args" { - var a = try Int.initSet(al, 5); + var a = try Int.initSet(testing.allocator, 5); + defer a.deinit(); - try a.add(a, try Int.initSet(al, 6)); + const b = try Int.initSet(testing.allocator, 6); + defer b.deinit(); + try a.add(a, b); testing.expect((try a.to(u64)) == 11); - testing.expect(a.cmp(try Int.initSet(al, 11)) == 0); - testing.expect(a.cmp(try Int.initSet(al, 14)) <= 0); + const c = try Int.initSet(testing.allocator, 11); + defer c.deinit(); + testing.expect(a.cmp(c) == 0); + + const d = try Int.initSet(testing.allocator, 14); + defer d.deinit(); + testing.expect(a.cmp(d) <= 0); } From 6ea6d5a4bdcf6f37c43857570522ee1308115de7 Mon Sep 17 00:00:00 2001 From: daurnimator Date: Fri, 14 Feb 2020 19:15:09 +1100 Subject: [PATCH 4/4] std: use testing.allocator in tests --- lib/std/json.zig | 29 +++---- lib/std/json/write_stream.zig | 6 +- lib/std/math/big/rational.zig | 151 ++++++++++++++++++++++------------ lib/std/mem.zig | 44 ++++++---- lib/std/net/test.zig | 4 +- 5 files changed, 147 insertions(+), 87 deletions(-) diff --git a/lib/std/json.zig b/lib/std/json.zig index 1e4f19fda8..74e008d76e 100644 --- a/lib/std/json.zig +++ b/lib/std/json.zig @@ -1598,21 +1598,21 @@ test "write json then parse it" { testing.expect(mem.eql(u8, tree.root.Object.get("str").?.value.String, "hello")); } -fn test_parse(memory: []u8, json_str: []const u8) !Value { - // buf_alloc goes out of scope, but we don't use it after parsing - var buf_alloc = std.heap.FixedBufferAllocator.init(memory); - var p = Parser.init(&buf_alloc.allocator, false); +fn test_parse(arena_allocator: *std.mem.Allocator, json_str: []const u8) !Value { + var p = Parser.init(arena_allocator, false); return (try p.parse(json_str)).root; } test "parsing empty string gives appropriate error" { - var memory: [1024 * 4]u8 = undefined; - testing.expectError(error.UnexpectedEndOfJson, test_parse(&memory, "")); + var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena_allocator.deinit(); + testing.expectError(error.UnexpectedEndOfJson, test_parse(&arena_allocator.allocator, "")); } test "integer after float has proper type" { - var memory: [1024 * 8]u8 = undefined; - const json = try test_parse(&memory, + var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena_allocator.deinit(); + const json = try test_parse(&arena_allocator.allocator, \\{ \\ "float": 3.14, \\ "ints": [1, 2, 3] @@ -1622,7 +1622,8 @@ test "integer after float has proper type" { } test "escaped characters" { - var memory: [1024 * 16]u8 = undefined; + var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena_allocator.deinit(); const input = \\{ \\ "backslash": "\\", @@ -1638,7 +1639,7 @@ test "escaped characters" { \\} ; - const obj = (try test_parse(&memory, input)).Object; + const obj = (try test_parse(&arena_allocator.allocator, input)).Object; testing.expectEqualSlices(u8, obj.get("backslash").?.value.String, "\\"); testing.expectEqualSlices(u8, obj.get("forwardslash").?.value.String, "/"); @@ -1662,13 +1663,13 @@ test "string copy option" { \\} ; - var mem_buffer: [1024 * 16]u8 = undefined; - var buf_alloc = std.heap.FixedBufferAllocator.init(&mem_buffer); + var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena_allocator.deinit(); - const tree_nocopy = try Parser.init(&buf_alloc.allocator, false).parse(input); + const tree_nocopy = try Parser.init(&arena_allocator.allocator, false).parse(input); const obj_nocopy = tree_nocopy.root.Object; - const tree_copy = try Parser.init(&buf_alloc.allocator, true).parse(input); + const tree_copy = try Parser.init(&arena_allocator.allocator, true).parse(input); const obj_copy = tree_copy.root.Object; for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| { diff --git a/lib/std/json/write_stream.zig b/lib/std/json/write_stream.zig index 51afe7fcbc..213b6768d4 100644 --- a/lib/std/json/write_stream.zig +++ b/lib/std/json/write_stream.zig @@ -254,11 +254,11 @@ test "json write stream" { var slice_stream = std.io.SliceOutStream.init(&out_buf); const out = &slice_stream.stream; - var mem_buf: [1024 * 10]u8 = undefined; - const allocator = &std.heap.FixedBufferAllocator.init(&mem_buf).allocator; + var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena_allocator.deinit(); var w = std.json.WriteStream(@TypeOf(out).Child, 10).init(out); - try w.emitJson(try getJson(allocator)); + try w.emitJson(try getJson(&arena_allocator.allocator)); const result = slice_stream.getWritten(); const expected = diff --git a/lib/std/math/big/rational.zig b/lib/std/math/big/rational.zig index 27a3b7300f..438c6c94fc 100644 --- a/lib/std/math/big/rational.zig +++ b/lib/std/math/big/rational.zig @@ -587,14 +587,13 @@ fn gcdLehmer(r: *Int, xa: Int, ya: Int) !void { r.swap(&x); } -var buffer: [64 * 8192]u8 = undefined; -var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]); -var al = &fixed.allocator; - test "big.rational gcd non-one small" { - var a = try Int.initSet(al, 17); - var b = try Int.initSet(al, 97); - var r = try Int.init(al); + var a = try Int.initSet(testing.allocator, 17); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 97); + defer b.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try gcd(&r, a, b); @@ -602,9 +601,12 @@ test "big.rational gcd non-one small" { } test "big.rational gcd non-one small" { - var a = try Int.initSet(al, 4864); - var b = try Int.initSet(al, 3458); - var r = try Int.init(al); + var a = try Int.initSet(testing.allocator, 4864); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 3458); + defer b.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try gcd(&r, a, b); @@ -612,9 +614,12 @@ test "big.rational gcd non-one small" { } test "big.rational gcd non-one large" { - var a = try Int.initSet(al, 0xffffffffffffffff); - var b = try Int.initSet(al, 0xffffffffffffffff7777); - var r = try Int.init(al); + var a = try Int.initSet(testing.allocator, 0xffffffffffffffff); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0xffffffffffffffff7777); + defer b.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try gcd(&r, a, b); @@ -622,9 +627,12 @@ test "big.rational gcd non-one large" { } test "big.rational gcd large multi-limb result" { - var a = try Int.initSet(al, 0x12345678123456781234567812345678123456781234567812345678); - var b = try Int.initSet(al, 0x12345671234567123456712345671234567123456712345671234567); - var r = try Int.init(al); + var a = try Int.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 0x12345671234567123456712345671234567123456712345671234567); + defer b.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try gcd(&r, a, b); @@ -632,9 +640,12 @@ test "big.rational gcd large multi-limb result" { } test "big.rational gcd one large" { - var a = try Int.initSet(al, 1897056385327307); - var b = try Int.initSet(al, 2251799813685248); - var r = try Int.init(al); + var a = try Int.initSet(testing.allocator, 1897056385327307); + defer a.deinit(); + var b = try Int.initSet(testing.allocator, 2251799813685248); + defer b.deinit(); + var r = try Int.init(testing.allocator); + defer r.deinit(); try gcd(&r, a, b); @@ -661,7 +672,8 @@ fn extractLowBits(a: Int, comptime T: type) T { } test "big.rational extractLowBits" { - var a = try Int.initSet(al, 0x11112222333344441234567887654321); + var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321); + defer a.deinit(); const a1 = extractLowBits(a, u8); testing.expect(a1 == 0x21); @@ -680,7 +692,8 @@ test "big.rational extractLowBits" { } test "big.rational set" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); try a.setInt(5); testing.expect((try a.p.to(u32)) == 5); @@ -708,7 +721,8 @@ test "big.rational set" { } test "big.rational setFloat" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); try a.setFloat(f64, 2.5); testing.expect((try a.p.to(i32)) == 5); @@ -732,7 +746,8 @@ test "big.rational setFloat" { } test "big.rational setFloatString" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); try a.setFloatString("72.14159312071241458852455252781510353"); @@ -742,7 +757,8 @@ test "big.rational setFloatString" { } test "big.rational toFloat" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); // = 3.14159297943115234375 try a.setRatio(3294199, 1048576); @@ -754,7 +770,8 @@ test "big.rational toFloat" { } test "big.rational set/to Float round-trip" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); var prng = std.rand.DefaultPrng.init(0x5EED); var i: usize = 0; while (i < 512) : (i += 1) { @@ -765,23 +782,29 @@ test "big.rational set/to Float round-trip" { } test "big.rational copy" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); - const b = try Int.initSet(al, 5); + const b = try Int.initSet(testing.allocator, 5); + defer b.deinit(); try a.copyInt(b); testing.expect((try a.p.to(u32)) == 5); testing.expect((try a.q.to(u32)) == 1); - const c = try Int.initSet(al, 7); - const d = try Int.initSet(al, 3); + const c = try Int.initSet(testing.allocator, 7); + defer c.deinit(); + const d = try Int.initSet(testing.allocator, 3); + defer d.deinit(); try a.copyRatio(c, d); testing.expect((try a.p.to(u32)) == 7); testing.expect((try a.q.to(u32)) == 3); - const e = try Int.initSet(al, 9); - const f = try Int.initSet(al, 3); + const e = try Int.initSet(testing.allocator, 9); + defer e.deinit(); + const f = try Int.initSet(testing.allocator, 3); + defer f.deinit(); try a.copyRatio(e, f); testing.expect((try a.p.to(u32)) == 3); @@ -789,7 +812,8 @@ test "big.rational copy" { } test "big.rational negate" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); try a.setInt(-50); testing.expect((try a.p.to(i32)) == -50); @@ -805,7 +829,8 @@ test "big.rational negate" { } test "big.rational abs" { - var a = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); try a.setInt(-50); testing.expect((try a.p.to(i32)) == -50); @@ -821,8 +846,10 @@ test "big.rational abs" { } test "big.rational swap" { - var a = try Rational.init(al); - var b = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); try a.setRatio(50, 23); try b.setRatio(17, 3); @@ -843,8 +870,10 @@ test "big.rational swap" { } test "big.rational cmp" { - var a = try Rational.init(al); - var b = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); try a.setRatio(500, 231); try b.setRatio(18903, 8584); @@ -856,8 +885,10 @@ test "big.rational cmp" { } test "big.rational add single-limb" { - var a = try Rational.init(al); - var b = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); try a.setRatio(500, 231); try b.setRatio(18903, 8584); @@ -869,9 +900,12 @@ test "big.rational add single-limb" { } test "big.rational add" { - var a = try Rational.init(al); - var b = try Rational.init(al); - var r = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); try a.setRatio(78923, 23341); try b.setRatio(123097, 12441414); @@ -882,9 +916,12 @@ test "big.rational add" { } test "big.rational sub" { - var a = try Rational.init(al); - var b = try Rational.init(al); - var r = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); try a.setRatio(78923, 23341); try b.setRatio(123097, 12441414); @@ -895,9 +932,12 @@ test "big.rational sub" { } test "big.rational mul" { - var a = try Rational.init(al); - var b = try Rational.init(al); - var r = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); try a.setRatio(78923, 23341); try b.setRatio(123097, 12441414); @@ -908,9 +948,12 @@ test "big.rational mul" { } test "big.rational div" { - var a = try Rational.init(al); - var b = try Rational.init(al); - var r = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); try a.setRatio(78923, 23341); try b.setRatio(123097, 12441414); @@ -921,8 +964,10 @@ test "big.rational div" { } test "big.rational div" { - var a = try Rational.init(al); - var r = try Rational.init(al); + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); try a.setRatio(78923, 23341); a.invert(); diff --git a/lib/std/mem.zig b/lib/std/mem.zig index 8f4987e0c9..a1b4a3c809 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -1011,11 +1011,21 @@ pub fn join(allocator: *Allocator, separator: []const u8, slices: []const []cons } test "mem.join" { - var buf: [1024]u8 = undefined; - const a = &std.heap.FixedBufferAllocator.init(&buf).allocator; - testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "b", "c" }), "a,b,c")); - testing.expect(eql(u8, try join(a, ",", &[_][]const u8{"a"}), "a")); - testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "", "b", "", "c" }), "a,,b,,c")); + { + const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "b", "c" }); + defer testing.allocator.free(str); + testing.expect(eql(u8, str, "a,b,c")); + } + { + const str = try join(testing.allocator, ",", &[_][]const u8{"a"}); + defer testing.allocator.free(str); + testing.expect(eql(u8, str, "a")); + } + { + const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "", "b", "", "c" }); + defer testing.allocator.free(str); + testing.expect(eql(u8, str, "a,,b,,c")); + } } /// Copies each T from slices into a new slice that exactly holds all the elements. @@ -1044,15 +1054,21 @@ pub fn concat(allocator: *Allocator, comptime T: type, slices: []const []const T } test "concat" { - var buf: [1024]u8 = undefined; - const a = &std.heap.FixedBufferAllocator.init(&buf).allocator; - testing.expect(eql(u8, try concat(a, u8, &[_][]const u8{ "abc", "def", "ghi" }), "abcdefghi")); - testing.expect(eql(u32, try concat(a, u32, &[_][]const u32{ - &[_]u32{ 0, 1 }, - &[_]u32{ 2, 3, 4 }, - &[_]u32{}, - &[_]u32{5}, - }), &[_]u32{ 0, 1, 2, 3, 4, 5 })); + { + const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" }); + defer testing.allocator.free(str); + testing.expect(eql(u8, str, "abcdefghi")); + } + { + const str = try concat(testing.allocator, u32, &[_][]const u32{ + &[_]u32{ 0, 1 }, + &[_]u32{ 2, 3, 4 }, + &[_]u32{}, + &[_]u32{5}, + }); + defer testing.allocator.free(str); + testing.expect(eql(u32, str, &[_]u32{ 0, 1, 2, 3, 4, 5 })); + } } test "testStringEquality" { diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig index 703a804bfb..45d8b1cffd 100644 --- a/lib/std/net/test.zig +++ b/lib/std/net/test.zig @@ -67,10 +67,8 @@ test "resolve DNS" { // DNS resolution not implemented on Windows yet. return error.SkipZigTest; } - var buf: [1000 * 10]u8 = undefined; - const a = &std.heap.FixedBufferAllocator.init(&buf).allocator; - const address_list = net.getAddressList(a, "example.com", 80) catch |err| switch (err) { + const address_list = net.getAddressList(testing.allocator, "example.com", 80) catch |err| switch (err) { // The tests are required to work even when there is no Internet connection, // so some of these errors we must accept and skip the test. error.UnknownHostName => return error.SkipZigTest,