commit 40b9db7cad6f876bb3e8fa32d7b32bbd4bc983ea (tree)
parent 9206f8a8cde9a8c1eafc606fe6b3f4129e233aef
Author: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 14 Feb 2020 09:40:08 -0500
Merge pull request #4451 from daurnimator/use-testing.allocator
Migrate (more) tests from FixedBufferAllocator to testing.allocator
Diffstat:
7 files changed, 651 insertions(+), 350 deletions(-)
diff --git 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
@@ -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/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
@@ -1361,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;
@@ -1381,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;
@@ -1440,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;
@@ -1469,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());
@@ -1480,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);
@@ -1507,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);
@@ -1537,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));
@@ -1564,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);
@@ -1650,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);
@@ -1663,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);
@@ -1719,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);
@@ -1729,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);
@@ -1754,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);
@@ -1775,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);
@@ -1784,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {
}
test "big.int add sign" {
- var a = try Int.init(al);
-
- 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);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
+ 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);
@@ -1805,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));
@@ -1828,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);
-
- 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);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
+ 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);
@@ -1872,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));
@@ -1894,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);
@@ -1913,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);
@@ -1922,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);
@@ -1930,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -1962,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -1977,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);
@@ -1992,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);
@@ -2007,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);
@@ -2019,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2031,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2043,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);
@@ -2055,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2070,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
@@ -2090,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
@@ -2110,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
@@ -2130,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
@@ -2150,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
@@ -2170,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
@@ -2190,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
@@ -2210,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
@@ -2227,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2239,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2251,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2263,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2275,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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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 q = try Int.init(al);
- var r = try Int.init(al);
+ 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(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);
@@ -2421,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);
@@ -2430,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);
@@ -2439,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);
@@ -2448,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);
@@ -2457,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);
@@ -2467,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);
}
diff --git 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
@@ -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
@@ -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,
diff --git 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.
