Commit 40b9db7cad6f876bb3e8fa32d7b32bbd4bc983ea | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-02-14 09:40:08-05:00
committer	GitHub <noreply@github.com> 2020-02-14 09:40:08-05:00
log	40b9db7cad6f876bb3e8fa32d7b32bbd4bc983ea
tree	ac84f7fcca0d11becb7d459c151782202f3e01c0
parent	9206f8a8cde9a8c1eafc606fe6b3f4129e233aef
parent	6ea6d5a4bdcf6f37c43857570522ee1308115de7
signature	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
  - json
    write_stream.zig
  - math
    big
    int.zig
    rational.zig
  - mem.zig
  - net
    test.zig
  - testing.zig

lib/std/json.zig+15-14

...	...	@@ -1598,21 +1598,21 @@ test "write json then parse it" {
1598	1598	testing.expect(mem.eql(u8, tree.root.Object.get("str").?.value.String, "hello"));
1599	1599	}
1600	1600
1601		fn test_parse(memory: []u8, json_str: []const u8) !Value {
1602		// buf_alloc goes out of scope, but we don't use it after parsing
1603		var buf_alloc = std.heap.FixedBufferAllocator.init(memory);
1604		var p = Parser.init(&buf_alloc.allocator, false);
	1601	fn test_parse(arena_allocator: *std.mem.Allocator, json_str: []const u8) !Value {
	1602	var p = Parser.init(arena_allocator, false);
1605	1603	return (try p.parse(json_str)).root;
1606	1604	}
1607	1605
1608	1606	test "parsing empty string gives appropriate error" {
1609		var memory: [1024 * 4]u8 = undefined;
1610		testing.expectError(error.UnexpectedEndOfJson, test_parse(&memory, ""));
	1607	var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
	1608	defer arena_allocator.deinit();
	1609	testing.expectError(error.UnexpectedEndOfJson, test_parse(&arena_allocator.allocator, ""));
1611	1610	}
1612	1611
1613	1612	test "integer after float has proper type" {
1614		var memory: [1024 * 8]u8 = undefined;
1615		const json = try test_parse(&memory,
	1613	var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
	1614	defer arena_allocator.deinit();
	1615	const json = try test_parse(&arena_allocator.allocator,
1616	1616	\\{
1617	1617	\\ "float": 3.14,
1618	1618	\\ "ints": [1, 2, 3]
...	...	@@ -1622,7 +1622,8 @@ test "integer after float has proper type" {
1622	1622	}
1623	1623
1624	1624	test "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	1627	const input =
1627	1628	\\{
1628	1629	\\ "backslash": "\\",
...	...	@@ -1638,7 +1639,7 @@ test "escaped characters" {
1638	1639	\\}
1639	1640	;
1640	1641
1641		const obj = (try test_parse(&memory, input)).Object;
	1642	const obj = (try test_parse(&arena_allocator.allocator, input)).Object;
1642	1643
1643	1644	testing.expectEqualSlices(u8, obj.get("backslash").?.value.String, "\\");
1644	1645	testing.expectEqualSlices(u8, obj.get("forwardslash").?.value.String, "/");
...	...	@@ -1662,13 +1663,13 @@ test "string copy option" {
1662	1663	\\}
1663	1664	;
1664	1665
1665		var mem_buffer: [1024 * 16]u8 = undefined;
1666		var buf_alloc = std.heap.FixedBufferAllocator.init(&mem_buffer);
	1666	var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
	1667	defer arena_allocator.deinit();
1667	1668
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	1670	const obj_nocopy = tree_nocopy.root.Object;
1670	1671
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	1673	const obj_copy = tree_copy.root.Object;
1673	1674
1674	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	254	var slice_stream = std.io.SliceOutStream.init(&out_buf);
255	255	const out = &slice_stream.stream;
256	256
257		var mem_buf: [1024 * 10]u8 = undefined;
258		const allocator = &std.heap.FixedBufferAllocator.init(&mem_buf).allocator;
	257	var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
	258	defer arena_allocator.deinit();
259	259
260	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));
262	262
263	263	const result = slice_stream.getWritten();
264	264	const expected =

lib/std/math/big/int.zig+503-262

...	...	@@ -137,10 +137,9 @@ pub const Int = struct {
137	137	}
138	138
139	139	/// Frees all memory associated with an Int.
140		pub fn deinit(self: *Int) void {
	140	pub fn deinit(self: Int) void {
141	141	self.assertWritable();
142	142	self.allocator.?.free(self.limbs);
143		self.* = undefined;
144	143	}
145	144
146	145	/// 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	1360	// They will still run on larger than this and should pass, but the multi-limb code-paths
1362	1361	// may be untested in some cases.
1363	1362
1364		var buffer: [64 * 8192]u8 = undefined;
1365		var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
1366		const al = &fixed.allocator;
1367
1368	1363	test "big.int comptime_int set" {
1369	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();
1371	1367
1372	1368	const s_limb_count = 128 / Limb.bit_count;
1373	1369
...	...	@@ -1381,39 +1377,45 @@ test "big.int comptime_int set" {
1381	1377	}
1382	1378
1383	1379	test "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();
1385	1382
1386	1383	testing.expect(a.limbs[0] == 10);
1387	1384	testing.expect(a.isPositive() == false);
1388	1385	}
1389	1386
1390	1387	test "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();
1392	1390
1393	1391	testing.expect(a.limbs[0] == 45);
1394	1392	testing.expect(a.isPositive() == true);
1395	1393	}
1396	1394
1397	1395	test "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();
1399	1398
1400	1399	testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
1401	1400	}
1402	1401
1403	1402	test "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();
1405	1405
1406	1406	testing.expect((try a.to(u8)) == 10);
1407	1407	}
1408	1408
1409	1409	test "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();
1411	1412
1412	1413	testing.expectError(error.TargetTooSmall, a.to(u8));
1413	1414	}
1414	1415
1415	1416	test "big.int normalize" {
1416		var a = try Int.init(al);
	1417	var a = try Int.init(testing.allocator);
	1418	defer a.deinit();
1417	1419	try a.ensureCapacity(8);
1418	1420
1419	1421	a.limbs[0] = 1;
...	...	@@ -1440,7 +1442,8 @@ test "big.int normalize" {
1440	1442	}
1441	1443
1442	1444	test "big.int normalize multi" {
1443		var a = try Int.init(al);
	1445	var a = try Int.init(testing.allocator);
	1446	defer a.deinit();
1444	1447	try a.ensureCapacity(8);
1445	1448
1446	1449	a.limbs[0] = 1;
...	...	@@ -1469,7 +1472,9 @@ test "big.int normalize multi" {
1469	1472	}
1470	1473
1471	1474	test "big.int parity" {
1472		var a = try Int.init(al);
	1475	var a = try Int.init(testing.allocator);
	1476	defer a.deinit();
	1477
1473	1478	try a.set(0);
1474	1479	testing.expect(a.isEven());
1475	1480	testing.expect(!a.isOdd());
...	...	@@ -1480,7 +1485,8 @@ test "big.int parity" {
1480	1485	}
1481	1486
1482	1487	test "big.int bitcount + sizeInBase" {
1483		var a = try Int.init(al);
	1488	var a = try Int.init(testing.allocator);
	1489	defer a.deinit();
1484	1490
1485	1491	try a.set(0b100);
1486	1492	testing.expect(a.bitCountAbs() == 3);
...	...	@@ -1507,7 +1513,8 @@ test "big.int bitcount + sizeInBase" {
1507	1513	}
1508	1514
1509	1515	test "big.int bitcount/to" {
1510		var a = try Int.init(al);
	1516	var a = try Int.init(testing.allocator);
	1517	defer a.deinit();
1511	1518
1512	1519	try a.set(0);
1513	1520	testing.expect(a.bitCountTwosComp() == 0);
...	...	@@ -1537,7 +1544,8 @@ test "big.int bitcount/to" {
1537	1544	}
1538	1545
1539	1546	test "big.int fits" {
1540		var a = try Int.init(al);
	1547	var a = try Int.init(testing.allocator);
	1548	defer a.deinit();
1541	1549
1542	1550	try a.set(0);
1543	1551	testing.expect(a.fits(u0));
...	...	@@ -1564,82 +1572,100 @@ test "big.int fits" {
1564	1572	}
1565	1573
1566	1574	test "big.int string set" {
1567		var a = try Int.init(al);
1568		try a.setString(10, "120317241209124781241290847124");
	1575	var a = try Int.init(testing.allocator);
	1576	defer a.deinit();
1569	1577
	1578	try a.setString(10, "120317241209124781241290847124");
1570	1579	testing.expect((try a.to(u128)) == 120317241209124781241290847124);
1571	1580	}
1572	1581
1573	1582	test "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	1586	try a.setString(10, "-1023");
1576	1587	testing.expect((try a.to(i32)) == -1023);
1577	1588	}
1578	1589
1579	1590	test "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	1593	testing.expectError(error.InvalidCharForDigit, a.setString(10, "x"));
1582	1594	}
1583	1595
1584	1596	test "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	1599	testing.expectError(error.InvalidBase, a.setString(45, "10"));
1587	1600	}
1588	1601
1589	1602	test "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();
1591	1605
1592		const as = try a.toString(al, 10);
	1606	const as = try a.toString(testing.allocator, 10);
	1607	defer testing.allocator.free(as);
1593	1608	const es = "120317241209124781241290847124";
1594	1609
1595	1610	testing.expect(mem.eql(u8, as, es));
1596	1611	}
1597	1612
1598	1613	test "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();
1600	1616
1601		testing.expectError(error.InvalidBase, a.toString(al, 45));
	1617	testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45));
1602	1618	}
1603	1619
1604	1620	test "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();
1606	1623
1607		const as = try a.toString(al, 2);
	1624	const as = try a.toString(testing.allocator, 2);
	1625	defer testing.allocator.free(as);
1608	1626	const es = "-1011";
1609	1627
1610	1628	testing.expect(mem.eql(u8, as, es));
1611	1629	}
1612	1630
1613	1631	test "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();
1615	1634
1616		const as = try a.toString(al, 16);
	1635	const as = try a.toString(testing.allocator, 16);
	1636	defer testing.allocator.free(as);
1617	1637	const es = "efffffff00000001eeeeeeefaaaaaaab";
1618	1638
1619	1639	testing.expect(mem.eql(u8, as, es));
1620	1640	}
1621	1641
1622	1642	test "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();
1624	1645
1625		const as = try a.toString(al, 10);
	1646	const as = try a.toString(testing.allocator, 10);
	1647	defer testing.allocator.free(as);
1626	1648	const es = "-123907434";
1627	1649
1628	1650	testing.expect(mem.eql(u8, as, es));
1629	1651	}
1630	1652
1631	1653	test "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();
1633	1656
1634		const as = try a.toString(al, 10);
	1657	const as = try a.toString(testing.allocator, 10);
	1658	defer testing.allocator.free(as);
1635	1659	const es = "0";
1636	1660
1637	1661	testing.expect(mem.eql(u8, as, es));
1638	1662	}
1639	1663
1640	1664	test "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	1667	const b = try a.clone();
	1668	defer b.deinit();
1643	1669
1644	1670	testing.expect((try a.to(u32)) == 1234);
1645	1671	testing.expect((try b.to(u32)) == 1234);
...	...	@@ -1650,8 +1676,10 @@ test "big.int clone" {
1650	1676	}
1651	1677
1652	1678	test "big.int swap" {
1653		var a = try Int.initSet(al, 1234);
1654		var b = try Int.initSet(al, 5678);
	1679	var a = try Int.initSet(testing.allocator, 1234);
	1680	defer a.deinit();
	1681	var b = try Int.initSet(testing.allocator, 5678);
	1682	defer b.deinit();
1655	1683
1656	1684	testing.expect((try a.to(u32)) == 1234);
1657	1685	testing.expect((try b.to(u32)) == 5678);
...	...	@@ -1663,53 +1691,65 @@ test "big.int swap" {
1663	1691	}
1664	1692
1665	1693	test "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();
1667	1696
1668	1697	testing.expect((try a.to(i32)) == -10);
1669	1698	}
1670	1699
1671	1700	test "big.int compare" {
1672		var a = try Int.initSet(al, -11);
1673		var b = try Int.initSet(al, 10);
	1701	var a = try Int.initSet(testing.allocator, -11);
	1702	defer a.deinit();
	1703	var b = try Int.initSet(testing.allocator, 10);
	1704	defer b.deinit();
1674	1705
1675	1706	testing.expect(a.cmpAbs(b) == 1);
1676	1707	testing.expect(a.cmp(b) == -1);
1677	1708	}
1678	1709
1679	1710	test "big.int compare similar" {
1680		var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);
1681		var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef);
	1711	var a = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee);
	1712	defer a.deinit();
	1713	var b = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef);
	1714	defer b.deinit();
1682	1715
1683	1716	testing.expect(a.cmpAbs(b) == -1);
1684	1717	testing.expect(b.cmpAbs(a) == 1);
1685	1718	}
1686	1719
1687	1720	test "big.int compare different limb size" {
1688		var a = try Int.initSet(al, maxInt(Limb) + 1);
1689		var b = try Int.initSet(al, 1);
	1721	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	1722	defer a.deinit();
	1723	var b = try Int.initSet(testing.allocator, 1);
	1724	defer b.deinit();
1690	1725
1691	1726	testing.expect(a.cmpAbs(b) == 1);
1692	1727	testing.expect(b.cmpAbs(a) == -1);
1693	1728	}
1694	1729
1695	1730	test "big.int compare multi-limb" {
1696		var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
1697		var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
	1731	var a = try Int.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
	1732	defer a.deinit();
	1733	var b = try Int.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
	1734	defer b.deinit();
1698	1735
1699	1736	testing.expect(a.cmpAbs(b) == 1);
1700	1737	testing.expect(a.cmp(b) == -1);
1701	1738	}
1702	1739
1703	1740	test "big.int equality" {
1704		var a = try Int.initSet(al, 0xffffffff1);
1705		var b = try Int.initSet(al, -0xffffffff1);
	1741	var a = try Int.initSet(testing.allocator, 0xffffffff1);
	1742	defer a.deinit();
	1743	var b = try Int.initSet(testing.allocator, -0xffffffff1);
	1744	defer b.deinit();
1706	1745
1707	1746	testing.expect(a.eqAbs(b));
1708	1747	testing.expect(!a.eq(b));
1709	1748	}
1710	1749
1711	1750	test "big.int abs" {
1712		var a = try Int.initSet(al, -5);
	1751	var a = try Int.initSet(testing.allocator, -5);
	1752	defer a.deinit();
1713	1753
1714	1754	a.abs();
1715	1755	testing.expect((try a.to(u32)) == 5);
...	...	@@ -1719,7 +1759,8 @@ test "big.int abs" {
1719	1759	}
1720	1760
1721	1761	test "big.int negate" {
1722		var a = try Int.initSet(al, 5);
	1762	var a = try Int.initSet(testing.allocator, 5);
	1763	defer a.deinit();
1723	1764
1724	1765	a.negate();
1725	1766	testing.expect((try a.to(i32)) == -5);
...	...	@@ -1729,20 +1770,26 @@ test "big.int negate" {
1729	1770	}
1730	1771
1731	1772	test "big.int add single-single" {
1732		var a = try Int.initSet(al, 50);
1733		var b = try Int.initSet(al, 5);
	1773	var a = try Int.initSet(testing.allocator, 50);
	1774	defer a.deinit();
	1775	var b = try Int.initSet(testing.allocator, 5);
	1776	defer b.deinit();
1734	1777
1735		var c = try Int.init(al);
	1778	var c = try Int.init(testing.allocator);
	1779	defer c.deinit();
1736	1780	try c.add(a, b);
1737	1781
1738	1782	testing.expect((try c.to(u32)) == 55);
1739	1783	}
1740	1784
1741	1785	test "big.int add multi-single" {
1742		var a = try Int.initSet(al, maxInt(Limb) + 1);
1743		var b = try Int.initSet(al, 1);
	1786	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	1787	defer a.deinit();
	1788	var b = try Int.initSet(testing.allocator, 1);
	1789	defer b.deinit();
1744	1790
1745		var c = try Int.init(al);
	1791	var c = try Int.init(testing.allocator);
	1792	defer c.deinit();
1746	1793
1747	1794	try c.add(a, b);
1748	1795	testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
...	...	@@ -1754,20 +1801,26 @@ test "big.int add multi-single" {
1754	1801	test "big.int add multi-multi" {
1755	1802	const op1 = 0xefefefef7f7f7f7f;
1756	1803	const op2 = 0xfefefefe9f9f9f9f;
1757		var a = try Int.initSet(al, op1);
1758		var b = try Int.initSet(al, op2);
	1804	var a = try Int.initSet(testing.allocator, op1);
	1805	defer a.deinit();
	1806	var b = try Int.initSet(testing.allocator, op2);
	1807	defer b.deinit();
1759	1808
1760		var c = try Int.init(al);
	1809	var c = try Int.init(testing.allocator);
	1810	defer c.deinit();
1761	1811	try c.add(a, b);
1762	1812
1763	1813	testing.expect((try c.to(u128)) == op1 + op2);
1764	1814	}
1765	1815
1766	1816	test "big.int add zero-zero" {
1767		var a = try Int.initSet(al, 0);
1768		var b = try Int.initSet(al, 0);
	1817	var a = try Int.initSet(testing.allocator, 0);
	1818	defer a.deinit();
	1819	var b = try Int.initSet(testing.allocator, 0);
	1820	defer b.deinit();
1769	1821
1770		var c = try Int.init(al);
	1822	var c = try Int.init(testing.allocator);
	1823	defer c.deinit();
1771	1824	try c.add(a, b);
1772	1825
1773	1826	testing.expect((try c.to(u32)) == 0);
...	...	@@ -1775,8 +1828,10 @@ test "big.int add zero-zero" {
1775	1828
1776	1829	test "big.int add alias multi-limb nonzero-zero" {
1777	1830	const op1 = 0xffffffff777777771;
1778		var a = try Int.initSet(al, op1);
1779		var b = try Int.initSet(al, 0);
	1831	var a = try Int.initSet(testing.allocator, op1);
	1832	defer a.deinit();
	1833	var b = try Int.initSet(testing.allocator, 0);
	1834	defer b.deinit();
1780	1835
1781	1836	try a.add(a, b);
1782	1837
...	...	@@ -1784,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {
1784	1839	}
1785	1840
1786	1841	test "big.int add sign" {
1787		var a = try Int.init(al);
1788
1789		const one = try Int.initSet(al, 1);
1790		const two = try Int.initSet(al, 2);
1791		const neg_one = try Int.initSet(al, -1);
1792		const neg_two = try Int.initSet(al, -2);
	1842	var a = try Int.init(testing.allocator);
	1843	defer a.deinit();
	1844
	1845	const one = try Int.initSet(testing.allocator, 1);
	1846	defer one.deinit();
	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();
1793	1853
1794	1854	try a.add(one, two);
1795	1855	testing.expect((try a.to(i32)) == 3);
...	...	@@ -1805,20 +1865,26 @@ test "big.int add sign" {
1805	1865	}
1806	1866
1807	1867	test "big.int sub single-single" {
1808		var a = try Int.initSet(al, 50);
1809		var b = try Int.initSet(al, 5);
	1868	var a = try Int.initSet(testing.allocator, 50);
	1869	defer a.deinit();
	1870	var b = try Int.initSet(testing.allocator, 5);
	1871	defer b.deinit();
1810	1872
1811		var c = try Int.init(al);
	1873	var c = try Int.init(testing.allocator);
	1874	defer c.deinit();
1812	1875	try c.sub(a, b);
1813	1876
1814	1877	testing.expect((try c.to(u32)) == 45);
1815	1878	}
1816	1879
1817	1880	test "big.int sub multi-single" {
1818		var a = try Int.initSet(al, maxInt(Limb) + 1);
1819		var b = try Int.initSet(al, 1);
	1881	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	1882	defer a.deinit();
	1883	var b = try Int.initSet(testing.allocator, 1);
	1884	defer b.deinit();
1820	1885
1821		var c = try Int.init(al);
	1886	var c = try Int.init(testing.allocator);
	1887	defer c.deinit();
1822	1888	try c.sub(a, b);
1823	1889
1824	1890	testing.expect((try c.to(Limb)) == maxInt(Limb));
...	...	@@ -1828,32 +1894,43 @@ test "big.int sub multi-multi" {
1828	1894	const op1 = 0xefefefefefefefefefefefef;
1829	1895	const op2 = 0xabababababababababababab;
1830	1896
1831		var a = try Int.initSet(al, op1);
1832		var b = try Int.initSet(al, op2);
	1897	var a = try Int.initSet(testing.allocator, op1);
	1898	defer a.deinit();
	1899	var b = try Int.initSet(testing.allocator, op2);
	1900	defer b.deinit();
1833	1901
1834		var c = try Int.init(al);
	1902	var c = try Int.init(testing.allocator);
	1903	defer c.deinit();
1835	1904	try c.sub(a, b);
1836	1905
1837	1906	testing.expect((try c.to(u128)) == op1 - op2);
1838	1907	}
1839	1908
1840	1909	test "big.int sub equal" {
1841		var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);
1842		var b = try Int.initSet(al, 0x11efefefefefefefefefefefef);
	1910	var a = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
	1911	defer a.deinit();
	1912	var b = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
	1913	defer b.deinit();
1843	1914
1844		var c = try Int.init(al);
	1915	var c = try Int.init(testing.allocator);
	1916	defer c.deinit();
1845	1917	try c.sub(a, b);
1846	1918
1847	1919	testing.expect((try c.to(u32)) == 0);
1848	1920	}
1849	1921
1850	1922	test "big.int sub sign" {
1851		var a = try Int.init(al);
1852
1853		const one = try Int.initSet(al, 1);
1854		const two = try Int.initSet(al, 2);
1855		const neg_one = try Int.initSet(al, -1);
1856		const neg_two = try Int.initSet(al, -2);
	1923	var a = try Int.init(testing.allocator);
	1924	defer a.deinit();
	1925
	1926	const one = try Int.initSet(testing.allocator, 1);
	1927	defer one.deinit();
	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();
1857	1934
1858	1935	try a.sub(one, two);
1859	1936	testing.expect((try a.to(i32)) == -1);
...	...	@@ -1872,20 +1949,26 @@ test "big.int sub sign" {
1872	1949	}
1873	1950
1874	1951	test "big.int mul single-single" {
1875		var a = try Int.initSet(al, 50);
1876		var b = try Int.initSet(al, 5);
	1952	var a = try Int.initSet(testing.allocator, 50);
	1953	defer a.deinit();
	1954	var b = try Int.initSet(testing.allocator, 5);
	1955	defer b.deinit();
1877	1956
1878		var c = try Int.init(al);
	1957	var c = try Int.init(testing.allocator);
	1958	defer c.deinit();
1879	1959	try c.mul(a, b);
1880	1960
1881	1961	testing.expect((try c.to(u64)) == 250);
1882	1962	}
1883	1963
1884	1964	test "big.int mul multi-single" {
1885		var a = try Int.initSet(al, maxInt(Limb));
1886		var b = try Int.initSet(al, 2);
	1965	var a = try Int.initSet(testing.allocator, maxInt(Limb));
	1966	defer a.deinit();
	1967	var b = try Int.initSet(testing.allocator, 2);
	1968	defer b.deinit();
1887	1969
1888		var c = try Int.init(al);
	1970	var c = try Int.init(testing.allocator);
	1971	defer c.deinit();
1889	1972	try c.mul(a, b);
1890	1973
1891	1974	testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));
...	...	@@ -1894,18 +1977,23 @@ test "big.int mul multi-single" {
1894	1977	test "big.int mul multi-multi" {
1895	1978	const op1 = 0x998888efefefefefefefef;
1896	1979	const op2 = 0x333000abababababababab;
1897		var a = try Int.initSet(al, op1);
1898		var b = try Int.initSet(al, op2);
	1980	var a = try Int.initSet(testing.allocator, op1);
	1981	defer a.deinit();
	1982	var b = try Int.initSet(testing.allocator, op2);
	1983	defer b.deinit();
1899	1984
1900		var c = try Int.init(al);
	1985	var c = try Int.init(testing.allocator);
	1986	defer c.deinit();
1901	1987	try c.mul(a, b);
1902	1988
1903	1989	testing.expect((try c.to(u256)) == op1 * op2);
1904	1990	}
1905	1991
1906	1992	test "big.int mul alias r with a" {
1907		var a = try Int.initSet(al, maxInt(Limb));
1908		var b = try Int.initSet(al, 2);
	1993	var a = try Int.initSet(testing.allocator, maxInt(Limb));
	1994	defer a.deinit();
	1995	var b = try Int.initSet(testing.allocator, 2);
	1996	defer b.deinit();
1909	1997
1910	1998	try a.mul(a, b);
1911	1999
...	...	@@ -1913,8 +2001,10 @@ test "big.int mul alias r with a" {
1913	2001	}
1914	2002
1915	2003	test "big.int mul alias r with b" {
1916		var a = try Int.initSet(al, maxInt(Limb));
1917		var b = try Int.initSet(al, 2);
	2004	var a = try Int.initSet(testing.allocator, maxInt(Limb));
	2005	defer a.deinit();
	2006	var b = try Int.initSet(testing.allocator, 2);
	2007	defer b.deinit();
1918	2008
1919	2009	try a.mul(b, a);
1920	2010
...	...	@@ -1922,7 +2012,8 @@ test "big.int mul alias r with b" {
1922	2012	}
1923	2013
1924	2014	test "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();
1926	2017
1927	2018	try a.mul(a, a);
1928	2019
...	...	@@ -1930,31 +2021,41 @@ test "big.int mul alias r with a and b" {
1930	2021	}
1931	2022
1932	2023	test "big.int mul a*0" {
1933		var a = try Int.initSet(al, 0xefefefefefefefef);
1934		var b = try Int.initSet(al, 0);
	2024	var a = try Int.initSet(testing.allocator, 0xefefefefefefefef);
	2025	defer a.deinit();
	2026	var b = try Int.initSet(testing.allocator, 0);
	2027	defer b.deinit();
1935	2028
1936		var c = try Int.init(al);
	2029	var c = try Int.init(testing.allocator);
	2030	defer c.deinit();
1937	2031	try c.mul(a, b);
1938	2032
1939	2033	testing.expect((try c.to(u32)) == 0);
1940	2034	}
1941	2035
1942	2036	test "big.int mul 0*0" {
1943		var a = try Int.initSet(al, 0);
1944		var b = try Int.initSet(al, 0);
	2037	var a = try Int.initSet(testing.allocator, 0);
	2038	defer a.deinit();
	2039	var b = try Int.initSet(testing.allocator, 0);
	2040	defer b.deinit();
1945	2041
1946		var c = try Int.init(al);
	2042	var c = try Int.init(testing.allocator);
	2043	defer c.deinit();
1947	2044	try c.mul(a, b);
1948	2045
1949	2046	testing.expect((try c.to(u32)) == 0);
1950	2047	}
1951	2048
1952	2049	test "big.int div single-single no rem" {
1953		var a = try Int.initSet(al, 50);
1954		var b = try Int.initSet(al, 5);
1955
1956		var q = try Int.init(al);
1957		var r = try Int.init(al);
	2050	var a = try Int.initSet(testing.allocator, 50);
	2051	defer a.deinit();
	2052	var b = try Int.initSet(testing.allocator, 5);
	2053	defer b.deinit();
	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	2059	try Int.divTrunc(&q, &r, a, b);
1959	2060
1960	2061	testing.expect((try q.to(u32)) == 10);
...	...	@@ -1962,11 +2063,15 @@ test "big.int div single-single no rem" {
1962	2063	}
1963	2064
1964	2065	test "big.int div single-single with rem" {
1965		var a = try Int.initSet(al, 49);
1966		var b = try Int.initSet(al, 5);
1967
1968		var q = try Int.init(al);
1969		var r = try Int.init(al);
	2066	var a = try Int.initSet(testing.allocator, 49);
	2067	defer a.deinit();
	2068	var b = try Int.initSet(testing.allocator, 5);
	2069	defer b.deinit();
	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	2075	try Int.divTrunc(&q, &r, a, b);
1971	2076
1972	2077	testing.expect((try q.to(u32)) == 9);
...	...	@@ -1977,11 +2082,15 @@ test "big.int div multi-single no rem" {
1977	2082	const op1 = 0xffffeeeeddddcccc;
1978	2083	const op2 = 34;
1979	2084
1980		var a = try Int.initSet(al, op1);
1981		var b = try Int.initSet(al, op2);
	2085	var a = try Int.initSet(testing.allocator, op1);
	2086	defer a.deinit();
	2087	var b = try Int.initSet(testing.allocator, op2);
	2088	defer b.deinit();
1982	2089
1983		var q = try Int.init(al);
1984		var r = try Int.init(al);
	2090	var q = try Int.init(testing.allocator);
	2091	defer q.deinit();
	2092	var r = try Int.init(testing.allocator);
	2093	defer r.deinit();
1985	2094	try Int.divTrunc(&q, &r, a, b);
1986	2095
1987	2096	testing.expect((try q.to(u64)) == op1 / op2);
...	...	@@ -1992,11 +2101,15 @@ test "big.int div multi-single with rem" {
1992	2101	const op1 = 0xffffeeeeddddcccf;
1993	2102	const op2 = 34;
1994	2103
1995		var a = try Int.initSet(al, op1);
1996		var b = try Int.initSet(al, op2);
	2104	var a = try Int.initSet(testing.allocator, op1);
	2105	defer a.deinit();
	2106	var b = try Int.initSet(testing.allocator, op2);
	2107	defer b.deinit();
1997	2108
1998		var q = try Int.init(al);
1999		var r = try Int.init(al);
	2109	var q = try Int.init(testing.allocator);
	2110	defer q.deinit();
	2111	var r = try Int.init(testing.allocator);
	2112	defer r.deinit();
2000	2113	try Int.divTrunc(&q, &r, a, b);
2001	2114
2002	2115	testing.expect((try q.to(u64)) == op1 / op2);
...	...	@@ -2007,11 +2120,15 @@ test "big.int div multi>2-single" {
2007	2120	const op1 = 0xfefefefefefefefefefefefefefefefe;
2008	2121	const op2 = 0xefab8;
2009	2122
2010		var a = try Int.initSet(al, op1);
2011		var b = try Int.initSet(al, op2);
	2123	var a = try Int.initSet(testing.allocator, op1);
	2124	defer a.deinit();
	2125	var b = try Int.initSet(testing.allocator, op2);
	2126	defer b.deinit();
2012	2127
2013		var q = try Int.init(al);
2014		var r = try Int.init(al);
	2128	var q = try Int.init(testing.allocator);
	2129	defer q.deinit();
	2130	var r = try Int.init(testing.allocator);
	2131	defer r.deinit();
2015	2132	try Int.divTrunc(&q, &r, a, b);
2016	2133
2017	2134	testing.expect((try q.to(u128)) == op1 / op2);
...	...	@@ -2019,11 +2136,15 @@ test "big.int div multi>2-single" {
2019	2136	}
2020	2137
2021	2138	test "big.int div single-single q < r" {
2022		var a = try Int.initSet(al, 0x0078f432);
2023		var b = try Int.initSet(al, 0x01000000);
2024
2025		var q = try Int.init(al);
2026		var r = try Int.init(al);
	2139	var a = try Int.initSet(testing.allocator, 0x0078f432);
	2140	defer a.deinit();
	2141	var b = try Int.initSet(testing.allocator, 0x01000000);
	2142	defer b.deinit();
	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	2148	try Int.divTrunc(&q, &r, a, b);
2028	2149
2029	2150	testing.expect((try q.to(u64)) == 0);
...	...	@@ -2031,11 +2152,15 @@ test "big.int div single-single q < r" {
2031	2152	}
2032	2153
2033	2154	test "big.int div single-single q == r" {
2034		var a = try Int.initSet(al, 10);
2035		var b = try Int.initSet(al, 10);
2036
2037		var q = try Int.init(al);
2038		var r = try Int.init(al);
	2155	var a = try Int.initSet(testing.allocator, 10);
	2156	defer a.deinit();
	2157	var b = try Int.initSet(testing.allocator, 10);
	2158	defer b.deinit();
	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	2164	try Int.divTrunc(&q, &r, a, b);
2040	2165
2041	2166	testing.expect((try q.to(u64)) == 1);
...	...	@@ -2043,8 +2168,10 @@ test "big.int div single-single q == r" {
2043	2168	}
2044	2169
2045	2170	test "big.int div q=0 alias" {
2046		var a = try Int.initSet(al, 3);
2047		var b = try Int.initSet(al, 10);
	2171	var a = try Int.initSet(testing.allocator, 3);
	2172	defer a.deinit();
	2173	var b = try Int.initSet(testing.allocator, 10);
	2174	defer b.deinit();
2048	2175
2049	2176	try Int.divTrunc(&a, &b, a, b);
2050	2177
...	...	@@ -2055,11 +2182,15 @@ test "big.int div q=0 alias" {
2055	2182	test "big.int div multi-multi q < r" {
2056	2183	const op1 = 0x1ffffffff0078f432;
2057	2184	const op2 = 0x1ffffffff01000000;
2058		var a = try Int.initSet(al, op1);
2059		var b = try Int.initSet(al, op2);
2060
2061		var q = try Int.init(al);
2062		var r = try Int.init(al);
	2185	var a = try Int.initSet(testing.allocator, op1);
	2186	defer a.deinit();
	2187	var b = try Int.initSet(testing.allocator, op2);
	2188	defer b.deinit();
	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	2194	try Int.divTrunc(&q, &r, a, b);
2064	2195
2065	2196	testing.expect((try q.to(u128)) == 0);
...	...	@@ -2070,11 +2201,15 @@ test "big.int div trunc single-single +/+" {
2070	2201	const u: i32 = 5;
2071	2202	const v: i32 = 3;
2072	2203
2073		var a = try Int.initSet(al, u);
2074		var b = try Int.initSet(al, v);
	2204	var a = try Int.initSet(testing.allocator, u);
	2205	defer a.deinit();
	2206	var b = try Int.initSet(testing.allocator, v);
	2207	defer b.deinit();
2075	2208
2076		var q = try Int.init(al);
2077		var r = try Int.init(al);
	2209	var q = try Int.init(testing.allocator);
	2210	defer q.deinit();
	2211	var r = try Int.init(testing.allocator);
	2212	defer r.deinit();
2078	2213	try Int.divTrunc(&q, &r, a, b);
2079	2214
2080	2215	// n = q * d + r
...	...	@@ -2090,11 +2225,15 @@ test "big.int div trunc single-single -/+" {
2090	2225	const u: i32 = -5;
2091	2226	const v: i32 = 3;
2092	2227
2093		var a = try Int.initSet(al, u);
2094		var b = try Int.initSet(al, v);
	2228	var a = try Int.initSet(testing.allocator, u);
	2229	defer a.deinit();
	2230	var b = try Int.initSet(testing.allocator, v);
	2231	defer b.deinit();
2095	2232
2096		var q = try Int.init(al);
2097		var r = try Int.init(al);
	2233	var q = try Int.init(testing.allocator);
	2234	defer q.deinit();
	2235	var r = try Int.init(testing.allocator);
	2236	defer r.deinit();
2098	2237	try Int.divTrunc(&q, &r, a, b);
2099	2238
2100	2239	// n = q * d + r
...	...	@@ -2110,11 +2249,15 @@ test "big.int div trunc single-single +/-" {
2110	2249	const u: i32 = 5;
2111	2250	const v: i32 = -3;
2112	2251
2113		var a = try Int.initSet(al, u);
2114		var b = try Int.initSet(al, v);
	2252	var a = try Int.initSet(testing.allocator, u);
	2253	defer a.deinit();
	2254	var b = try Int.initSet(testing.allocator, v);
	2255	defer b.deinit();
2115	2256
2116		var q = try Int.init(al);
2117		var r = try Int.init(al);
	2257	var q = try Int.init(testing.allocator);
	2258	defer q.deinit();
	2259	var r = try Int.init(testing.allocator);
	2260	defer r.deinit();
2118	2261	try Int.divTrunc(&q, &r, a, b);
2119	2262
2120	2263	// n = q * d + r
...	...	@@ -2130,11 +2273,15 @@ test "big.int div trunc single-single -/-" {
2130	2273	const u: i32 = -5;
2131	2274	const v: i32 = -3;
2132	2275
2133		var a = try Int.initSet(al, u);
2134		var b = try Int.initSet(al, v);
	2276	var a = try Int.initSet(testing.allocator, u);
	2277	defer a.deinit();
	2278	var b = try Int.initSet(testing.allocator, v);
	2279	defer b.deinit();
2135	2280
2136		var q = try Int.init(al);
2137		var r = try Int.init(al);
	2281	var q = try Int.init(testing.allocator);
	2282	defer q.deinit();
	2283	var r = try Int.init(testing.allocator);
	2284	defer r.deinit();
2138	2285	try Int.divTrunc(&q, &r, a, b);
2139	2286
2140	2287	// n = q * d + r
...	...	@@ -2150,11 +2297,15 @@ test "big.int div floor single-single +/+" {
2150	2297	const u: i32 = 5;
2151	2298	const v: i32 = 3;
2152	2299
2153		var a = try Int.initSet(al, u);
2154		var b = try Int.initSet(al, v);
	2300	var a = try Int.initSet(testing.allocator, u);
	2301	defer a.deinit();
	2302	var b = try Int.initSet(testing.allocator, v);
	2303	defer b.deinit();
2155	2304
2156		var q = try Int.init(al);
2157		var r = try Int.init(al);
	2305	var q = try Int.init(testing.allocator);
	2306	defer q.deinit();
	2307	var r = try Int.init(testing.allocator);
	2308	defer r.deinit();
2158	2309	try Int.divFloor(&q, &r, a, b);
2159	2310
2160	2311	// n = q * d + r
...	...	@@ -2170,11 +2321,15 @@ test "big.int div floor single-single -/+" {
2170	2321	const u: i32 = -5;
2171	2322	const v: i32 = 3;
2172	2323
2173		var a = try Int.initSet(al, u);
2174		var b = try Int.initSet(al, v);
	2324	var a = try Int.initSet(testing.allocator, u);
	2325	defer a.deinit();
	2326	var b = try Int.initSet(testing.allocator, v);
	2327	defer b.deinit();
2175	2328
2176		var q = try Int.init(al);
2177		var r = try Int.init(al);
	2329	var q = try Int.init(testing.allocator);
	2330	defer q.deinit();
	2331	var r = try Int.init(testing.allocator);
	2332	defer r.deinit();
2178	2333	try Int.divFloor(&q, &r, a, b);
2179	2334
2180	2335	// n = q * d + r
...	...	@@ -2190,11 +2345,15 @@ test "big.int div floor single-single +/-" {
2190	2345	const u: i32 = 5;
2191	2346	const v: i32 = -3;
2192	2347
2193		var a = try Int.initSet(al, u);
2194		var b = try Int.initSet(al, v);
	2348	var a = try Int.initSet(testing.allocator, u);
	2349	defer a.deinit();
	2350	var b = try Int.initSet(testing.allocator, v);
	2351	defer b.deinit();
2195	2352
2196		var q = try Int.init(al);
2197		var r = try Int.init(al);
	2353	var q = try Int.init(testing.allocator);
	2354	defer q.deinit();
	2355	var r = try Int.init(testing.allocator);
	2356	defer r.deinit();
2198	2357	try Int.divFloor(&q, &r, a, b);
2199	2358
2200	2359	// n = q * d + r
...	...	@@ -2210,11 +2369,15 @@ test "big.int div floor single-single -/-" {
2210	2369	const u: i32 = -5;
2211	2370	const v: i32 = -3;
2212	2371
2213		var a = try Int.initSet(al, u);
2214		var b = try Int.initSet(al, v);
	2372	var a = try Int.initSet(testing.allocator, u);
	2373	defer a.deinit();
	2374	var b = try Int.initSet(testing.allocator, v);
	2375	defer b.deinit();
2215	2376
2216		var q = try Int.init(al);
2217		var r = try Int.init(al);
	2377	var q = try Int.init(testing.allocator);
	2378	defer q.deinit();
	2379	var r = try Int.init(testing.allocator);
	2380	defer r.deinit();
2218	2381	try Int.divFloor(&q, &r, a, b);
2219	2382
2220	2383	// n = q * d + r
...	...	@@ -2227,11 +2390,15 @@ test "big.int div floor single-single -/-" {
2227	2390	}
2228	2391
2229	2392	test "big.int div multi-multi with rem" {
2230		var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
2231		var b = try Int.initSet(al, 0x99990000111122223333);
2232
2233		var q = try Int.init(al);
2234		var r = try Int.init(al);
	2393	var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
	2394	defer a.deinit();
	2395	var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
	2396	defer b.deinit();
	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	2402	try Int.divTrunc(&q, &r, a, b);
2236	2403
2237	2404	testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...	...	@@ -2239,11 +2406,15 @@ test "big.int div multi-multi with rem" {
2239	2406	}
2240	2407
2241	2408	test "big.int div multi-multi no rem" {
2242		var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
2243		var b = try Int.initSet(al, 0x99990000111122223333);
2244
2245		var q = try Int.init(al);
2246		var r = try Int.init(al);
	2409	var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
	2410	defer a.deinit();
	2411	var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
	2412	defer b.deinit();
	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	2418	try Int.divTrunc(&q, &r, a, b);
2248	2419
2249	2420	testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...	...	@@ -2251,11 +2422,15 @@ test "big.int div multi-multi no rem" {
2251	2422	}
2252	2423
2253	2424	test "big.int div multi-multi (2 branch)" {
2254		var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);
2255		var b = try Int.initSet(al, 0x86666666555555554444444433333333);
2256
2257		var q = try Int.init(al);
2258		var r = try Int.init(al);
	2425	var a = try Int.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111);
	2426	defer a.deinit();
	2427	var b = try Int.initSet(testing.allocator, 0x86666666555555554444444433333333);
	2428	defer b.deinit();
	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	2434	try Int.divTrunc(&q, &r, a, b);
2260	2435
2261	2436	testing.expect((try q.to(u128)) == 0x10000000000000000);
...	...	@@ -2263,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" {
2263	2438	}
2264	2439
2265	2440	test "big.int div multi-multi (3.1/3.3 branch)" {
2266		var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);
2267		var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);
2268
2269		var q = try Int.init(al);
2270		var r = try Int.init(al);
	2441	var a = try Int.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
	2442	defer a.deinit();
	2443	var b = try Int.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171);
	2444	defer b.deinit();
	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	2450	try Int.divTrunc(&q, &r, a, b);
2272	2451
2273	2452	testing.expect((try q.to(u128)) == 0xfffffffffffffffffff);
...	...	@@ -2275,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
2275	2454	}
2276	2455
2277	2456	test "big.int div multi-single zero-limb trailing" {
2278		var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000);
2279		var b = try Int.initSet(al, 0x10000000000000000);
2280
2281		var q = try Int.init(al);
2282		var r = try Int.init(al);
	2457	var a = try Int.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000);
	2458	defer a.deinit();
	2459	var b = try Int.initSet(testing.allocator, 0x10000000000000000);
	2460	defer b.deinit();
	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	2466	try Int.divTrunc(&q, &r, a, b);
2284	2467
2285		var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000);
	2468	var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000);
	2469	defer expected.deinit();
2286	2470	testing.expect(q.eq(expected));
2287	2471	testing.expect(r.eqZero());
2288	2472	}
2289	2473
2290	2474	test "big.int div multi-multi zero-limb trailing (with rem)" {
2291		var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
2292		var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
2293
2294		var q = try Int.init(al);
2295		var r = try Int.init(al);
	2475	var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
	2476	defer a.deinit();
	2477	var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
	2478	defer b.deinit();
	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	2484	try Int.divTrunc(&q, &r, a, b);
2297	2485
2298	2486	testing.expect((try q.to(u128)) == 0x10000000000000000);
2299	2487
2300		const rs = try r.toString(al, 16);
	2488	const rs = try r.toString(testing.allocator, 16);
	2489	defer testing.allocator.free(rs);
2301	2490	testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));
2302	2491	}
2303	2492
2304	2493	test "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);
2306		var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
2307
2308		var q = try Int.init(al);
2309		var r = try Int.init(al);
	2494	var a = try Int.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
	2495	defer a.deinit();
	2496	var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
	2497	defer b.deinit();
	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	2503	try Int.divTrunc(&q, &r, a, b);
2311	2504
2312	2505	testing.expect((try q.to(u128)) == 0x1);
2313	2506
2314		const rs = try r.toString(al, 16);
	2507	const rs = try r.toString(testing.allocator, 16);
	2508	defer testing.allocator.free(rs);
2315	2509	testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));
2316	2510	}
2317	2511
2318	2512	test "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);
2320		var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000);
2321
2322		var q = try Int.init(al);
2323		var r = try Int.init(al);
	2513	var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
	2514	defer a.deinit();
	2515	var b = try Int.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000);
	2516	defer b.deinit();
	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	2522	try Int.divTrunc(&q, &r, a, b);
2325	2523
2326		const qs = try q.toString(al, 16);
	2524	const qs = try q.toString(testing.allocator, 16);
	2525	defer testing.allocator.free(qs);
2327	2526	testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f"));
2328	2527
2329		const rs = try r.toString(al, 16);
	2528	const rs = try r.toString(testing.allocator, 16);
	2529	defer testing.allocator.free(rs);
2330	2530	testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));
2331	2531	}
2332	2532
2333	2533	test "big.int div multi-multi fuzz case #1" {
2334		var a = try Int.init(al);
2335		var b = try Int.init(al);
	2534	var a = try Int.init(testing.allocator);
	2535	defer a.deinit();
	2536	var b = try Int.init(testing.allocator);
	2537	defer b.deinit();
2336	2538
2337	2539	try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
2338	2540	try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff");
2339	2541
2340		var q = try Int.init(al);
2341		var r = try Int.init(al);
	2542	var q = try Int.init(testing.allocator);
	2543	defer q.deinit();
	2544	var r = try Int.init(testing.allocator);
	2545	defer r.deinit();
2342	2546	try Int.divTrunc(&q, &r, a, b);
2343	2547
2344		const qs = try q.toString(al, 16);
	2548	const qs = try q.toString(testing.allocator, 16);
	2549	defer testing.allocator.free(qs);
2345	2550	testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1"));
2346	2551
2347		const rs = try r.toString(al, 16);
	2552	const rs = try r.toString(testing.allocator, 16);
	2553	defer testing.allocator.free(rs);
2348	2554	testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));
2349	2555	}
2350	2556
2351	2557	test "big.int div multi-multi fuzz case #2" {
2352		var a = try Int.init(al);
2353		var b = try Int.init(al);
	2558	var a = try Int.init(testing.allocator);
	2559	defer a.deinit();
	2560	var b = try Int.init(testing.allocator);
	2561	defer b.deinit();
2354	2562
2355	2563	try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000");
2356	2564	try b.setString(16, "ffc0000000000000000000000000000000000000000000000000");
2357	2565
2358		var q = try Int.init(al);
2359		var r = try Int.init(al);
	2566	var q = try Int.init(testing.allocator);
	2567	defer q.deinit();
	2568	var r = try Int.init(testing.allocator);
	2569	defer r.deinit();
2360	2570	try Int.divTrunc(&q, &r, a, b);
2361	2571
2362		const qs = try q.toString(al, 16);
	2572	const qs = try q.toString(testing.allocator, 16);
	2573	defer testing.allocator.free(qs);
2363	2574	testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4"));
2364	2575
2365		const rs = try r.toString(al, 16);
	2576	const rs = try r.toString(testing.allocator, 16);
	2577	defer testing.allocator.free(rs);
2366	2578	testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));
2367	2579	}
2368	2580
2369	2581	test "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	2584	try a.shiftRight(a, 16);
2372	2585
2373	2586	testing.expect((try a.to(u32)) == 0xffff);
2374	2587	}
2375	2588
2376	2589	test "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	2592	try a.shiftRight(a, 67);
2379	2593
2380	2594	testing.expect((try a.to(u64)) == 0x1fffe0001dddc222);
2381	2595	}
2382	2596
2383	2597	test "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	2600	try a.shiftLeft(a, 16);
2386	2601
2387	2602	testing.expect((try a.to(u64)) == 0xffff0000);
2388	2603	}
2389	2604
2390	2605	test "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	2608	try a.shiftLeft(a, 67);
2393	2609
2394	2610	testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
2395	2611	}
2396	2612
2397	2613	test "big.int shift-right negative" {
2398		var a = try Int.init(al);
	2614	var a = try Int.init(testing.allocator);
	2615	defer a.deinit();
2399	2616
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	2619	testing.expect((try a.to(i32)) == -20 >> 2);
2402	2620
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	2623	testing.expect((try a.to(i32)) == -5 >> 10);
2405	2624	}
2406	2625
2407	2626	test "big.int shift-left negative" {
2408		var a = try Int.init(al);
	2627	var a = try Int.init(testing.allocator);
	2628	defer a.deinit();
2409	2629
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	2632	testing.expect((try a.to(i32)) == -10 >> 1232);
2412	2633	}
2413	2634
2414	2635	test "big.int bitwise and simple" {
2415		var a = try Int.initSet(al, 0xffffffff11111111);
2416		var b = try Int.initSet(al, 0xeeeeeeee22222222);
	2636	var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
	2637	defer a.deinit();
	2638	var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
	2639	defer b.deinit();
2417	2640
2418	2641	try a.bitAnd(a, b);
2419	2642
...	...	@@ -2421,8 +2644,10 @@ test "big.int bitwise and simple" {
2421	2644	}
2422	2645
2423	2646	test "big.int bitwise and multi-limb" {
2424		var a = try Int.initSet(al, maxInt(Limb) + 1);
2425		var b = try Int.initSet(al, maxInt(Limb));
	2647	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	2648	defer a.deinit();
	2649	var b = try Int.initSet(testing.allocator, maxInt(Limb));
	2650	defer b.deinit();
2426	2651
2427	2652	try a.bitAnd(a, b);
2428	2653
...	...	@@ -2430,8 +2655,10 @@ test "big.int bitwise and multi-limb" {
2430	2655	}
2431	2656
2432	2657	test "big.int bitwise xor simple" {
2433		var a = try Int.initSet(al, 0xffffffff11111111);
2434		var b = try Int.initSet(al, 0xeeeeeeee22222222);
	2658	var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
	2659	defer a.deinit();
	2660	var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
	2661	defer b.deinit();
2435	2662
2436	2663	try a.bitXor(a, b);
2437	2664
...	...	@@ -2439,8 +2666,10 @@ test "big.int bitwise xor simple" {
2439	2666	}
2440	2667
2441	2668	test "big.int bitwise xor multi-limb" {
2442		var a = try Int.initSet(al, maxInt(Limb) + 1);
2443		var b = try Int.initSet(al, maxInt(Limb));
	2669	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	2670	defer a.deinit();
	2671	var b = try Int.initSet(testing.allocator, maxInt(Limb));
	2672	defer b.deinit();
2444	2673
2445	2674	try a.bitXor(a, b);
2446	2675
...	...	@@ -2448,8 +2677,10 @@ test "big.int bitwise xor multi-limb" {
2448	2677	}
2449	2678
2450	2679	test "big.int bitwise or simple" {
2451		var a = try Int.initSet(al, 0xffffffff11111111);
2452		var b = try Int.initSet(al, 0xeeeeeeee22222222);
	2680	var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
	2681	defer a.deinit();
	2682	var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
	2683	defer b.deinit();
2453	2684
2454	2685	try a.bitOr(a, b);
2455	2686
...	...	@@ -2457,8 +2688,10 @@ test "big.int bitwise or simple" {
2457	2688	}
2458	2689
2459	2690	test "big.int bitwise or multi-limb" {
2460		var a = try Int.initSet(al, maxInt(Limb) + 1);
2461		var b = try Int.initSet(al, maxInt(Limb));
	2691	var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
	2692	defer a.deinit();
	2693	var b = try Int.initSet(testing.allocator, maxInt(Limb));
	2694	defer b.deinit();
2462	2695
2463	2696	try a.bitOr(a, b);
2464	2697
...	...	@@ -2467,11 +2700,19 @@ test "big.int bitwise or multi-limb" {
2467	2700	}
2468	2701
2469	2702	test "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();
2471	2705
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	2709	testing.expect((try a.to(u64)) == 11);
2474	2710
2475		testing.expect(a.cmp(try Int.initSet(al, 11)) == 0);
2476		testing.expect(a.cmp(try Int.initSet(al, 14)) <= 0);
	2711	const c = try Int.initSet(testing.allocator, 11);
	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	587	r.swap(&x);
588	588	}
589	589
590		var buffer: [64 * 8192]u8 = undefined;
591		var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
592		var al = &fixed.allocator;
593
594	590	test "big.rational gcd non-one small" {
595		var a = try Int.initSet(al, 17);
596		var b = try Int.initSet(al, 97);
597		var r = try Int.init(al);
	591	var a = try Int.initSet(testing.allocator, 17);
	592	defer a.deinit();
	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();
598	597
599	598	try gcd(&r, a, b);
600	599
...	...	@@ -602,9 +601,12 @@ test "big.rational gcd non-one small" {
602	601	}
603	602
604	603	test "big.rational gcd non-one small" {
605		var a = try Int.initSet(al, 4864);
606		var b = try Int.initSet(al, 3458);
607		var r = try Int.init(al);
	604	var a = try Int.initSet(testing.allocator, 4864);
	605	defer a.deinit();
	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();
608	610
609	611	try gcd(&r, a, b);
610	612
...	...	@@ -612,9 +614,12 @@ test "big.rational gcd non-one small" {
612	614	}
613	615
614	616	test "big.rational gcd non-one large" {
615		var a = try Int.initSet(al, 0xffffffffffffffff);
616		var b = try Int.initSet(al, 0xffffffffffffffff7777);
617		var r = try Int.init(al);
	617	var a = try Int.initSet(testing.allocator, 0xffffffffffffffff);
	618	defer a.deinit();
	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();
618	623
619	624	try gcd(&r, a, b);
620	625
...	...	@@ -622,9 +627,12 @@ test "big.rational gcd non-one large" {
622	627	}
623	628
624	629	test "big.rational gcd large multi-limb result" {
625		var a = try Int.initSet(al, 0x12345678123456781234567812345678123456781234567812345678);
626		var b = try Int.initSet(al, 0x12345671234567123456712345671234567123456712345671234567);
627		var r = try Int.init(al);
	630	var a = try Int.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
	631	defer a.deinit();
	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();
628	636
629	637	try gcd(&r, a, b);
630	638
...	...	@@ -632,9 +640,12 @@ test "big.rational gcd large multi-limb result" {
632	640	}
633	641
634	642	test "big.rational gcd one large" {
635		var a = try Int.initSet(al, 1897056385327307);
636		var b = try Int.initSet(al, 2251799813685248);
637		var r = try Int.init(al);
	643	var a = try Int.initSet(testing.allocator, 1897056385327307);
	644	defer a.deinit();
	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();
638	649
639	650	try gcd(&r, a, b);
640	651
...	...	@@ -661,7 +672,8 @@ fn extractLowBits(a: Int, comptime T: type) T {
661	672	}
662	673
663	674	test "big.rational extractLowBits" {
664		var a = try Int.initSet(al, 0x11112222333344441234567887654321);
	675	var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321);
	676	defer a.deinit();
665	677
666	678	const a1 = extractLowBits(a, u8);
667	679	testing.expect(a1 == 0x21);
...	...	@@ -680,7 +692,8 @@ test "big.rational extractLowBits" {
680	692	}
681	693
682	694	test "big.rational set" {
683		var a = try Rational.init(al);
	695	var a = try Rational.init(testing.allocator);
	696	defer a.deinit();
684	697
685	698	try a.setInt(5);
686	699	testing.expect((try a.p.to(u32)) == 5);
...	...	@@ -708,7 +721,8 @@ test "big.rational set" {
708	721	}
709	722
710	723	test "big.rational setFloat" {
711		var a = try Rational.init(al);
	724	var a = try Rational.init(testing.allocator);
	725	defer a.deinit();
712	726
713	727	try a.setFloat(f64, 2.5);
714	728	testing.expect((try a.p.to(i32)) == 5);
...	...	@@ -732,7 +746,8 @@ test "big.rational setFloat" {
732	746	}
733	747
734	748	test "big.rational setFloatString" {
735		var a = try Rational.init(al);
	749	var a = try Rational.init(testing.allocator);
	750	defer a.deinit();
736	751
737	752	try a.setFloatString("72.14159312071241458852455252781510353");
738	753
...	...	@@ -742,7 +757,8 @@ test "big.rational setFloatString" {
742	757	}
743	758
744	759	test "big.rational toFloat" {
745		var a = try Rational.init(al);
	760	var a = try Rational.init(testing.allocator);
	761	defer a.deinit();
746	762
747	763	// = 3.14159297943115234375
748	764	try a.setRatio(3294199, 1048576);
...	...	@@ -754,7 +770,8 @@ test "big.rational toFloat" {
754	770	}
755	771
756	772	test "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	775	var prng = std.rand.DefaultPrng.init(0x5EED);
759	776	var i: usize = 0;
760	777	while (i < 512) : (i += 1) {
...	...	@@ -765,23 +782,29 @@ test "big.rational set/to Float round-trip" {
765	782	}
766	783
767	784	test "big.rational copy" {
768		var a = try Rational.init(al);
	785	var a = try Rational.init(testing.allocator);
	786	defer a.deinit();
769	787
770		const b = try Int.initSet(al, 5);
	788	const b = try Int.initSet(testing.allocator, 5);
	789	defer b.deinit();
771	790
772	791	try a.copyInt(b);
773	792	testing.expect((try a.p.to(u32)) == 5);
774	793	testing.expect((try a.q.to(u32)) == 1);
775	794
776		const c = try Int.initSet(al, 7);
777		const d = try Int.initSet(al, 3);
	795	const c = try Int.initSet(testing.allocator, 7);
	796	defer c.deinit();
	797	const d = try Int.initSet(testing.allocator, 3);
	798	defer d.deinit();
778	799
779	800	try a.copyRatio(c, d);
780	801	testing.expect((try a.p.to(u32)) == 7);
781	802	testing.expect((try a.q.to(u32)) == 3);
782	803
783		const e = try Int.initSet(al, 9);
784		const f = try Int.initSet(al, 3);
	804	const e = try Int.initSet(testing.allocator, 9);
	805	defer e.deinit();
	806	const f = try Int.initSet(testing.allocator, 3);
	807	defer f.deinit();
785	808
786	809	try a.copyRatio(e, f);
787	810	testing.expect((try a.p.to(u32)) == 3);
...	...	@@ -789,7 +812,8 @@ test "big.rational copy" {
789	812	}
790	813
791	814	test "big.rational negate" {
792		var a = try Rational.init(al);
	815	var a = try Rational.init(testing.allocator);
	816	defer a.deinit();
793	817
794	818	try a.setInt(-50);
795	819	testing.expect((try a.p.to(i32)) == -50);
...	...	@@ -805,7 +829,8 @@ test "big.rational negate" {
805	829	}
806	830
807	831	test "big.rational abs" {
808		var a = try Rational.init(al);
	832	var a = try Rational.init(testing.allocator);
	833	defer a.deinit();
809	834
810	835	try a.setInt(-50);
811	836	testing.expect((try a.p.to(i32)) == -50);
...	...	@@ -821,8 +846,10 @@ test "big.rational abs" {
821	846	}
822	847
823	848	test "big.rational swap" {
824		var a = try Rational.init(al);
825		var b = try Rational.init(al);
	849	var a = try Rational.init(testing.allocator);
	850	defer a.deinit();
	851	var b = try Rational.init(testing.allocator);
	852	defer b.deinit();
826	853
827	854	try a.setRatio(50, 23);
828	855	try b.setRatio(17, 3);
...	...	@@ -843,8 +870,10 @@ test "big.rational swap" {
843	870	}
844	871
845	872	test "big.rational cmp" {
846		var a = try Rational.init(al);
847		var b = try Rational.init(al);
	873	var a = try Rational.init(testing.allocator);
	874	defer a.deinit();
	875	var b = try Rational.init(testing.allocator);
	876	defer b.deinit();
848	877
849	878	try a.setRatio(500, 231);
850	879	try b.setRatio(18903, 8584);
...	...	@@ -856,8 +885,10 @@ test "big.rational cmp" {
856	885	}
857	886
858	887	test "big.rational add single-limb" {
859		var a = try Rational.init(al);
860		var b = try Rational.init(al);
	888	var a = try Rational.init(testing.allocator);
	889	defer a.deinit();
	890	var b = try Rational.init(testing.allocator);
	891	defer b.deinit();
861	892
862	893	try a.setRatio(500, 231);
863	894	try b.setRatio(18903, 8584);
...	...	@@ -869,9 +900,12 @@ test "big.rational add single-limb" {
869	900	}
870	901
871	902	test "big.rational add" {
872		var a = try Rational.init(al);
873		var b = try Rational.init(al);
874		var r = try Rational.init(al);
	903	var a = try Rational.init(testing.allocator);
	904	defer a.deinit();
	905	var b = try Rational.init(testing.allocator);
	906	defer b.deinit();
	907	var r = try Rational.init(testing.allocator);
	908	defer r.deinit();
875	909
876	910	try a.setRatio(78923, 23341);
877	911	try b.setRatio(123097, 12441414);
...	...	@@ -882,9 +916,12 @@ test "big.rational add" {
882	916	}
883	917
884	918	test "big.rational sub" {
885		var a = try Rational.init(al);
886		var b = try Rational.init(al);
887		var r = try Rational.init(al);
	919	var a = try Rational.init(testing.allocator);
	920	defer a.deinit();
	921	var b = try Rational.init(testing.allocator);
	922	defer b.deinit();
	923	var r = try Rational.init(testing.allocator);
	924	defer r.deinit();
888	925
889	926	try a.setRatio(78923, 23341);
890	927	try b.setRatio(123097, 12441414);
...	...	@@ -895,9 +932,12 @@ test "big.rational sub" {
895	932	}
896	933
897	934	test "big.rational mul" {
898		var a = try Rational.init(al);
899		var b = try Rational.init(al);
900		var r = try Rational.init(al);
	935	var a = try Rational.init(testing.allocator);
	936	defer a.deinit();
	937	var b = try Rational.init(testing.allocator);
	938	defer b.deinit();
	939	var r = try Rational.init(testing.allocator);
	940	defer r.deinit();
901	941
902	942	try a.setRatio(78923, 23341);
903	943	try b.setRatio(123097, 12441414);
...	...	@@ -908,9 +948,12 @@ test "big.rational mul" {
908	948	}
909	949
910	950	test "big.rational div" {
911		var a = try Rational.init(al);
912		var b = try Rational.init(al);
913		var r = try Rational.init(al);
	951	var a = try Rational.init(testing.allocator);
	952	defer a.deinit();
	953	var b = try Rational.init(testing.allocator);
	954	defer b.deinit();
	955	var r = try Rational.init(testing.allocator);
	956	defer r.deinit();
914	957
915	958	try a.setRatio(78923, 23341);
916	959	try b.setRatio(123097, 12441414);
...	...	@@ -921,8 +964,10 @@ test "big.rational div" {
921	964	}
922	965
923	966	test "big.rational div" {
924		var a = try Rational.init(al);
925		var r = try Rational.init(al);
	967	var a = try Rational.init(testing.allocator);
	968	defer a.deinit();
	969	var r = try Rational.init(testing.allocator);
	970	defer r.deinit();
926	971
927	972	try a.setRatio(78923, 23341);
928	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	1011	}
1012	1012
1013	1013	test "mem.join" {
1014		var buf: [1024]u8 = undefined;
1015		const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
1016		testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "b", "c" }), "a,b,c"));
1017		testing.expect(eql(u8, try join(a, ",", &[_][]const u8{"a"}), "a"));
1018		testing.expect(eql(u8, try join(a, ",", &[_][]const u8{ "a", "", "b", "", "c" }), "a,,b,,c"));
	1014	{
	1015	const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "b", "c" });
	1016	defer testing.allocator.free(str);
	1017	testing.expect(eql(u8, str, "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	}
1020	1030
1021	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	1054	}
1045	1055
1046	1056	test "concat" {
1047		var buf: [1024]u8 = undefined;
1048		const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
1049		testing.expect(eql(u8, try concat(a, u8, &[_][]const u8{ "abc", "def", "ghi" }), "abcdefghi"));
1050		testing.expect(eql(u32, try concat(a, u32, &[_][]const u32{
1051		&[_]u32{ 0, 1 },
1052		&[_]u32{ 2, 3, 4 },
1053		&[_]u32{},
1054		&[_]u32{5},
1055		}), &[_]u32{ 0, 1, 2, 3, 4, 5 }));
	1057	{
	1058	const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" });
	1059	defer testing.allocator.free(str);
	1060	testing.expect(eql(u8, str, "abcdefghi"));
	1061	}
	1062	{
	1063	const str = try concat(testing.allocator, u32, &[_][]const u32{
	1064	&[_]u32{ 0, 1 },
	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	}
1057	1073
1058	1074	test "testStringEquality" {

lib/std/net/test.zig+1-3

...	...	@@ -67,10 +67,8 @@ test "resolve DNS" {
67	67	// DNS resolution not implemented on Windows yet.
68	68	return error.SkipZigTest;
69	69	}
70		var buf: [1000 * 10]u8 = undefined;
71		const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
72	70
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	72	// The tests are required to work even when there is no Internet connection,
75	73	// so some of these errors we must accept and skip the test.
76	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	12	pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator;
13	13
14	14	pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
15		var allocator_mem: [512 * 1024]u8 = undefined;
	15	var allocator_mem: [1024 * 1024]u8 = undefined;
16	16
17	17	/// This function is intended to be used only in tests. It prints diagnostics to stderr
18	18	/// and then aborts when actual_error_union is not expected_error.