authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-02-14 09:40:08-05:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-02-14 09:40:08-05:00
log40b9db7cad6f876bb3e8fa32d7b32bbd4bc983ea
treeac84f7fcca0d11becb7d459c151782202f3e01c0
parent9206f8a8cde9a8c1eafc606fe6b3f4129e233aef
parent6ea6d5a4bdcf6f37c43857570522ee1308115de7
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4451 from daurnimator/use-testing.allocator

Migrate (more) tests from FixedBufferAllocator to testing.allocator

7 files changed, 651 insertions(+), 350 deletions(-)

lib/std/json.zig+15-14
...@@ -1598,21 +1598,21 @@ test "write json then parse it" {...@@ -1598,21 +1598,21 @@ test "write json then parse it" {
1598 testing.expect(mem.eql(u8, tree.root.Object.get("str").?.value.String, "hello"));1598 testing.expect(mem.eql(u8, tree.root.Object.get("str").?.value.String, "hello"));
1599}1599}
16001600
1601fn test_parse(memory: []u8, json_str: []const u8) !Value {1601fn test_parse(arena_allocator: *std.mem.Allocator, json_str: []const u8) !Value {
1602 // buf_alloc goes out of scope, but we don't use it after parsing1602 var p = Parser.init(arena_allocator, false);
1603 var buf_alloc = std.heap.FixedBufferAllocator.init(memory);
1604 var p = Parser.init(&buf_alloc.allocator, false);
1605 return (try p.parse(json_str)).root;1603 return (try p.parse(json_str)).root;
1606}1604}
16071605
1608test "parsing empty string gives appropriate error" {1606test "parsing empty string gives appropriate error" {
1609 var memory: [1024 * 4]u8 = undefined;1607 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
1610 testing.expectError(error.UnexpectedEndOfJson, test_parse(&memory, ""));1608 defer arena_allocator.deinit();
1609 testing.expectError(error.UnexpectedEndOfJson, test_parse(&arena_allocator.allocator, ""));
1611}1610}
16121611
1613test "integer after float has proper type" {1612test "integer after float has proper type" {
1614 var memory: [1024 * 8]u8 = undefined;1613 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
1615 const json = try test_parse(&memory,1614 defer arena_allocator.deinit();
1615 const json = try test_parse(&arena_allocator.allocator,
1616 \\{1616 \\{
1617 \\ "float": 3.14,1617 \\ "float": 3.14,
1618 \\ "ints": [1, 2, 3]1618 \\ "ints": [1, 2, 3]
...@@ -1622,7 +1622,8 @@ test "integer after float has proper type" {...@@ -1622,7 +1622,8 @@ test "integer after float has proper type" {
1622}1622}
16231623
1624test "escaped characters" {1624test "escaped characters" {
1625 var memory: [1024 * 16]u8 = undefined;1625 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
1626 defer arena_allocator.deinit();
1626 const input =1627 const input =
1627 \\{1628 \\{
1628 \\ "backslash": "\\",1629 \\ "backslash": "\\",
...@@ -1638,7 +1639,7 @@ test "escaped characters" {...@@ -1638,7 +1639,7 @@ test "escaped characters" {
1638 \\}1639 \\}
1639 ;1640 ;
16401641
1641 const obj = (try test_parse(&memory, input)).Object;1642 const obj = (try test_parse(&arena_allocator.allocator, input)).Object;
16421643
1643 testing.expectEqualSlices(u8, obj.get("backslash").?.value.String, "\\");1644 testing.expectEqualSlices(u8, obj.get("backslash").?.value.String, "\\");
1644 testing.expectEqualSlices(u8, obj.get("forwardslash").?.value.String, "/");1645 testing.expectEqualSlices(u8, obj.get("forwardslash").?.value.String, "/");
...@@ -1662,13 +1663,13 @@ test "string copy option" {...@@ -1662,13 +1663,13 @@ test "string copy option" {
1662 \\}1663 \\}
1663 ;1664 ;
16641665
1665 var mem_buffer: [1024 * 16]u8 = undefined;1666 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
1666 var buf_alloc = std.heap.FixedBufferAllocator.init(&mem_buffer);1667 defer arena_allocator.deinit();
16671668
1668 const tree_nocopy = try Parser.init(&buf_alloc.allocator, false).parse(input);1669 const tree_nocopy = try Parser.init(&arena_allocator.allocator, false).parse(input);
1669 const obj_nocopy = tree_nocopy.root.Object;1670 const obj_nocopy = tree_nocopy.root.Object;
16701671
1671 const tree_copy = try Parser.init(&buf_alloc.allocator, true).parse(input);1672 const tree_copy = try Parser.init(&arena_allocator.allocator, true).parse(input);
1672 const obj_copy = tree_copy.root.Object;1673 const obj_copy = tree_copy.root.Object;
16731674
1674 for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| {1675 for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| {
lib/std/json/write_stream.zig+3-3
...@@ -254,11 +254,11 @@ test "json write stream" {...@@ -254,11 +254,11 @@ test "json write stream" {
254 var slice_stream = std.io.SliceOutStream.init(&out_buf);254 var slice_stream = std.io.SliceOutStream.init(&out_buf);
255 const out = &slice_stream.stream;255 const out = &slice_stream.stream;
256256
257 var mem_buf: [1024 * 10]u8 = undefined;257 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
258 const allocator = &std.heap.FixedBufferAllocator.init(&mem_buf).allocator;258 defer arena_allocator.deinit();
259259
260 var w = std.json.WriteStream(@TypeOf(out).Child, 10).init(out);260 var w = std.json.WriteStream(@TypeOf(out).Child, 10).init(out);
261 try w.emitJson(try getJson(allocator));261 try w.emitJson(try getJson(&arena_allocator.allocator));
262262
263 const result = slice_stream.getWritten();263 const result = slice_stream.getWritten();
264 const expected =264 const expected =
lib/std/math/big/int.zig+503-262
...@@ -137,10 +137,9 @@ pub const Int = struct {...@@ -137,10 +137,9 @@ pub const Int = struct {
137 }137 }
138138
139 /// Frees all memory associated with an Int.139 /// Frees all memory associated with an Int.
140 pub fn deinit(self: *Int) void {140 pub fn deinit(self: Int) void {
141 self.assertWritable();141 self.assertWritable();
142 self.allocator.?.free(self.limbs);142 self.allocator.?.free(self.limbs);
143 self.* = undefined;
144 }143 }
145144
146 /// Clones an Int and returns a new Int with the same value. The new Int is a deep copy and145 /// 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 {...@@ -1361,13 +1360,10 @@ pub const Int = struct {
1361// They will still run on larger than this and should pass, but the multi-limb code-paths1360// They will still run on larger than this and should pass, but the multi-limb code-paths
1362// may be untested in some cases.1361// may be untested in some cases.
13631362
1364var buffer: [64 * 8192]u8 = undefined;
1365var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
1366const al = &fixed.allocator;
1367
1368test "big.int comptime_int set" {1363test "big.int comptime_int set" {
1369 comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;1364 comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;
1370 var a = try Int.initSet(al, s);1365 var a = try Int.initSet(testing.allocator, s);
1366 defer a.deinit();
13711367
1372 const s_limb_count = 128 / Limb.bit_count;1368 const s_limb_count = 128 / Limb.bit_count;
13731369
...@@ -1381,39 +1377,45 @@ test "big.int comptime_int set" {...@@ -1381,39 +1377,45 @@ test "big.int comptime_int set" {
1381}1377}
13821378
1383test "big.int comptime_int set negative" {1379test "big.int comptime_int set negative" {
1384 var a = try Int.initSet(al, -10);1380 var a = try Int.initSet(testing.allocator, -10);
1381 defer a.deinit();
13851382
1386 testing.expect(a.limbs[0] == 10);1383 testing.expect(a.limbs[0] == 10);
1387 testing.expect(a.isPositive() == false);1384 testing.expect(a.isPositive() == false);
1388}1385}
13891386
1390test "big.int int set unaligned small" {1387test "big.int int set unaligned small" {
1391 var a = try Int.initSet(al, @as(u7, 45));1388 var a = try Int.initSet(testing.allocator, @as(u7, 45));
1389 defer a.deinit();
13921390
1393 testing.expect(a.limbs[0] == 45);1391 testing.expect(a.limbs[0] == 45);
1394 testing.expect(a.isPositive() == true);1392 testing.expect(a.isPositive() == true);
1395}1393}
13961394
1397test "big.int comptime_int to" {1395test "big.int comptime_int to" {
1398 const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);1396 const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
1397 defer a.deinit();
13991398
1400 testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);1399 testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
1401}1400}
14021401
1403test "big.int sub-limb to" {1402test "big.int sub-limb to" {
1404 const a = try Int.initSet(al, 10);1403 const a = try Int.initSet(testing.allocator, 10);
1404 defer a.deinit();
14051405
1406 testing.expect((try a.to(u8)) == 10);1406 testing.expect((try a.to(u8)) == 10);
1407}1407}
14081408
1409test "big.int to target too small error" {1409test "big.int to target too small error" {
1410 const a = try Int.initSet(al, 0xffffffff);1410 const a = try Int.initSet(testing.allocator, 0xffffffff);
1411 defer a.deinit();
14111412
1412 testing.expectError(error.TargetTooSmall, a.to(u8));1413 testing.expectError(error.TargetTooSmall, a.to(u8));
1413}1414}
14141415
1415test "big.int normalize" {1416test "big.int normalize" {
1416 var a = try Int.init(al);1417 var a = try Int.init(testing.allocator);
1418 defer a.deinit();
1417 try a.ensureCapacity(8);1419 try a.ensureCapacity(8);
14181420
1419 a.limbs[0] = 1;1421 a.limbs[0] = 1;
...@@ -1440,7 +1442,8 @@ test "big.int normalize" {...@@ -1440,7 +1442,8 @@ test "big.int normalize" {
1440}1442}
14411443
1442test "big.int normalize multi" {1444test "big.int normalize multi" {
1443 var a = try Int.init(al);1445 var a = try Int.init(testing.allocator);
1446 defer a.deinit();
1444 try a.ensureCapacity(8);1447 try a.ensureCapacity(8);
14451448
1446 a.limbs[0] = 1;1449 a.limbs[0] = 1;
...@@ -1469,7 +1472,9 @@ test "big.int normalize multi" {...@@ -1469,7 +1472,9 @@ test "big.int normalize multi" {
1469}1472}
14701473
1471test "big.int parity" {1474test "big.int parity" {
1472 var a = try Int.init(al);1475 var a = try Int.init(testing.allocator);
1476 defer a.deinit();
1477
1473 try a.set(0);1478 try a.set(0);
1474 testing.expect(a.isEven());1479 testing.expect(a.isEven());
1475 testing.expect(!a.isOdd());1480 testing.expect(!a.isOdd());
...@@ -1480,7 +1485,8 @@ test "big.int parity" {...@@ -1480,7 +1485,8 @@ test "big.int parity" {
1480}1485}
14811486
1482test "big.int bitcount + sizeInBase" {1487test "big.int bitcount + sizeInBase" {
1483 var a = try Int.init(al);1488 var a = try Int.init(testing.allocator);
1489 defer a.deinit();
14841490
1485 try a.set(0b100);1491 try a.set(0b100);
1486 testing.expect(a.bitCountAbs() == 3);1492 testing.expect(a.bitCountAbs() == 3);
...@@ -1507,7 +1513,8 @@ test "big.int bitcount + sizeInBase" {...@@ -1507,7 +1513,8 @@ test "big.int bitcount + sizeInBase" {
1507}1513}
15081514
1509test "big.int bitcount/to" {1515test "big.int bitcount/to" {
1510 var a = try Int.init(al);1516 var a = try Int.init(testing.allocator);
1517 defer a.deinit();
15111518
1512 try a.set(0);1519 try a.set(0);
1513 testing.expect(a.bitCountTwosComp() == 0);1520 testing.expect(a.bitCountTwosComp() == 0);
...@@ -1537,7 +1544,8 @@ test "big.int bitcount/to" {...@@ -1537,7 +1544,8 @@ test "big.int bitcount/to" {
1537}1544}
15381545
1539test "big.int fits" {1546test "big.int fits" {
1540 var a = try Int.init(al);1547 var a = try Int.init(testing.allocator);
1548 defer a.deinit();
15411549
1542 try a.set(0);1550 try a.set(0);
1543 testing.expect(a.fits(u0));1551 testing.expect(a.fits(u0));
...@@ -1564,82 +1572,100 @@ test "big.int fits" {...@@ -1564,82 +1572,100 @@ test "big.int fits" {
1564}1572}
15651573
1566test "big.int string set" {1574test "big.int string set" {
1567 var a = try Int.init(al);1575 var a = try Int.init(testing.allocator);
1568 try a.setString(10, "120317241209124781241290847124");1576 defer a.deinit();
15691577
1578 try a.setString(10, "120317241209124781241290847124");
1570 testing.expect((try a.to(u128)) == 120317241209124781241290847124);1579 testing.expect((try a.to(u128)) == 120317241209124781241290847124);
1571}1580}
15721581
1573test "big.int string negative" {1582test "big.int string negative" {
1574 var a = try Int.init(al);1583 var a = try Int.init(testing.allocator);
1584 defer a.deinit();
1585
1575 try a.setString(10, "-1023");1586 try a.setString(10, "-1023");
1576 testing.expect((try a.to(i32)) == -1023);1587 testing.expect((try a.to(i32)) == -1023);
1577}1588}
15781589
1579test "big.int string set bad char error" {1590test "big.int string set bad char error" {
1580 var a = try Int.init(al);1591 var a = try Int.init(testing.allocator);
1592 defer a.deinit();
1581 testing.expectError(error.InvalidCharForDigit, a.setString(10, "x"));1593 testing.expectError(error.InvalidCharForDigit, a.setString(10, "x"));
1582}1594}
15831595
1584test "big.int string set bad base error" {1596test "big.int string set bad base error" {
1585 var a = try Int.init(al);1597 var a = try Int.init(testing.allocator);
1598 defer a.deinit();
1586 testing.expectError(error.InvalidBase, a.setString(45, "10"));1599 testing.expectError(error.InvalidBase, a.setString(45, "10"));
1587}1600}
15881601
1589test "big.int string to" {1602test "big.int string to" {
1590 const a = try Int.initSet(al, 120317241209124781241290847124);1603 const a = try Int.initSet(testing.allocator, 120317241209124781241290847124);
1604 defer a.deinit();
15911605
1592 const as = try a.toString(al, 10);1606 const as = try a.toString(testing.allocator, 10);
1607 defer testing.allocator.free(as);
1593 const es = "120317241209124781241290847124";1608 const es = "120317241209124781241290847124";
15941609
1595 testing.expect(mem.eql(u8, as, es));1610 testing.expect(mem.eql(u8, as, es));
1596}1611}
15971612
1598test "big.int string to base base error" {1613test "big.int string to base base error" {
1599 const a = try Int.initSet(al, 0xffffffff);1614 const a = try Int.initSet(testing.allocator, 0xffffffff);
1615 defer a.deinit();
16001616
1601 testing.expectError(error.InvalidBase, a.toString(al, 45));1617 testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45));
1602}1618}
16031619
1604test "big.int string to base 2" {1620test "big.int string to base 2" {
1605 const a = try Int.initSet(al, -0b1011);1621 const a = try Int.initSet(testing.allocator, -0b1011);
1622 defer a.deinit();
16061623
1607 const as = try a.toString(al, 2);1624 const as = try a.toString(testing.allocator, 2);
1625 defer testing.allocator.free(as);
1608 const es = "-1011";1626 const es = "-1011";
16091627
1610 testing.expect(mem.eql(u8, as, es));1628 testing.expect(mem.eql(u8, as, es));
1611}1629}
16121630
1613test "big.int string to base 16" {1631test "big.int string to base 16" {
1614 const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);1632 const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
1633 defer a.deinit();
16151634
1616 const as = try a.toString(al, 16);1635 const as = try a.toString(testing.allocator, 16);
1636 defer testing.allocator.free(as);
1617 const es = "efffffff00000001eeeeeeefaaaaaaab";1637 const es = "efffffff00000001eeeeeeefaaaaaaab";
16181638
1619 testing.expect(mem.eql(u8, as, es));1639 testing.expect(mem.eql(u8, as, es));
1620}1640}
16211641
1622test "big.int neg string to" {1642test "big.int neg string to" {
1623 const a = try Int.initSet(al, -123907434);1643 const a = try Int.initSet(testing.allocator, -123907434);
1644 defer a.deinit();
16241645
1625 const as = try a.toString(al, 10);1646 const as = try a.toString(testing.allocator, 10);
1647 defer testing.allocator.free(as);
1626 const es = "-123907434";1648 const es = "-123907434";
16271649
1628 testing.expect(mem.eql(u8, as, es));1650 testing.expect(mem.eql(u8, as, es));
1629}1651}
16301652
1631test "big.int zero string to" {1653test "big.int zero string to" {
1632 const a = try Int.initSet(al, 0);1654 const a = try Int.initSet(testing.allocator, 0);
1655 defer a.deinit();
16331656
1634 const as = try a.toString(al, 10);1657 const as = try a.toString(testing.allocator, 10);
1658 defer testing.allocator.free(as);
1635 const es = "0";1659 const es = "0";
16361660
1637 testing.expect(mem.eql(u8, as, es));1661 testing.expect(mem.eql(u8, as, es));
1638}1662}
16391663
1640test "big.int clone" {1664test "big.int clone" {
1641 var a = try Int.initSet(al, 1234);1665 var a = try Int.initSet(testing.allocator, 1234);
1666 defer a.deinit();
1642 const b = try a.clone();1667 const b = try a.clone();
1668 defer b.deinit();
16431669
1644 testing.expect((try a.to(u32)) == 1234);1670 testing.expect((try a.to(u32)) == 1234);
1645 testing.expect((try b.to(u32)) == 1234);1671 testing.expect((try b.to(u32)) == 1234);
...@@ -1650,8 +1676,10 @@ test "big.int clone" {...@@ -1650,8 +1676,10 @@ test "big.int clone" {
1650}1676}
16511677
1652test "big.int swap" {1678test "big.int swap" {
1653 var a = try Int.initSet(al, 1234);1679 var a = try Int.initSet(testing.allocator, 1234);
1654 var b = try Int.initSet(al, 5678);1680 defer a.deinit();
1681 var b = try Int.initSet(testing.allocator, 5678);
1682 defer b.deinit();
16551683
1656 testing.expect((try a.to(u32)) == 1234);1684 testing.expect((try a.to(u32)) == 1234);
1657 testing.expect((try b.to(u32)) == 5678);1685 testing.expect((try b.to(u32)) == 5678);
...@@ -1663,53 +1691,65 @@ test "big.int swap" {...@@ -1663,53 +1691,65 @@ test "big.int swap" {
1663}1691}
16641692
1665test "big.int to negative" {1693test "big.int to negative" {
1666 var a = try Int.initSet(al, -10);1694 var a = try Int.initSet(testing.allocator, -10);
1695 defer a.deinit();
16671696
1668 testing.expect((try a.to(i32)) == -10);1697 testing.expect((try a.to(i32)) == -10);
1669}1698}
16701699
1671test "big.int compare" {1700test "big.int compare" {
1672 var a = try Int.initSet(al, -11);1701 var a = try Int.initSet(testing.allocator, -11);
1673 var b = try Int.initSet(al, 10);1702 defer a.deinit();
1703 var b = try Int.initSet(testing.allocator, 10);
1704 defer b.deinit();
16741705
1675 testing.expect(a.cmpAbs(b) == 1);1706 testing.expect(a.cmpAbs(b) == 1);
1676 testing.expect(a.cmp(b) == -1);1707 testing.expect(a.cmp(b) == -1);
1677}1708}
16781709
1679test "big.int compare similar" {1710test "big.int compare similar" {
1680 var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);1711 var a = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee);
1681 var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef);1712 defer a.deinit();
1713 var b = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef);
1714 defer b.deinit();
16821715
1683 testing.expect(a.cmpAbs(b) == -1);1716 testing.expect(a.cmpAbs(b) == -1);
1684 testing.expect(b.cmpAbs(a) == 1);1717 testing.expect(b.cmpAbs(a) == 1);
1685}1718}
16861719
1687test "big.int compare different limb size" {1720test "big.int compare different limb size" {
1688 var a = try Int.initSet(al, maxInt(Limb) + 1);1721 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
1689 var b = try Int.initSet(al, 1);1722 defer a.deinit();
1723 var b = try Int.initSet(testing.allocator, 1);
1724 defer b.deinit();
16901725
1691 testing.expect(a.cmpAbs(b) == 1);1726 testing.expect(a.cmpAbs(b) == 1);
1692 testing.expect(b.cmpAbs(a) == -1);1727 testing.expect(b.cmpAbs(a) == -1);
1693}1728}
16941729
1695test "big.int compare multi-limb" {1730test "big.int compare multi-limb" {
1696 var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);1731 var a = try Int.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
1697 var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);1732 defer a.deinit();
1733 var b = try Int.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
1734 defer b.deinit();
16981735
1699 testing.expect(a.cmpAbs(b) == 1);1736 testing.expect(a.cmpAbs(b) == 1);
1700 testing.expect(a.cmp(b) == -1);1737 testing.expect(a.cmp(b) == -1);
1701}1738}
17021739
1703test "big.int equality" {1740test "big.int equality" {
1704 var a = try Int.initSet(al, 0xffffffff1);1741 var a = try Int.initSet(testing.allocator, 0xffffffff1);
1705 var b = try Int.initSet(al, -0xffffffff1);1742 defer a.deinit();
1743 var b = try Int.initSet(testing.allocator, -0xffffffff1);
1744 defer b.deinit();
17061745
1707 testing.expect(a.eqAbs(b));1746 testing.expect(a.eqAbs(b));
1708 testing.expect(!a.eq(b));1747 testing.expect(!a.eq(b));
1709}1748}
17101749
1711test "big.int abs" {1750test "big.int abs" {
1712 var a = try Int.initSet(al, -5);1751 var a = try Int.initSet(testing.allocator, -5);
1752 defer a.deinit();
17131753
1714 a.abs();1754 a.abs();
1715 testing.expect((try a.to(u32)) == 5);1755 testing.expect((try a.to(u32)) == 5);
...@@ -1719,7 +1759,8 @@ test "big.int abs" {...@@ -1719,7 +1759,8 @@ test "big.int abs" {
1719}1759}
17201760
1721test "big.int negate" {1761test "big.int negate" {
1722 var a = try Int.initSet(al, 5);1762 var a = try Int.initSet(testing.allocator, 5);
1763 defer a.deinit();
17231764
1724 a.negate();1765 a.negate();
1725 testing.expect((try a.to(i32)) == -5);1766 testing.expect((try a.to(i32)) == -5);
...@@ -1729,20 +1770,26 @@ test "big.int negate" {...@@ -1729,20 +1770,26 @@ test "big.int negate" {
1729}1770}
17301771
1731test "big.int add single-single" {1772test "big.int add single-single" {
1732 var a = try Int.initSet(al, 50);1773 var a = try Int.initSet(testing.allocator, 50);
1733 var b = try Int.initSet(al, 5);1774 defer a.deinit();
1775 var b = try Int.initSet(testing.allocator, 5);
1776 defer b.deinit();
17341777
1735 var c = try Int.init(al);1778 var c = try Int.init(testing.allocator);
1779 defer c.deinit();
1736 try c.add(a, b);1780 try c.add(a, b);
17371781
1738 testing.expect((try c.to(u32)) == 55);1782 testing.expect((try c.to(u32)) == 55);
1739}1783}
17401784
1741test "big.int add multi-single" {1785test "big.int add multi-single" {
1742 var a = try Int.initSet(al, maxInt(Limb) + 1);1786 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
1743 var b = try Int.initSet(al, 1);1787 defer a.deinit();
1788 var b = try Int.initSet(testing.allocator, 1);
1789 defer b.deinit();
17441790
1745 var c = try Int.init(al);1791 var c = try Int.init(testing.allocator);
1792 defer c.deinit();
17461793
1747 try c.add(a, b);1794 try c.add(a, b);
1748 testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);1795 testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
...@@ -1754,20 +1801,26 @@ test "big.int add multi-single" {...@@ -1754,20 +1801,26 @@ test "big.int add multi-single" {
1754test "big.int add multi-multi" {1801test "big.int add multi-multi" {
1755 const op1 = 0xefefefef7f7f7f7f;1802 const op1 = 0xefefefef7f7f7f7f;
1756 const op2 = 0xfefefefe9f9f9f9f;1803 const op2 = 0xfefefefe9f9f9f9f;
1757 var a = try Int.initSet(al, op1);1804 var a = try Int.initSet(testing.allocator, op1);
1758 var b = try Int.initSet(al, op2);1805 defer a.deinit();
1806 var b = try Int.initSet(testing.allocator, op2);
1807 defer b.deinit();
17591808
1760 var c = try Int.init(al);1809 var c = try Int.init(testing.allocator);
1810 defer c.deinit();
1761 try c.add(a, b);1811 try c.add(a, b);
17621812
1763 testing.expect((try c.to(u128)) == op1 + op2);1813 testing.expect((try c.to(u128)) == op1 + op2);
1764}1814}
17651815
1766test "big.int add zero-zero" {1816test "big.int add zero-zero" {
1767 var a = try Int.initSet(al, 0);1817 var a = try Int.initSet(testing.allocator, 0);
1768 var b = try Int.initSet(al, 0);1818 defer a.deinit();
1819 var b = try Int.initSet(testing.allocator, 0);
1820 defer b.deinit();
17691821
1770 var c = try Int.init(al);1822 var c = try Int.init(testing.allocator);
1823 defer c.deinit();
1771 try c.add(a, b);1824 try c.add(a, b);
17721825
1773 testing.expect((try c.to(u32)) == 0);1826 testing.expect((try c.to(u32)) == 0);
...@@ -1775,8 +1828,10 @@ test "big.int add zero-zero" {...@@ -1775,8 +1828,10 @@ test "big.int add zero-zero" {
17751828
1776test "big.int add alias multi-limb nonzero-zero" {1829test "big.int add alias multi-limb nonzero-zero" {
1777 const op1 = 0xffffffff777777771;1830 const op1 = 0xffffffff777777771;
1778 var a = try Int.initSet(al, op1);1831 var a = try Int.initSet(testing.allocator, op1);
1779 var b = try Int.initSet(al, 0);1832 defer a.deinit();
1833 var b = try Int.initSet(testing.allocator, 0);
1834 defer b.deinit();
17801835
1781 try a.add(a, b);1836 try a.add(a, b);
17821837
...@@ -1784,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {...@@ -1784,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {
1784}1839}
17851840
1786test "big.int add sign" {1841test "big.int add sign" {
1787 var a = try Int.init(al);1842 var a = try Int.init(testing.allocator);
17881843 defer a.deinit();
1789 const one = try Int.initSet(al, 1);1844
1790 const two = try Int.initSet(al, 2);1845 const one = try Int.initSet(testing.allocator, 1);
1791 const neg_one = try Int.initSet(al, -1);1846 defer one.deinit();
1792 const neg_two = try Int.initSet(al, -2);1847 const two = try Int.initSet(testing.allocator, 2);
1848 defer two.deinit();
1849 const neg_one = try Int.initSet(testing.allocator, -1);
1850 defer neg_one.deinit();
1851 const neg_two = try Int.initSet(testing.allocator, -2);
1852 defer neg_two.deinit();
17931853
1794 try a.add(one, two);1854 try a.add(one, two);
1795 testing.expect((try a.to(i32)) == 3);1855 testing.expect((try a.to(i32)) == 3);
...@@ -1805,20 +1865,26 @@ test "big.int add sign" {...@@ -1805,20 +1865,26 @@ test "big.int add sign" {
1805}1865}
18061866
1807test "big.int sub single-single" {1867test "big.int sub single-single" {
1808 var a = try Int.initSet(al, 50);1868 var a = try Int.initSet(testing.allocator, 50);
1809 var b = try Int.initSet(al, 5);1869 defer a.deinit();
1870 var b = try Int.initSet(testing.allocator, 5);
1871 defer b.deinit();
18101872
1811 var c = try Int.init(al);1873 var c = try Int.init(testing.allocator);
1874 defer c.deinit();
1812 try c.sub(a, b);1875 try c.sub(a, b);
18131876
1814 testing.expect((try c.to(u32)) == 45);1877 testing.expect((try c.to(u32)) == 45);
1815}1878}
18161879
1817test "big.int sub multi-single" {1880test "big.int sub multi-single" {
1818 var a = try Int.initSet(al, maxInt(Limb) + 1);1881 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
1819 var b = try Int.initSet(al, 1);1882 defer a.deinit();
1883 var b = try Int.initSet(testing.allocator, 1);
1884 defer b.deinit();
18201885
1821 var c = try Int.init(al);1886 var c = try Int.init(testing.allocator);
1887 defer c.deinit();
1822 try c.sub(a, b);1888 try c.sub(a, b);
18231889
1824 testing.expect((try c.to(Limb)) == maxInt(Limb));1890 testing.expect((try c.to(Limb)) == maxInt(Limb));
...@@ -1828,32 +1894,43 @@ test "big.int sub multi-multi" {...@@ -1828,32 +1894,43 @@ test "big.int sub multi-multi" {
1828 const op1 = 0xefefefefefefefefefefefef;1894 const op1 = 0xefefefefefefefefefefefef;
1829 const op2 = 0xabababababababababababab;1895 const op2 = 0xabababababababababababab;
18301896
1831 var a = try Int.initSet(al, op1);1897 var a = try Int.initSet(testing.allocator, op1);
1832 var b = try Int.initSet(al, op2);1898 defer a.deinit();
1899 var b = try Int.initSet(testing.allocator, op2);
1900 defer b.deinit();
18331901
1834 var c = try Int.init(al);1902 var c = try Int.init(testing.allocator);
1903 defer c.deinit();
1835 try c.sub(a, b);1904 try c.sub(a, b);
18361905
1837 testing.expect((try c.to(u128)) == op1 - op2);1906 testing.expect((try c.to(u128)) == op1 - op2);
1838}1907}
18391908
1840test "big.int sub equal" {1909test "big.int sub equal" {
1841 var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);1910 var a = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
1842 var b = try Int.initSet(al, 0x11efefefefefefefefefefefef);1911 defer a.deinit();
1912 var b = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
1913 defer b.deinit();
18431914
1844 var c = try Int.init(al);1915 var c = try Int.init(testing.allocator);
1916 defer c.deinit();
1845 try c.sub(a, b);1917 try c.sub(a, b);
18461918
1847 testing.expect((try c.to(u32)) == 0);1919 testing.expect((try c.to(u32)) == 0);
1848}1920}
18491921
1850test "big.int sub sign" {1922test "big.int sub sign" {
1851 var a = try Int.init(al);1923 var a = try Int.init(testing.allocator);
18521924 defer a.deinit();
1853 const one = try Int.initSet(al, 1);1925
1854 const two = try Int.initSet(al, 2);1926 const one = try Int.initSet(testing.allocator, 1);
1855 const neg_one = try Int.initSet(al, -1);1927 defer one.deinit();
1856 const neg_two = try Int.initSet(al, -2);1928 const two = try Int.initSet(testing.allocator, 2);
1929 defer two.deinit();
1930 const neg_one = try Int.initSet(testing.allocator, -1);
1931 defer neg_one.deinit();
1932 const neg_two = try Int.initSet(testing.allocator, -2);
1933 defer neg_two.deinit();
18571934
1858 try a.sub(one, two);1935 try a.sub(one, two);
1859 testing.expect((try a.to(i32)) == -1);1936 testing.expect((try a.to(i32)) == -1);
...@@ -1872,20 +1949,26 @@ test "big.int sub sign" {...@@ -1872,20 +1949,26 @@ test "big.int sub sign" {
1872}1949}
18731950
1874test "big.int mul single-single" {1951test "big.int mul single-single" {
1875 var a = try Int.initSet(al, 50);1952 var a = try Int.initSet(testing.allocator, 50);
1876 var b = try Int.initSet(al, 5);1953 defer a.deinit();
1954 var b = try Int.initSet(testing.allocator, 5);
1955 defer b.deinit();
18771956
1878 var c = try Int.init(al);1957 var c = try Int.init(testing.allocator);
1958 defer c.deinit();
1879 try c.mul(a, b);1959 try c.mul(a, b);
18801960
1881 testing.expect((try c.to(u64)) == 250);1961 testing.expect((try c.to(u64)) == 250);
1882}1962}
18831963
1884test "big.int mul multi-single" {1964test "big.int mul multi-single" {
1885 var a = try Int.initSet(al, maxInt(Limb));1965 var a = try Int.initSet(testing.allocator, maxInt(Limb));
1886 var b = try Int.initSet(al, 2);1966 defer a.deinit();
1967 var b = try Int.initSet(testing.allocator, 2);
1968 defer b.deinit();
18871969
1888 var c = try Int.init(al);1970 var c = try Int.init(testing.allocator);
1971 defer c.deinit();
1889 try c.mul(a, b);1972 try c.mul(a, b);
18901973
1891 testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));1974 testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));
...@@ -1894,18 +1977,23 @@ test "big.int mul multi-single" {...@@ -1894,18 +1977,23 @@ test "big.int mul multi-single" {
1894test "big.int mul multi-multi" {1977test "big.int mul multi-multi" {
1895 const op1 = 0x998888efefefefefefefef;1978 const op1 = 0x998888efefefefefefefef;
1896 const op2 = 0x333000abababababababab;1979 const op2 = 0x333000abababababababab;
1897 var a = try Int.initSet(al, op1);1980 var a = try Int.initSet(testing.allocator, op1);
1898 var b = try Int.initSet(al, op2);1981 defer a.deinit();
1982 var b = try Int.initSet(testing.allocator, op2);
1983 defer b.deinit();
18991984
1900 var c = try Int.init(al);1985 var c = try Int.init(testing.allocator);
1986 defer c.deinit();
1901 try c.mul(a, b);1987 try c.mul(a, b);
19021988
1903 testing.expect((try c.to(u256)) == op1 * op2);1989 testing.expect((try c.to(u256)) == op1 * op2);
1904}1990}
19051991
1906test "big.int mul alias r with a" {1992test "big.int mul alias r with a" {
1907 var a = try Int.initSet(al, maxInt(Limb));1993 var a = try Int.initSet(testing.allocator, maxInt(Limb));
1908 var b = try Int.initSet(al, 2);1994 defer a.deinit();
1995 var b = try Int.initSet(testing.allocator, 2);
1996 defer b.deinit();
19091997
1910 try a.mul(a, b);1998 try a.mul(a, b);
19111999
...@@ -1913,8 +2001,10 @@ test "big.int mul alias r with a" {...@@ -1913,8 +2001,10 @@ test "big.int mul alias r with a" {
1913}2001}
19142002
1915test "big.int mul alias r with b" {2003test "big.int mul alias r with b" {
1916 var a = try Int.initSet(al, maxInt(Limb));2004 var a = try Int.initSet(testing.allocator, maxInt(Limb));
1917 var b = try Int.initSet(al, 2);2005 defer a.deinit();
2006 var b = try Int.initSet(testing.allocator, 2);
2007 defer b.deinit();
19182008
1919 try a.mul(b, a);2009 try a.mul(b, a);
19202010
...@@ -1922,7 +2012,8 @@ test "big.int mul alias r with b" {...@@ -1922,7 +2012,8 @@ test "big.int mul alias r with b" {
1922}2012}
19232013
1924test "big.int mul alias r with a and b" {2014test "big.int mul alias r with a and b" {
1925 var a = try Int.initSet(al, maxInt(Limb));2015 var a = try Int.initSet(testing.allocator, maxInt(Limb));
2016 defer a.deinit();
19262017
1927 try a.mul(a, a);2018 try a.mul(a, a);
19282019
...@@ -1930,31 +2021,41 @@ test "big.int mul alias r with a and b" {...@@ -1930,31 +2021,41 @@ test "big.int mul alias r with a and b" {
1930}2021}
19312022
1932test "big.int mul a*0" {2023test "big.int mul a*0" {
1933 var a = try Int.initSet(al, 0xefefefefefefefef);2024 var a = try Int.initSet(testing.allocator, 0xefefefefefefefef);
1934 var b = try Int.initSet(al, 0);2025 defer a.deinit();
2026 var b = try Int.initSet(testing.allocator, 0);
2027 defer b.deinit();
19352028
1936 var c = try Int.init(al);2029 var c = try Int.init(testing.allocator);
2030 defer c.deinit();
1937 try c.mul(a, b);2031 try c.mul(a, b);
19382032
1939 testing.expect((try c.to(u32)) == 0);2033 testing.expect((try c.to(u32)) == 0);
1940}2034}
19412035
1942test "big.int mul 0*0" {2036test "big.int mul 0*0" {
1943 var a = try Int.initSet(al, 0);2037 var a = try Int.initSet(testing.allocator, 0);
1944 var b = try Int.initSet(al, 0);2038 defer a.deinit();
2039 var b = try Int.initSet(testing.allocator, 0);
2040 defer b.deinit();
19452041
1946 var c = try Int.init(al);2042 var c = try Int.init(testing.allocator);
2043 defer c.deinit();
1947 try c.mul(a, b);2044 try c.mul(a, b);
19482045
1949 testing.expect((try c.to(u32)) == 0);2046 testing.expect((try c.to(u32)) == 0);
1950}2047}
19512048
1952test "big.int div single-single no rem" {2049test "big.int div single-single no rem" {
1953 var a = try Int.initSet(al, 50);2050 var a = try Int.initSet(testing.allocator, 50);
1954 var b = try Int.initSet(al, 5);2051 defer a.deinit();
19552052 var b = try Int.initSet(testing.allocator, 5);
1956 var q = try Int.init(al);2053 defer b.deinit();
1957 var r = try Int.init(al);2054
2055 var q = try Int.init(testing.allocator);
2056 defer q.deinit();
2057 var r = try Int.init(testing.allocator);
2058 defer r.deinit();
1958 try Int.divTrunc(&q, &r, a, b);2059 try Int.divTrunc(&q, &r, a, b);
19592060
1960 testing.expect((try q.to(u32)) == 10);2061 testing.expect((try q.to(u32)) == 10);
...@@ -1962,11 +2063,15 @@ test "big.int div single-single no rem" {...@@ -1962,11 +2063,15 @@ test "big.int div single-single no rem" {
1962}2063}
19632064
1964test "big.int div single-single with rem" {2065test "big.int div single-single with rem" {
1965 var a = try Int.initSet(al, 49);2066 var a = try Int.initSet(testing.allocator, 49);
1966 var b = try Int.initSet(al, 5);2067 defer a.deinit();
19672068 var b = try Int.initSet(testing.allocator, 5);
1968 var q = try Int.init(al);2069 defer b.deinit();
1969 var r = try Int.init(al);2070
2071 var q = try Int.init(testing.allocator);
2072 defer q.deinit();
2073 var r = try Int.init(testing.allocator);
2074 defer r.deinit();
1970 try Int.divTrunc(&q, &r, a, b);2075 try Int.divTrunc(&q, &r, a, b);
19712076
1972 testing.expect((try q.to(u32)) == 9);2077 testing.expect((try q.to(u32)) == 9);
...@@ -1977,11 +2082,15 @@ test "big.int div multi-single no rem" {...@@ -1977,11 +2082,15 @@ test "big.int div multi-single no rem" {
1977 const op1 = 0xffffeeeeddddcccc;2082 const op1 = 0xffffeeeeddddcccc;
1978 const op2 = 34;2083 const op2 = 34;
19792084
1980 var a = try Int.initSet(al, op1);2085 var a = try Int.initSet(testing.allocator, op1);
1981 var b = try Int.initSet(al, op2);2086 defer a.deinit();
2087 var b = try Int.initSet(testing.allocator, op2);
2088 defer b.deinit();
19822089
1983 var q = try Int.init(al);2090 var q = try Int.init(testing.allocator);
1984 var r = try Int.init(al);2091 defer q.deinit();
2092 var r = try Int.init(testing.allocator);
2093 defer r.deinit();
1985 try Int.divTrunc(&q, &r, a, b);2094 try Int.divTrunc(&q, &r, a, b);
19862095
1987 testing.expect((try q.to(u64)) == op1 / op2);2096 testing.expect((try q.to(u64)) == op1 / op2);
...@@ -1992,11 +2101,15 @@ test "big.int div multi-single with rem" {...@@ -1992,11 +2101,15 @@ test "big.int div multi-single with rem" {
1992 const op1 = 0xffffeeeeddddcccf;2101 const op1 = 0xffffeeeeddddcccf;
1993 const op2 = 34;2102 const op2 = 34;
19942103
1995 var a = try Int.initSet(al, op1);2104 var a = try Int.initSet(testing.allocator, op1);
1996 var b = try Int.initSet(al, op2);2105 defer a.deinit();
2106 var b = try Int.initSet(testing.allocator, op2);
2107 defer b.deinit();
19972108
1998 var q = try Int.init(al);2109 var q = try Int.init(testing.allocator);
1999 var r = try Int.init(al);2110 defer q.deinit();
2111 var r = try Int.init(testing.allocator);
2112 defer r.deinit();
2000 try Int.divTrunc(&q, &r, a, b);2113 try Int.divTrunc(&q, &r, a, b);
20012114
2002 testing.expect((try q.to(u64)) == op1 / op2);2115 testing.expect((try q.to(u64)) == op1 / op2);
...@@ -2007,11 +2120,15 @@ test "big.int div multi>2-single" {...@@ -2007,11 +2120,15 @@ test "big.int div multi>2-single" {
2007 const op1 = 0xfefefefefefefefefefefefefefefefe;2120 const op1 = 0xfefefefefefefefefefefefefefefefe;
2008 const op2 = 0xefab8;2121 const op2 = 0xefab8;
20092122
2010 var a = try Int.initSet(al, op1);2123 var a = try Int.initSet(testing.allocator, op1);
2011 var b = try Int.initSet(al, op2);2124 defer a.deinit();
2125 var b = try Int.initSet(testing.allocator, op2);
2126 defer b.deinit();
20122127
2013 var q = try Int.init(al);2128 var q = try Int.init(testing.allocator);
2014 var r = try Int.init(al);2129 defer q.deinit();
2130 var r = try Int.init(testing.allocator);
2131 defer r.deinit();
2015 try Int.divTrunc(&q, &r, a, b);2132 try Int.divTrunc(&q, &r, a, b);
20162133
2017 testing.expect((try q.to(u128)) == op1 / op2);2134 testing.expect((try q.to(u128)) == op1 / op2);
...@@ -2019,11 +2136,15 @@ test "big.int div multi>2-single" {...@@ -2019,11 +2136,15 @@ test "big.int div multi>2-single" {
2019}2136}
20202137
2021test "big.int div single-single q < r" {2138test "big.int div single-single q < r" {
2022 var a = try Int.initSet(al, 0x0078f432);2139 var a = try Int.initSet(testing.allocator, 0x0078f432);
2023 var b = try Int.initSet(al, 0x01000000);2140 defer a.deinit();
20242141 var b = try Int.initSet(testing.allocator, 0x01000000);
2025 var q = try Int.init(al);2142 defer b.deinit();
2026 var r = try Int.init(al);2143
2144 var q = try Int.init(testing.allocator);
2145 defer q.deinit();
2146 var r = try Int.init(testing.allocator);
2147 defer r.deinit();
2027 try Int.divTrunc(&q, &r, a, b);2148 try Int.divTrunc(&q, &r, a, b);
20282149
2029 testing.expect((try q.to(u64)) == 0);2150 testing.expect((try q.to(u64)) == 0);
...@@ -2031,11 +2152,15 @@ test "big.int div single-single q < r" {...@@ -2031,11 +2152,15 @@ test "big.int div single-single q < r" {
2031}2152}
20322153
2033test "big.int div single-single q == r" {2154test "big.int div single-single q == r" {
2034 var a = try Int.initSet(al, 10);2155 var a = try Int.initSet(testing.allocator, 10);
2035 var b = try Int.initSet(al, 10);2156 defer a.deinit();
20362157 var b = try Int.initSet(testing.allocator, 10);
2037 var q = try Int.init(al);2158 defer b.deinit();
2038 var r = try Int.init(al);2159
2160 var q = try Int.init(testing.allocator);
2161 defer q.deinit();
2162 var r = try Int.init(testing.allocator);
2163 defer r.deinit();
2039 try Int.divTrunc(&q, &r, a, b);2164 try Int.divTrunc(&q, &r, a, b);
20402165
2041 testing.expect((try q.to(u64)) == 1);2166 testing.expect((try q.to(u64)) == 1);
...@@ -2043,8 +2168,10 @@ test "big.int div single-single q == r" {...@@ -2043,8 +2168,10 @@ test "big.int div single-single q == r" {
2043}2168}
20442169
2045test "big.int div q=0 alias" {2170test "big.int div q=0 alias" {
2046 var a = try Int.initSet(al, 3);2171 var a = try Int.initSet(testing.allocator, 3);
2047 var b = try Int.initSet(al, 10);2172 defer a.deinit();
2173 var b = try Int.initSet(testing.allocator, 10);
2174 defer b.deinit();
20482175
2049 try Int.divTrunc(&a, &b, a, b);2176 try Int.divTrunc(&a, &b, a, b);
20502177
...@@ -2055,11 +2182,15 @@ test "big.int div q=0 alias" {...@@ -2055,11 +2182,15 @@ test "big.int div q=0 alias" {
2055test "big.int div multi-multi q < r" {2182test "big.int div multi-multi q < r" {
2056 const op1 = 0x1ffffffff0078f432;2183 const op1 = 0x1ffffffff0078f432;
2057 const op2 = 0x1ffffffff01000000;2184 const op2 = 0x1ffffffff01000000;
2058 var a = try Int.initSet(al, op1);2185 var a = try Int.initSet(testing.allocator, op1);
2059 var b = try Int.initSet(al, op2);2186 defer a.deinit();
20602187 var b = try Int.initSet(testing.allocator, op2);
2061 var q = try Int.init(al);2188 defer b.deinit();
2062 var r = try Int.init(al);2189
2190 var q = try Int.init(testing.allocator);
2191 defer q.deinit();
2192 var r = try Int.init(testing.allocator);
2193 defer r.deinit();
2063 try Int.divTrunc(&q, &r, a, b);2194 try Int.divTrunc(&q, &r, a, b);
20642195
2065 testing.expect((try q.to(u128)) == 0);2196 testing.expect((try q.to(u128)) == 0);
...@@ -2070,11 +2201,15 @@ test "big.int div trunc single-single +/+" {...@@ -2070,11 +2201,15 @@ test "big.int div trunc single-single +/+" {
2070 const u: i32 = 5;2201 const u: i32 = 5;
2071 const v: i32 = 3;2202 const v: i32 = 3;
20722203
2073 var a = try Int.initSet(al, u);2204 var a = try Int.initSet(testing.allocator, u);
2074 var b = try Int.initSet(al, v);2205 defer a.deinit();
2206 var b = try Int.initSet(testing.allocator, v);
2207 defer b.deinit();
20752208
2076 var q = try Int.init(al);2209 var q = try Int.init(testing.allocator);
2077 var r = try Int.init(al);2210 defer q.deinit();
2211 var r = try Int.init(testing.allocator);
2212 defer r.deinit();
2078 try Int.divTrunc(&q, &r, a, b);2213 try Int.divTrunc(&q, &r, a, b);
20792214
2080 // n = q * d + r2215 // n = q * d + r
...@@ -2090,11 +2225,15 @@ test "big.int div trunc single-single -/+" {...@@ -2090,11 +2225,15 @@ test "big.int div trunc single-single -/+" {
2090 const u: i32 = -5;2225 const u: i32 = -5;
2091 const v: i32 = 3;2226 const v: i32 = 3;
20922227
2093 var a = try Int.initSet(al, u);2228 var a = try Int.initSet(testing.allocator, u);
2094 var b = try Int.initSet(al, v);2229 defer a.deinit();
2230 var b = try Int.initSet(testing.allocator, v);
2231 defer b.deinit();
20952232
2096 var q = try Int.init(al);2233 var q = try Int.init(testing.allocator);
2097 var r = try Int.init(al);2234 defer q.deinit();
2235 var r = try Int.init(testing.allocator);
2236 defer r.deinit();
2098 try Int.divTrunc(&q, &r, a, b);2237 try Int.divTrunc(&q, &r, a, b);
20992238
2100 // n = q * d + r2239 // n = q * d + r
...@@ -2110,11 +2249,15 @@ test "big.int div trunc single-single +/-" {...@@ -2110,11 +2249,15 @@ test "big.int div trunc single-single +/-" {
2110 const u: i32 = 5;2249 const u: i32 = 5;
2111 const v: i32 = -3;2250 const v: i32 = -3;
21122251
2113 var a = try Int.initSet(al, u);2252 var a = try Int.initSet(testing.allocator, u);
2114 var b = try Int.initSet(al, v);2253 defer a.deinit();
2254 var b = try Int.initSet(testing.allocator, v);
2255 defer b.deinit();
21152256
2116 var q = try Int.init(al);2257 var q = try Int.init(testing.allocator);
2117 var r = try Int.init(al);2258 defer q.deinit();
2259 var r = try Int.init(testing.allocator);
2260 defer r.deinit();
2118 try Int.divTrunc(&q, &r, a, b);2261 try Int.divTrunc(&q, &r, a, b);
21192262
2120 // n = q * d + r2263 // n = q * d + r
...@@ -2130,11 +2273,15 @@ test "big.int div trunc single-single -/-" {...@@ -2130,11 +2273,15 @@ test "big.int div trunc single-single -/-" {
2130 const u: i32 = -5;2273 const u: i32 = -5;
2131 const v: i32 = -3;2274 const v: i32 = -3;
21322275
2133 var a = try Int.initSet(al, u);2276 var a = try Int.initSet(testing.allocator, u);
2134 var b = try Int.initSet(al, v);2277 defer a.deinit();
2278 var b = try Int.initSet(testing.allocator, v);
2279 defer b.deinit();
21352280
2136 var q = try Int.init(al);2281 var q = try Int.init(testing.allocator);
2137 var r = try Int.init(al);2282 defer q.deinit();
2283 var r = try Int.init(testing.allocator);
2284 defer r.deinit();
2138 try Int.divTrunc(&q, &r, a, b);2285 try Int.divTrunc(&q, &r, a, b);
21392286
2140 // n = q * d + r2287 // n = q * d + r
...@@ -2150,11 +2297,15 @@ test "big.int div floor single-single +/+" {...@@ -2150,11 +2297,15 @@ test "big.int div floor single-single +/+" {
2150 const u: i32 = 5;2297 const u: i32 = 5;
2151 const v: i32 = 3;2298 const v: i32 = 3;
21522299
2153 var a = try Int.initSet(al, u);2300 var a = try Int.initSet(testing.allocator, u);
2154 var b = try Int.initSet(al, v);2301 defer a.deinit();
2302 var b = try Int.initSet(testing.allocator, v);
2303 defer b.deinit();
21552304
2156 var q = try Int.init(al);2305 var q = try Int.init(testing.allocator);
2157 var r = try Int.init(al);2306 defer q.deinit();
2307 var r = try Int.init(testing.allocator);
2308 defer r.deinit();
2158 try Int.divFloor(&q, &r, a, b);2309 try Int.divFloor(&q, &r, a, b);
21592310
2160 // n = q * d + r2311 // n = q * d + r
...@@ -2170,11 +2321,15 @@ test "big.int div floor single-single -/+" {...@@ -2170,11 +2321,15 @@ test "big.int div floor single-single -/+" {
2170 const u: i32 = -5;2321 const u: i32 = -5;
2171 const v: i32 = 3;2322 const v: i32 = 3;
21722323
2173 var a = try Int.initSet(al, u);2324 var a = try Int.initSet(testing.allocator, u);
2174 var b = try Int.initSet(al, v);2325 defer a.deinit();
2326 var b = try Int.initSet(testing.allocator, v);
2327 defer b.deinit();
21752328
2176 var q = try Int.init(al);2329 var q = try Int.init(testing.allocator);
2177 var r = try Int.init(al);2330 defer q.deinit();
2331 var r = try Int.init(testing.allocator);
2332 defer r.deinit();
2178 try Int.divFloor(&q, &r, a, b);2333 try Int.divFloor(&q, &r, a, b);
21792334
2180 // n = q * d + r2335 // n = q * d + r
...@@ -2190,11 +2345,15 @@ test "big.int div floor single-single +/-" {...@@ -2190,11 +2345,15 @@ test "big.int div floor single-single +/-" {
2190 const u: i32 = 5;2345 const u: i32 = 5;
2191 const v: i32 = -3;2346 const v: i32 = -3;
21922347
2193 var a = try Int.initSet(al, u);2348 var a = try Int.initSet(testing.allocator, u);
2194 var b = try Int.initSet(al, v);2349 defer a.deinit();
2350 var b = try Int.initSet(testing.allocator, v);
2351 defer b.deinit();
21952352
2196 var q = try Int.init(al);2353 var q = try Int.init(testing.allocator);
2197 var r = try Int.init(al);2354 defer q.deinit();
2355 var r = try Int.init(testing.allocator);
2356 defer r.deinit();
2198 try Int.divFloor(&q, &r, a, b);2357 try Int.divFloor(&q, &r, a, b);
21992358
2200 // n = q * d + r2359 // n = q * d + r
...@@ -2210,11 +2369,15 @@ test "big.int div floor single-single -/-" {...@@ -2210,11 +2369,15 @@ test "big.int div floor single-single -/-" {
2210 const u: i32 = -5;2369 const u: i32 = -5;
2211 const v: i32 = -3;2370 const v: i32 = -3;
22122371
2213 var a = try Int.initSet(al, u);2372 var a = try Int.initSet(testing.allocator, u);
2214 var b = try Int.initSet(al, v);2373 defer a.deinit();
2374 var b = try Int.initSet(testing.allocator, v);
2375 defer b.deinit();
22152376
2216 var q = try Int.init(al);2377 var q = try Int.init(testing.allocator);
2217 var r = try Int.init(al);2378 defer q.deinit();
2379 var r = try Int.init(testing.allocator);
2380 defer r.deinit();
2218 try Int.divFloor(&q, &r, a, b);2381 try Int.divFloor(&q, &r, a, b);
22192382
2220 // n = q * d + r2383 // n = q * d + r
...@@ -2227,11 +2390,15 @@ test "big.int div floor single-single -/-" {...@@ -2227,11 +2390,15 @@ test "big.int div floor single-single -/-" {
2227}2390}
22282391
2229test "big.int div multi-multi with rem" {2392test "big.int div multi-multi with rem" {
2230 var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);2393 var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
2231 var b = try Int.initSet(al, 0x99990000111122223333);2394 defer a.deinit();
22322395 var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
2233 var q = try Int.init(al);2396 defer b.deinit();
2234 var r = try Int.init(al);2397
2398 var q = try Int.init(testing.allocator);
2399 defer q.deinit();
2400 var r = try Int.init(testing.allocator);
2401 defer r.deinit();
2235 try Int.divTrunc(&q, &r, a, b);2402 try Int.divTrunc(&q, &r, a, b);
22362403
2237 testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);2404 testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...@@ -2239,11 +2406,15 @@ test "big.int div multi-multi with rem" {...@@ -2239,11 +2406,15 @@ test "big.int div multi-multi with rem" {
2239}2406}
22402407
2241test "big.int div multi-multi no rem" {2408test "big.int div multi-multi no rem" {
2242 var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);2409 var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
2243 var b = try Int.initSet(al, 0x99990000111122223333);2410 defer a.deinit();
22442411 var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
2245 var q = try Int.init(al);2412 defer b.deinit();
2246 var r = try Int.init(al);2413
2414 var q = try Int.init(testing.allocator);
2415 defer q.deinit();
2416 var r = try Int.init(testing.allocator);
2417 defer r.deinit();
2247 try Int.divTrunc(&q, &r, a, b);2418 try Int.divTrunc(&q, &r, a, b);
22482419
2249 testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);2420 testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...@@ -2251,11 +2422,15 @@ test "big.int div multi-multi no rem" {...@@ -2251,11 +2422,15 @@ test "big.int div multi-multi no rem" {
2251}2422}
22522423
2253test "big.int div multi-multi (2 branch)" {2424test "big.int div multi-multi (2 branch)" {
2254 var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);2425 var a = try Int.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111);
2255 var b = try Int.initSet(al, 0x86666666555555554444444433333333);2426 defer a.deinit();
22562427 var b = try Int.initSet(testing.allocator, 0x86666666555555554444444433333333);
2257 var q = try Int.init(al);2428 defer b.deinit();
2258 var r = try Int.init(al);2429
2430 var q = try Int.init(testing.allocator);
2431 defer q.deinit();
2432 var r = try Int.init(testing.allocator);
2433 defer r.deinit();
2259 try Int.divTrunc(&q, &r, a, b);2434 try Int.divTrunc(&q, &r, a, b);
22602435
2261 testing.expect((try q.to(u128)) == 0x10000000000000000);2436 testing.expect((try q.to(u128)) == 0x10000000000000000);
...@@ -2263,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" {...@@ -2263,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" {
2263}2438}
22642439
2265test "big.int div multi-multi (3.1/3.3 branch)" {2440test "big.int div multi-multi (3.1/3.3 branch)" {
2266 var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);2441 var a = try Int.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
2267 var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);2442 defer a.deinit();
22682443 var b = try Int.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171);
2269 var q = try Int.init(al);2444 defer b.deinit();
2270 var r = try Int.init(al);2445
2446 var q = try Int.init(testing.allocator);
2447 defer q.deinit();
2448 var r = try Int.init(testing.allocator);
2449 defer r.deinit();
2271 try Int.divTrunc(&q, &r, a, b);2450 try Int.divTrunc(&q, &r, a, b);
22722451
2273 testing.expect((try q.to(u128)) == 0xfffffffffffffffffff);2452 testing.expect((try q.to(u128)) == 0xfffffffffffffffffff);
...@@ -2275,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" {...@@ -2275,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
2275}2454}
22762455
2277test "big.int div multi-single zero-limb trailing" {2456test "big.int div multi-single zero-limb trailing" {
2278 var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000);2457 var a = try Int.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000);
2279 var b = try Int.initSet(al, 0x10000000000000000);2458 defer a.deinit();
22802459 var b = try Int.initSet(testing.allocator, 0x10000000000000000);
2281 var q = try Int.init(al);2460 defer b.deinit();
2282 var r = try Int.init(al);2461
2462 var q = try Int.init(testing.allocator);
2463 defer q.deinit();
2464 var r = try Int.init(testing.allocator);
2465 defer r.deinit();
2283 try Int.divTrunc(&q, &r, a, b);2466 try Int.divTrunc(&q, &r, a, b);
22842467
2285 var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000);2468 var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000);
2469 defer expected.deinit();
2286 testing.expect(q.eq(expected));2470 testing.expect(q.eq(expected));
2287 testing.expect(r.eqZero());2471 testing.expect(r.eqZero());
2288}2472}
22892473
2290test "big.int div multi-multi zero-limb trailing (with rem)" {2474test "big.int div multi-multi zero-limb trailing (with rem)" {
2291 var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);2475 var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
2292 var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);2476 defer a.deinit();
22932477 var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
2294 var q = try Int.init(al);2478 defer b.deinit();
2295 var r = try Int.init(al);2479
2480 var q = try Int.init(testing.allocator);
2481 defer q.deinit();
2482 var r = try Int.init(testing.allocator);
2483 defer r.deinit();
2296 try Int.divTrunc(&q, &r, a, b);2484 try Int.divTrunc(&q, &r, a, b);
22972485
2298 testing.expect((try q.to(u128)) == 0x10000000000000000);2486 testing.expect((try q.to(u128)) == 0x10000000000000000);
22992487
2300 const rs = try r.toString(al, 16);2488 const rs = try r.toString(testing.allocator, 16);
2489 defer testing.allocator.free(rs);
2301 testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));2490 testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));
2302}2491}
23032492
2304test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {2493test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
2305 var a = try Int.initSet(al, 0x8666666655555555888888877777777611111111111111110000000000000000);2494 var a = try Int.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
2306 var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);2495 defer a.deinit();
23072496 var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
2308 var q = try Int.init(al);2497 defer b.deinit();
2309 var r = try Int.init(al);2498
2499 var q = try Int.init(testing.allocator);
2500 defer q.deinit();
2501 var r = try Int.init(testing.allocator);
2502 defer r.deinit();
2310 try Int.divTrunc(&q, &r, a, b);2503 try Int.divTrunc(&q, &r, a, b);
23112504
2312 testing.expect((try q.to(u128)) == 0x1);2505 testing.expect((try q.to(u128)) == 0x1);
23132506
2314 const rs = try r.toString(al, 16);2507 const rs = try r.toString(testing.allocator, 16);
2508 defer testing.allocator.free(rs);
2315 testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));2509 testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));
2316}2510}
23172511
2318test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {2512test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
2319 var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);2513 var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
2320 var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000);2514 defer a.deinit();
23212515 var b = try Int.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000);
2322 var q = try Int.init(al);2516 defer b.deinit();
2323 var r = try Int.init(al);2517
2518 var q = try Int.init(testing.allocator);
2519 defer q.deinit();
2520 var r = try Int.init(testing.allocator);
2521 defer r.deinit();
2324 try Int.divTrunc(&q, &r, a, b);2522 try Int.divTrunc(&q, &r, a, b);
23252523
2326 const qs = try q.toString(al, 16);2524 const qs = try q.toString(testing.allocator, 16);
2525 defer testing.allocator.free(qs);
2327 testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f"));2526 testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f"));
23282527
2329 const rs = try r.toString(al, 16);2528 const rs = try r.toString(testing.allocator, 16);
2529 defer testing.allocator.free(rs);
2330 testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));2530 testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));
2331}2531}
23322532
2333test "big.int div multi-multi fuzz case #1" {2533test "big.int div multi-multi fuzz case #1" {
2334 var a = try Int.init(al);2534 var a = try Int.init(testing.allocator);
2335 var b = try Int.init(al);2535 defer a.deinit();
2536 var b = try Int.init(testing.allocator);
2537 defer b.deinit();
23362538
2337 try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");2539 try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
2338 try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff");2540 try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff");
23392541
2340 var q = try Int.init(al);2542 var q = try Int.init(testing.allocator);
2341 var r = try Int.init(al);2543 defer q.deinit();
2544 var r = try Int.init(testing.allocator);
2545 defer r.deinit();
2342 try Int.divTrunc(&q, &r, a, b);2546 try Int.divTrunc(&q, &r, a, b);
23432547
2344 const qs = try q.toString(al, 16);2548 const qs = try q.toString(testing.allocator, 16);
2549 defer testing.allocator.free(qs);
2345 testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1"));2550 testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1"));
23462551
2347 const rs = try r.toString(al, 16);2552 const rs = try r.toString(testing.allocator, 16);
2553 defer testing.allocator.free(rs);
2348 testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));2554 testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));
2349}2555}
23502556
2351test "big.int div multi-multi fuzz case #2" {2557test "big.int div multi-multi fuzz case #2" {
2352 var a = try Int.init(al);2558 var a = try Int.init(testing.allocator);
2353 var b = try Int.init(al);2559 defer a.deinit();
2560 var b = try Int.init(testing.allocator);
2561 defer b.deinit();
23542562
2355 try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000");2563 try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000");
2356 try b.setString(16, "ffc0000000000000000000000000000000000000000000000000");2564 try b.setString(16, "ffc0000000000000000000000000000000000000000000000000");
23572565
2358 var q = try Int.init(al);2566 var q = try Int.init(testing.allocator);
2359 var r = try Int.init(al);2567 defer q.deinit();
2568 var r = try Int.init(testing.allocator);
2569 defer r.deinit();
2360 try Int.divTrunc(&q, &r, a, b);2570 try Int.divTrunc(&q, &r, a, b);
23612571
2362 const qs = try q.toString(al, 16);2572 const qs = try q.toString(testing.allocator, 16);
2573 defer testing.allocator.free(qs);
2363 testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4"));2574 testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4"));
23642575
2365 const rs = try r.toString(al, 16);2576 const rs = try r.toString(testing.allocator, 16);
2577 defer testing.allocator.free(rs);
2366 testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));2578 testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));
2367}2579}
23682580
2369test "big.int shift-right single" {2581test "big.int shift-right single" {
2370 var a = try Int.initSet(al, 0xffff0000);2582 var a = try Int.initSet(testing.allocator, 0xffff0000);
2583 defer a.deinit();
2371 try a.shiftRight(a, 16);2584 try a.shiftRight(a, 16);
23722585
2373 testing.expect((try a.to(u32)) == 0xffff);2586 testing.expect((try a.to(u32)) == 0xffff);
2374}2587}
23752588
2376test "big.int shift-right multi" {2589test "big.int shift-right multi" {
2377 var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333);2590 var a = try Int.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333);
2591 defer a.deinit();
2378 try a.shiftRight(a, 67);2592 try a.shiftRight(a, 67);
23792593
2380 testing.expect((try a.to(u64)) == 0x1fffe0001dddc222);2594 testing.expect((try a.to(u64)) == 0x1fffe0001dddc222);
2381}2595}
23822596
2383test "big.int shift-left single" {2597test "big.int shift-left single" {
2384 var a = try Int.initSet(al, 0xffff);2598 var a = try Int.initSet(testing.allocator, 0xffff);
2599 defer a.deinit();
2385 try a.shiftLeft(a, 16);2600 try a.shiftLeft(a, 16);
23862601
2387 testing.expect((try a.to(u64)) == 0xffff0000);2602 testing.expect((try a.to(u64)) == 0xffff0000);
2388}2603}
23892604
2390test "big.int shift-left multi" {2605test "big.int shift-left multi" {
2391 var a = try Int.initSet(al, 0x1fffe0001dddc222);2606 var a = try Int.initSet(testing.allocator, 0x1fffe0001dddc222);
2607 defer a.deinit();
2392 try a.shiftLeft(a, 67);2608 try a.shiftLeft(a, 67);
23932609
2394 testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);2610 testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
2395}2611}
23962612
2397test "big.int shift-right negative" {2613test "big.int shift-right negative" {
2398 var a = try Int.init(al);2614 var a = try Int.init(testing.allocator);
2615 defer a.deinit();
23992616
2400 try a.shiftRight(try Int.initSet(al, -20), 2);2617 try a.shiftRight(try Int.initSet(testing.allocator, -20), 2);
2618 defer a.deinit();
2401 testing.expect((try a.to(i32)) == -20 >> 2);2619 testing.expect((try a.to(i32)) == -20 >> 2);
24022620
2403 try a.shiftRight(try Int.initSet(al, -5), 10);2621 try a.shiftRight(try Int.initSet(testing.allocator, -5), 10);
2622 defer a.deinit();
2404 testing.expect((try a.to(i32)) == -5 >> 10);2623 testing.expect((try a.to(i32)) == -5 >> 10);
2405}2624}
24062625
2407test "big.int shift-left negative" {2626test "big.int shift-left negative" {
2408 var a = try Int.init(al);2627 var a = try Int.init(testing.allocator);
2628 defer a.deinit();
24092629
2410 try a.shiftRight(try Int.initSet(al, -10), 1232);2630 try a.shiftRight(try Int.initSet(testing.allocator, -10), 1232);
2631 defer a.deinit();
2411 testing.expect((try a.to(i32)) == -10 >> 1232);2632 testing.expect((try a.to(i32)) == -10 >> 1232);
2412}2633}
24132634
2414test "big.int bitwise and simple" {2635test "big.int bitwise and simple" {
2415 var a = try Int.initSet(al, 0xffffffff11111111);2636 var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
2416 var b = try Int.initSet(al, 0xeeeeeeee22222222);2637 defer a.deinit();
2638 var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
2639 defer b.deinit();
24172640
2418 try a.bitAnd(a, b);2641 try a.bitAnd(a, b);
24192642
...@@ -2421,8 +2644,10 @@ test "big.int bitwise and simple" {...@@ -2421,8 +2644,10 @@ test "big.int bitwise and simple" {
2421}2644}
24222645
2423test "big.int bitwise and multi-limb" {2646test "big.int bitwise and multi-limb" {
2424 var a = try Int.initSet(al, maxInt(Limb) + 1);2647 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
2425 var b = try Int.initSet(al, maxInt(Limb));2648 defer a.deinit();
2649 var b = try Int.initSet(testing.allocator, maxInt(Limb));
2650 defer b.deinit();
24262651
2427 try a.bitAnd(a, b);2652 try a.bitAnd(a, b);
24282653
...@@ -2430,8 +2655,10 @@ test "big.int bitwise and multi-limb" {...@@ -2430,8 +2655,10 @@ test "big.int bitwise and multi-limb" {
2430}2655}
24312656
2432test "big.int bitwise xor simple" {2657test "big.int bitwise xor simple" {
2433 var a = try Int.initSet(al, 0xffffffff11111111);2658 var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
2434 var b = try Int.initSet(al, 0xeeeeeeee22222222);2659 defer a.deinit();
2660 var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
2661 defer b.deinit();
24352662
2436 try a.bitXor(a, b);2663 try a.bitXor(a, b);
24372664
...@@ -2439,8 +2666,10 @@ test "big.int bitwise xor simple" {...@@ -2439,8 +2666,10 @@ test "big.int bitwise xor simple" {
2439}2666}
24402667
2441test "big.int bitwise xor multi-limb" {2668test "big.int bitwise xor multi-limb" {
2442 var a = try Int.initSet(al, maxInt(Limb) + 1);2669 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
2443 var b = try Int.initSet(al, maxInt(Limb));2670 defer a.deinit();
2671 var b = try Int.initSet(testing.allocator, maxInt(Limb));
2672 defer b.deinit();
24442673
2445 try a.bitXor(a, b);2674 try a.bitXor(a, b);
24462675
...@@ -2448,8 +2677,10 @@ test "big.int bitwise xor multi-limb" {...@@ -2448,8 +2677,10 @@ test "big.int bitwise xor multi-limb" {
2448}2677}
24492678
2450test "big.int bitwise or simple" {2679test "big.int bitwise or simple" {
2451 var a = try Int.initSet(al, 0xffffffff11111111);2680 var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
2452 var b = try Int.initSet(al, 0xeeeeeeee22222222);2681 defer a.deinit();
2682 var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
2683 defer b.deinit();
24532684
2454 try a.bitOr(a, b);2685 try a.bitOr(a, b);
24552686
...@@ -2457,8 +2688,10 @@ test "big.int bitwise or simple" {...@@ -2457,8 +2688,10 @@ test "big.int bitwise or simple" {
2457}2688}
24582689
2459test "big.int bitwise or multi-limb" {2690test "big.int bitwise or multi-limb" {
2460 var a = try Int.initSet(al, maxInt(Limb) + 1);2691 var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
2461 var b = try Int.initSet(al, maxInt(Limb));2692 defer a.deinit();
2693 var b = try Int.initSet(testing.allocator, maxInt(Limb));
2694 defer b.deinit();
24622695
2463 try a.bitOr(a, b);2696 try a.bitOr(a, b);
24642697
...@@ -2467,11 +2700,19 @@ test "big.int bitwise or multi-limb" {...@@ -2467,11 +2700,19 @@ test "big.int bitwise or multi-limb" {
2467}2700}
24682701
2469test "big.int var args" {2702test "big.int var args" {
2470 var a = try Int.initSet(al, 5);2703 var a = try Int.initSet(testing.allocator, 5);
2704 defer a.deinit();
24712705
2472 try a.add(a, try Int.initSet(al, 6));2706 const b = try Int.initSet(testing.allocator, 6);
2707 defer b.deinit();
2708 try a.add(a, b);
2473 testing.expect((try a.to(u64)) == 11);2709 testing.expect((try a.to(u64)) == 11);
24742710
2475 testing.expect(a.cmp(try Int.initSet(al, 11)) == 0);2711 const c = try Int.initSet(testing.allocator, 11);
2476 testing.expect(a.cmp(try Int.initSet(al, 14)) <= 0);2712 defer c.deinit();
2713 testing.expect(a.cmp(c) == 0);
2714
2715 const d = try Int.initSet(testing.allocator, 14);
2716 defer d.deinit();
2717 testing.expect(a.cmp(d) <= 0);
2477}2718}
lib/std/math/big/rational.zig+98-53
...@@ -587,14 +587,13 @@ fn gcdLehmer(r: *Int, xa: Int, ya: Int) !void {...@@ -587,14 +587,13 @@ fn gcdLehmer(r: *Int, xa: Int, ya: Int) !void {
587 r.swap(&x);587 r.swap(&x);
588}588}
589589
590var buffer: [64 * 8192]u8 = undefined;
591var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
592var al = &fixed.allocator;
593
594test "big.rational gcd non-one small" {590test "big.rational gcd non-one small" {
595 var a = try Int.initSet(al, 17);591 var a = try Int.initSet(testing.allocator, 17);
596 var b = try Int.initSet(al, 97);592 defer a.deinit();
597 var r = try Int.init(al);593 var b = try Int.initSet(testing.allocator, 97);
594 defer b.deinit();
595 var r = try Int.init(testing.allocator);
596 defer r.deinit();
598597
599 try gcd(&r, a, b);598 try gcd(&r, a, b);
600599
...@@ -602,9 +601,12 @@ test "big.rational gcd non-one small" {...@@ -602,9 +601,12 @@ test "big.rational gcd non-one small" {
602}601}
603602
604test "big.rational gcd non-one small" {603test "big.rational gcd non-one small" {
605 var a = try Int.initSet(al, 4864);604 var a = try Int.initSet(testing.allocator, 4864);
606 var b = try Int.initSet(al, 3458);605 defer a.deinit();
607 var r = try Int.init(al);606 var b = try Int.initSet(testing.allocator, 3458);
607 defer b.deinit();
608 var r = try Int.init(testing.allocator);
609 defer r.deinit();
608610
609 try gcd(&r, a, b);611 try gcd(&r, a, b);
610612
...@@ -612,9 +614,12 @@ test "big.rational gcd non-one small" {...@@ -612,9 +614,12 @@ test "big.rational gcd non-one small" {
612}614}
613615
614test "big.rational gcd non-one large" {616test "big.rational gcd non-one large" {
615 var a = try Int.initSet(al, 0xffffffffffffffff);617 var a = try Int.initSet(testing.allocator, 0xffffffffffffffff);
616 var b = try Int.initSet(al, 0xffffffffffffffff7777);618 defer a.deinit();
617 var r = try Int.init(al);619 var b = try Int.initSet(testing.allocator, 0xffffffffffffffff7777);
620 defer b.deinit();
621 var r = try Int.init(testing.allocator);
622 defer r.deinit();
618623
619 try gcd(&r, a, b);624 try gcd(&r, a, b);
620625
...@@ -622,9 +627,12 @@ test "big.rational gcd non-one large" {...@@ -622,9 +627,12 @@ test "big.rational gcd non-one large" {
622}627}
623628
624test "big.rational gcd large multi-limb result" {629test "big.rational gcd large multi-limb result" {
625 var a = try Int.initSet(al, 0x12345678123456781234567812345678123456781234567812345678);630 var a = try Int.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
626 var b = try Int.initSet(al, 0x12345671234567123456712345671234567123456712345671234567);631 defer a.deinit();
627 var r = try Int.init(al);632 var b = try Int.initSet(testing.allocator, 0x12345671234567123456712345671234567123456712345671234567);
633 defer b.deinit();
634 var r = try Int.init(testing.allocator);
635 defer r.deinit();
628636
629 try gcd(&r, a, b);637 try gcd(&r, a, b);
630638
...@@ -632,9 +640,12 @@ test "big.rational gcd large multi-limb result" {...@@ -632,9 +640,12 @@ test "big.rational gcd large multi-limb result" {
632}640}
633641
634test "big.rational gcd one large" {642test "big.rational gcd one large" {
635 var a = try Int.initSet(al, 1897056385327307);643 var a = try Int.initSet(testing.allocator, 1897056385327307);
636 var b = try Int.initSet(al, 2251799813685248);644 defer a.deinit();
637 var r = try Int.init(al);645 var b = try Int.initSet(testing.allocator, 2251799813685248);
646 defer b.deinit();
647 var r = try Int.init(testing.allocator);
648 defer r.deinit();
638649
639 try gcd(&r, a, b);650 try gcd(&r, a, b);
640651
...@@ -661,7 +672,8 @@ fn extractLowBits(a: Int, comptime T: type) T {...@@ -661,7 +672,8 @@ fn extractLowBits(a: Int, comptime T: type) T {
661}672}
662673
663test "big.rational extractLowBits" {674test "big.rational extractLowBits" {
664 var a = try Int.initSet(al, 0x11112222333344441234567887654321);675 var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321);
676 defer a.deinit();
665677
666 const a1 = extractLowBits(a, u8);678 const a1 = extractLowBits(a, u8);
667 testing.expect(a1 == 0x21);679 testing.expect(a1 == 0x21);
...@@ -680,7 +692,8 @@ test "big.rational extractLowBits" {...@@ -680,7 +692,8 @@ test "big.rational extractLowBits" {
680}692}
681693
682test "big.rational set" {694test "big.rational set" {
683 var a = try Rational.init(al);695 var a = try Rational.init(testing.allocator);
696 defer a.deinit();
684697
685 try a.setInt(5);698 try a.setInt(5);
686 testing.expect((try a.p.to(u32)) == 5);699 testing.expect((try a.p.to(u32)) == 5);
...@@ -708,7 +721,8 @@ test "big.rational set" {...@@ -708,7 +721,8 @@ test "big.rational set" {
708}721}
709722
710test "big.rational setFloat" {723test "big.rational setFloat" {
711 var a = try Rational.init(al);724 var a = try Rational.init(testing.allocator);
725 defer a.deinit();
712726
713 try a.setFloat(f64, 2.5);727 try a.setFloat(f64, 2.5);
714 testing.expect((try a.p.to(i32)) == 5);728 testing.expect((try a.p.to(i32)) == 5);
...@@ -732,7 +746,8 @@ test "big.rational setFloat" {...@@ -732,7 +746,8 @@ test "big.rational setFloat" {
732}746}
733747
734test "big.rational setFloatString" {748test "big.rational setFloatString" {
735 var a = try Rational.init(al);749 var a = try Rational.init(testing.allocator);
750 defer a.deinit();
736751
737 try a.setFloatString("72.14159312071241458852455252781510353");752 try a.setFloatString("72.14159312071241458852455252781510353");
738753
...@@ -742,7 +757,8 @@ test "big.rational setFloatString" {...@@ -742,7 +757,8 @@ test "big.rational setFloatString" {
742}757}
743758
744test "big.rational toFloat" {759test "big.rational toFloat" {
745 var a = try Rational.init(al);760 var a = try Rational.init(testing.allocator);
761 defer a.deinit();
746762
747 // = 3.14159297943115234375763 // = 3.14159297943115234375
748 try a.setRatio(3294199, 1048576);764 try a.setRatio(3294199, 1048576);
...@@ -754,7 +770,8 @@ test "big.rational toFloat" {...@@ -754,7 +770,8 @@ test "big.rational toFloat" {
754}770}
755771
756test "big.rational set/to Float round-trip" {772test "big.rational set/to Float round-trip" {
757 var a = try Rational.init(al);773 var a = try Rational.init(testing.allocator);
774 defer a.deinit();
758 var prng = std.rand.DefaultPrng.init(0x5EED);775 var prng = std.rand.DefaultPrng.init(0x5EED);
759 var i: usize = 0;776 var i: usize = 0;
760 while (i < 512) : (i += 1) {777 while (i < 512) : (i += 1) {
...@@ -765,23 +782,29 @@ test "big.rational set/to Float round-trip" {...@@ -765,23 +782,29 @@ test "big.rational set/to Float round-trip" {
765}782}
766783
767test "big.rational copy" {784test "big.rational copy" {
768 var a = try Rational.init(al);785 var a = try Rational.init(testing.allocator);
786 defer a.deinit();
769787
770 const b = try Int.initSet(al, 5);788 const b = try Int.initSet(testing.allocator, 5);
789 defer b.deinit();
771790
772 try a.copyInt(b);791 try a.copyInt(b);
773 testing.expect((try a.p.to(u32)) == 5);792 testing.expect((try a.p.to(u32)) == 5);
774 testing.expect((try a.q.to(u32)) == 1);793 testing.expect((try a.q.to(u32)) == 1);
775794
776 const c = try Int.initSet(al, 7);795 const c = try Int.initSet(testing.allocator, 7);
777 const d = try Int.initSet(al, 3);796 defer c.deinit();
797 const d = try Int.initSet(testing.allocator, 3);
798 defer d.deinit();
778799
779 try a.copyRatio(c, d);800 try a.copyRatio(c, d);
780 testing.expect((try a.p.to(u32)) == 7);801 testing.expect((try a.p.to(u32)) == 7);
781 testing.expect((try a.q.to(u32)) == 3);802 testing.expect((try a.q.to(u32)) == 3);
782803
783 const e = try Int.initSet(al, 9);804 const e = try Int.initSet(testing.allocator, 9);
784 const f = try Int.initSet(al, 3);805 defer e.deinit();
806 const f = try Int.initSet(testing.allocator, 3);
807 defer f.deinit();
785808
786 try a.copyRatio(e, f);809 try a.copyRatio(e, f);
787 testing.expect((try a.p.to(u32)) == 3);810 testing.expect((try a.p.to(u32)) == 3);
...@@ -789,7 +812,8 @@ test "big.rational copy" {...@@ -789,7 +812,8 @@ test "big.rational copy" {
789}812}
790813
791test "big.rational negate" {814test "big.rational negate" {
792 var a = try Rational.init(al);815 var a = try Rational.init(testing.allocator);
816 defer a.deinit();
793817
794 try a.setInt(-50);818 try a.setInt(-50);
795 testing.expect((try a.p.to(i32)) == -50);819 testing.expect((try a.p.to(i32)) == -50);
...@@ -805,7 +829,8 @@ test "big.rational negate" {...@@ -805,7 +829,8 @@ test "big.rational negate" {
805}829}
806830
807test "big.rational abs" {831test "big.rational abs" {
808 var a = try Rational.init(al);832 var a = try Rational.init(testing.allocator);
833 defer a.deinit();
809834
810 try a.setInt(-50);835 try a.setInt(-50);
811 testing.expect((try a.p.to(i32)) == -50);836 testing.expect((try a.p.to(i32)) == -50);
...@@ -821,8 +846,10 @@ test "big.rational abs" {...@@ -821,8 +846,10 @@ test "big.rational abs" {
821}846}
822847
823test "big.rational swap" {848test "big.rational swap" {
824 var a = try Rational.init(al);849 var a = try Rational.init(testing.allocator);
825 var b = try Rational.init(al);850 defer a.deinit();
851 var b = try Rational.init(testing.allocator);
852 defer b.deinit();
826853
827 try a.setRatio(50, 23);854 try a.setRatio(50, 23);
828 try b.setRatio(17, 3);855 try b.setRatio(17, 3);
...@@ -843,8 +870,10 @@ test "big.rational swap" {...@@ -843,8 +870,10 @@ test "big.rational swap" {
843}870}
844871
845test "big.rational cmp" {872test "big.rational cmp" {
846 var a = try Rational.init(al);873 var a = try Rational.init(testing.allocator);
847 var b = try Rational.init(al);874 defer a.deinit();
875 var b = try Rational.init(testing.allocator);
876 defer b.deinit();
848877
849 try a.setRatio(500, 231);878 try a.setRatio(500, 231);
850 try b.setRatio(18903, 8584);879 try b.setRatio(18903, 8584);
...@@ -856,8 +885,10 @@ test "big.rational cmp" {...@@ -856,8 +885,10 @@ test "big.rational cmp" {
856}885}
857886
858test "big.rational add single-limb" {887test "big.rational add single-limb" {
859 var a = try Rational.init(al);888 var a = try Rational.init(testing.allocator);
860 var b = try Rational.init(al);889 defer a.deinit();
890 var b = try Rational.init(testing.allocator);
891 defer b.deinit();
861892
862 try a.setRatio(500, 231);893 try a.setRatio(500, 231);
863 try b.setRatio(18903, 8584);894 try b.setRatio(18903, 8584);
...@@ -869,9 +900,12 @@ test "big.rational add single-limb" {...@@ -869,9 +900,12 @@ test "big.rational add single-limb" {
869}900}
870901
871test "big.rational add" {902test "big.rational add" {
872 var a = try Rational.init(al);903 var a = try Rational.init(testing.allocator);
873 var b = try Rational.init(al);904 defer a.deinit();
874 var r = try Rational.init(al);905 var b = try Rational.init(testing.allocator);
906 defer b.deinit();
907 var r = try Rational.init(testing.allocator);
908 defer r.deinit();
875909
876 try a.setRatio(78923, 23341);910 try a.setRatio(78923, 23341);
877 try b.setRatio(123097, 12441414);911 try b.setRatio(123097, 12441414);
...@@ -882,9 +916,12 @@ test "big.rational add" {...@@ -882,9 +916,12 @@ test "big.rational add" {
882}916}
883917
884test "big.rational sub" {918test "big.rational sub" {
885 var a = try Rational.init(al);919 var a = try Rational.init(testing.allocator);
886 var b = try Rational.init(al);920 defer a.deinit();
887 var r = try Rational.init(al);921 var b = try Rational.init(testing.allocator);
922 defer b.deinit();
923 var r = try Rational.init(testing.allocator);
924 defer r.deinit();
888925
889 try a.setRatio(78923, 23341);926 try a.setRatio(78923, 23341);
890 try b.setRatio(123097, 12441414);927 try b.setRatio(123097, 12441414);
...@@ -895,9 +932,12 @@ test "big.rational sub" {...@@ -895,9 +932,12 @@ test "big.rational sub" {
895}932}
896933
897test "big.rational mul" {934test "big.rational mul" {
898 var a = try Rational.init(al);935 var a = try Rational.init(testing.allocator);
899 var b = try Rational.init(al);936 defer a.deinit();
900 var r = try Rational.init(al);937 var b = try Rational.init(testing.allocator);
938 defer b.deinit();
939 var r = try Rational.init(testing.allocator);
940 defer r.deinit();
901941
902 try a.setRatio(78923, 23341);942 try a.setRatio(78923, 23341);
903 try b.setRatio(123097, 12441414);943 try b.setRatio(123097, 12441414);
...@@ -908,9 +948,12 @@ test "big.rational mul" {...@@ -908,9 +948,12 @@ test "big.rational mul" {
908}948}
909949
910test "big.rational div" {950test "big.rational div" {
911 var a = try Rational.init(al);951 var a = try Rational.init(testing.allocator);
912 var b = try Rational.init(al);952 defer a.deinit();
913 var r = try Rational.init(al);953 var b = try Rational.init(testing.allocator);
954 defer b.deinit();
955 var r = try Rational.init(testing.allocator);
956 defer r.deinit();
914957
915 try a.setRatio(78923, 23341);958 try a.setRatio(78923, 23341);
916 try b.setRatio(123097, 12441414);959 try b.setRatio(123097, 12441414);
...@@ -921,8 +964,10 @@ test "big.rational div" {...@@ -921,8 +964,10 @@ test "big.rational div" {
921}964}
922965
923test "big.rational div" {966test "big.rational div" {
924 var a = try Rational.init(al);967 var a = try Rational.init(testing.allocator);
925 var r = try Rational.init(al);968 defer a.deinit();
969 var r = try Rational.init(testing.allocator);
970 defer r.deinit();
926971
927 try a.setRatio(78923, 23341);972 try a.setRatio(78923, 23341);
928 a.invert();973 a.invert();
lib/std/mem.zig+30-14
...@@ -1011,11 +1011,21 @@ pub fn join(allocator: *Allocator, separator: []const u8, slices: []const []cons...@@ -1011,11 +1011,21 @@ pub fn join(allocator: *Allocator, separator: []const u8, slices: []const []cons
1011}1011}
10121012
1013test "mem.join" {1013test "mem.join" {
1014 var buf: [1024]u8 = undefined;1014 {
1015 const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;1015 const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "b", "c" });
1016 testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "b", "c" }), "a,b,c"));1016 defer testing.allocator.free(str);
1017 testing.expect(eql(u8, try join(a, ",", &[_][]const u8{"a"}), "a"));1017 testing.expect(eql(u8, str, "a,b,c"));
1018 testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "", "b", "", "c" }), "a,,b,,c"));1018 }
1019 {
1020 const str = try join(testing.allocator, ",", &[_][]const u8{"a"});
1021 defer testing.allocator.free(str);
1022 testing.expect(eql(u8, str, "a"));
1023 }
1024 {
1025 const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "", "b", "", "c" });
1026 defer testing.allocator.free(str);
1027 testing.expect(eql(u8, str, "a,,b,,c"));
1028 }
1019}1029}
10201030
1021/// Copies each T from slices into a new slice that exactly holds all the elements.1031/// 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...@@ -1044,15 +1054,21 @@ pub fn concat(allocator: *Allocator, comptime T: type, slices: []const []const T
1044}1054}
10451055
1046test "concat" {1056test "concat" {
1047 var buf: [1024]u8 = undefined;1057 {
1048 const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;1058 const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" });
1049 testing.expect(eql(u8, try concat(a, u8, &[_][]const u8{ "abc", "def", "ghi" }), "abcdefghi"));1059 defer testing.allocator.free(str);
1050 testing.expect(eql(u32, try concat(a, u32, &[_][]const u32{1060 testing.expect(eql(u8, str, "abcdefghi"));
1051 &[_]u32{ 0, 1 },1061 }
1052 &[_]u32{ 2, 3, 4 },1062 {
1053 &[_]u32{},1063 const str = try concat(testing.allocator, u32, &[_][]const u32{
1054 &[_]u32{5},1064 &[_]u32{ 0, 1 },
1055 }), &[_]u32{ 0, 1, 2, 3, 4, 5 }));1065 &[_]u32{ 2, 3, 4 },
1066 &[_]u32{},
1067 &[_]u32{5},
1068 });
1069 defer testing.allocator.free(str);
1070 testing.expect(eql(u32, str, &[_]u32{ 0, 1, 2, 3, 4, 5 }));
1071 }
1056}1072}
10571073
1058test "testStringEquality" {1074test "testStringEquality" {
lib/std/net/test.zig+1-3
...@@ -67,10 +67,8 @@ test "resolve DNS" {...@@ -67,10 +67,8 @@ test "resolve DNS" {
67 // DNS resolution not implemented on Windows yet.67 // DNS resolution not implemented on Windows yet.
68 return error.SkipZigTest;68 return error.SkipZigTest;
69 }69 }
70 var buf: [1000 * 10]u8 = undefined;
71 const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
7270
73 const address_list = net.getAddressList(a, "example.com", 80) catch |err| switch (err) {71 const address_list = net.getAddressList(testing.allocator, "example.com", 80) catch |err| switch (err) {
74 // The tests are required to work even when there is no Internet connection,72 // The tests are required to work even when there is no Internet connection,
75 // so some of these errors we must accept and skip the test.73 // so some of these errors we must accept and skip the test.
76 error.UnknownHostName => return error.SkipZigTest,74 error.UnknownHostName => return error.SkipZigTest,
lib/std/testing.zig+1-1
...@@ -12,7 +12,7 @@ pub var allocator_instance = LeakCountAllocator.init(&base_allocator_instance.al...@@ -12,7 +12,7 @@ pub var allocator_instance = LeakCountAllocator.init(&base_allocator_instance.al
12pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator;12pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator;
1313
14pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);14pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
15var allocator_mem: [512 * 1024]u8 = undefined;15var allocator_mem: [1024 * 1024]u8 = undefined;
1616
17/// This function is intended to be used only in tests. It prints diagnostics to stderr17/// This function is intended to be used only in tests. It prints diagnostics to stderr
18/// and then aborts when actual_error_union is not expected_error.18/// and then aborts when actual_error_union is not expected_error.