Commit ca41567924d0576be9a000076d29ec5f46a93e95 | zig

author	daurnimator <quae@daurnimator.com> 2020-02-14 18:59:40+11:00
committer	daurnimator <quae@daurnimator.com> 2020-02-14 18:59:40+11:00
log	ca41567924d0576be9a000076d29ec5f46a93e95
tree	5f5e6d34404348542626d94d979463cb2d360b2a
parent	f20ba7c32c1b06104dd91c0c654ac1d0fc0a9c1e
signature	Commit is signed but in an unrecognized format.

std: use testing.allocator in big int tests

1 files changed, 502 insertions(+), 260 deletions(-)

lib
- std
  - math
    big
    int.zig

lib/std/math/big/int.zig+502-260

...	...	@@ -1360,13 +1360,10 @@ pub const Int = struct {
1360	1360	// They will still run on larger than this and should pass, but the multi-limb code-paths
1361	1361	// may be untested in some cases.
1362	1362
1363		var buffer: [64 * 8192]u8 = undefined;
1364		var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
1365		const al = &fixed.allocator;
1366
1367	1363	test "big.int comptime_int set" {
1368	1364	comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;
1369		var a = try Int.initSet(al, s);
	1365	var a = try Int.initSet(testing.allocator, s);
	1366	defer a.deinit();
1370	1367
1371	1368	const s_limb_count = 128 / Limb.bit_count;
1372	1369
...	...	@@ -1380,39 +1377,45 @@ test "big.int comptime_int set" {
1380	1377	}
1381	1378
1382	1379	test "big.int comptime_int set negative" {
1383		var a = try Int.initSet(al, -10);
	1380	var a = try Int.initSet(testing.allocator, -10);
	1381	defer a.deinit();
1384	1382
1385	1383	testing.expect(a.limbs[0] == 10);
1386	1384	testing.expect(a.isPositive() == false);
1387	1385	}
1388	1386
1389	1387	test "big.int int set unaligned small" {
1390		var a = try Int.initSet(al, @as(u7, 45));
	1388	var a = try Int.initSet(testing.allocator, @as(u7, 45));
	1389	defer a.deinit();
1391	1390
1392	1391	testing.expect(a.limbs[0] == 45);
1393	1392	testing.expect(a.isPositive() == true);
1394	1393	}
1395	1394
1396	1395	test "big.int comptime_int to" {
1397		const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
	1396	const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
	1397	defer a.deinit();
1398	1398
1399	1399	testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
1400	1400	}
1401	1401
1402	1402	test "big.int sub-limb to" {
1403		const a = try Int.initSet(al, 10);
	1403	const a = try Int.initSet(testing.allocator, 10);
	1404	defer a.deinit();
1404	1405
1405	1406	testing.expect((try a.to(u8)) == 10);
1406	1407	}
1407	1408
1408	1409	test "big.int to target too small error" {
1409		const a = try Int.initSet(al, 0xffffffff);
	1410	const a = try Int.initSet(testing.allocator, 0xffffffff);
	1411	defer a.deinit();
1410	1412
1411	1413	testing.expectError(error.TargetTooSmall, a.to(u8));
1412	1414	}
1413	1415
1414	1416	test "big.int normalize" {
1415		var a = try Int.init(al);
	1417	var a = try Int.init(testing.allocator);
	1418	defer a.deinit();
1416	1419	try a.ensureCapacity(8);
1417	1420
1418	1421	a.limbs[0] = 1;
...	...	@@ -1439,7 +1442,8 @@ test "big.int normalize" {
1439	1442	}
1440	1443
1441	1444	test "big.int normalize multi" {
1442		var a = try Int.init(al);
	1445	var a = try Int.init(testing.allocator);
	1446	defer a.deinit();
1443	1447	try a.ensureCapacity(8);
1444	1448
1445	1449	a.limbs[0] = 1;
...	...	@@ -1468,7 +1472,9 @@ test "big.int normalize multi" {
1468	1472	}
1469	1473
1470	1474	test "big.int parity" {
1471		var a = try Int.init(al);
	1475	var a = try Int.init(testing.allocator);
	1476	defer a.deinit();
	1477
1472	1478	try a.set(0);
1473	1479	testing.expect(a.isEven());
1474	1480	testing.expect(!a.isOdd());
...	...	@@ -1479,7 +1485,8 @@ test "big.int parity" {
1479	1485	}
1480	1486
1481	1487	test "big.int bitcount + sizeInBase" {
1482		var a = try Int.init(al);
	1488	var a = try Int.init(testing.allocator);
	1489	defer a.deinit();
1483	1490
1484	1491	try a.set(0b100);
1485	1492	testing.expect(a.bitCountAbs() == 3);
...	...	@@ -1506,7 +1513,8 @@ test "big.int bitcount + sizeInBase" {
1506	1513	}
1507	1514
1508	1515	test "big.int bitcount/to" {
1509		var a = try Int.init(al);
	1516	var a = try Int.init(testing.allocator);
	1517	defer a.deinit();
1510	1518
1511	1519	try a.set(0);
1512	1520	testing.expect(a.bitCountTwosComp() == 0);
...	...	@@ -1536,7 +1544,8 @@ test "big.int bitcount/to" {
1536	1544	}
1537	1545
1538	1546	test "big.int fits" {
1539		var a = try Int.init(al);
	1547	var a = try Int.init(testing.allocator);
	1548	defer a.deinit();
1540	1549
1541	1550	try a.set(0);
1542	1551	testing.expect(a.fits(u0));
...	...	@@ -1563,82 +1572,100 @@ test "big.int fits" {
1563	1572	}
1564	1573
1565	1574	test "big.int string set" {
1566		var a = try Int.init(al);
1567		try a.setString(10, "120317241209124781241290847124");
	1575	var a = try Int.init(testing.allocator);
	1576	defer a.deinit();
1568	1577
	1578	try a.setString(10, "120317241209124781241290847124");
1569	1579	testing.expect((try a.to(u128)) == 120317241209124781241290847124);
1570	1580	}
1571	1581
1572	1582	test "big.int string negative" {
1573		var a = try Int.init(al);
	1583	var a = try Int.init(testing.allocator);
	1584	defer a.deinit();
	1585
1574	1586	try a.setString(10, "-1023");
1575	1587	testing.expect((try a.to(i32)) == -1023);
1576	1588	}
1577	1589
1578	1590	test "big.int string set bad char error" {
1579		var a = try Int.init(al);
	1591	var a = try Int.init(testing.allocator);
	1592	defer a.deinit();
1580	1593	testing.expectError(error.InvalidCharForDigit, a.setString(10, "x"));
1581	1594	}
1582	1595
1583	1596	test "big.int string set bad base error" {
1584		var a = try Int.init(al);
	1597	var a = try Int.init(testing.allocator);
	1598	defer a.deinit();
1585	1599	testing.expectError(error.InvalidBase, a.setString(45, "10"));
1586	1600	}
1587	1601
1588	1602	test "big.int string to" {
1589		const a = try Int.initSet(al, 120317241209124781241290847124);
	1603	const a = try Int.initSet(testing.allocator, 120317241209124781241290847124);
	1604	defer a.deinit();
1590	1605
1591		const as = try a.toString(al, 10);
	1606	const as = try a.toString(testing.allocator, 10);
	1607	defer testing.allocator.free(as);
1592	1608	const es = "120317241209124781241290847124";
1593	1609
1594	1610	testing.expect(mem.eql(u8, as, es));
1595	1611	}
1596	1612
1597	1613	test "big.int string to base base error" {
1598		const a = try Int.initSet(al, 0xffffffff);
	1614	const a = try Int.initSet(testing.allocator, 0xffffffff);
	1615	defer a.deinit();
1599	1616
1600		testing.expectError(error.InvalidBase, a.toString(al, 45));
	1617	testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45));
1601	1618	}
1602	1619
1603	1620	test "big.int string to base 2" {
1604		const a = try Int.initSet(al, -0b1011);
	1621	const a = try Int.initSet(testing.allocator, -0b1011);
	1622	defer a.deinit();
1605	1623
1606		const as = try a.toString(al, 2);
	1624	const as = try a.toString(testing.allocator, 2);
	1625	defer testing.allocator.free(as);
1607	1626	const es = "-1011";
1608	1627
1609	1628	testing.expect(mem.eql(u8, as, es));
1610	1629	}
1611	1630
1612	1631	test "big.int string to base 16" {
1613		const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
	1632	const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
	1633	defer a.deinit();
1614	1634
1615		const as = try a.toString(al, 16);
	1635	const as = try a.toString(testing.allocator, 16);
	1636	defer testing.allocator.free(as);
1616	1637	const es = "efffffff00000001eeeeeeefaaaaaaab";
1617	1638
1618	1639	testing.expect(mem.eql(u8, as, es));
1619	1640	}
1620	1641
1621	1642	test "big.int neg string to" {
1622		const a = try Int.initSet(al, -123907434);
	1643	const a = try Int.initSet(testing.allocator, -123907434);
	1644	defer a.deinit();
1623	1645
1624		const as = try a.toString(al, 10);
	1646	const as = try a.toString(testing.allocator, 10);
	1647	defer testing.allocator.free(as);
1625	1648	const es = "-123907434";
1626	1649
1627	1650	testing.expect(mem.eql(u8, as, es));
1628	1651	}
1629	1652
1630	1653	test "big.int zero string to" {
1631		const a = try Int.initSet(al, 0);
	1654	const a = try Int.initSet(testing.allocator, 0);
	1655	defer a.deinit();
1632	1656
1633		const as = try a.toString(al, 10);
	1657	const as = try a.toString(testing.allocator, 10);
	1658	defer testing.allocator.free(as);
1634	1659	const es = "0";
1635	1660
1636	1661	testing.expect(mem.eql(u8, as, es));
1637	1662	}
1638	1663
1639	1664	test "big.int clone" {
1640		var a = try Int.initSet(al, 1234);
	1665	var a = try Int.initSet(testing.allocator, 1234);
	1666	defer a.deinit();
1641	1667	const b = try a.clone();
	1668	defer b.deinit();
1642	1669
1643	1670	testing.expect((try a.to(u32)) == 1234);
1644	1671	testing.expect((try b.to(u32)) == 1234);
...	...	@@ -1649,8 +1676,10 @@ test "big.int clone" {
1649	1676	}
1650	1677
1651	1678	test "big.int swap" {
1652		var a = try Int.initSet(al, 1234);
1653		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();
1654	1683
1655	1684	testing.expect((try a.to(u32)) == 1234);
1656	1685	testing.expect((try b.to(u32)) == 5678);
...	...	@@ -1662,53 +1691,65 @@ test "big.int swap" {
1662	1691	}
1663	1692
1664	1693	test "big.int to negative" {
1665		var a = try Int.initSet(al, -10);
	1694	var a = try Int.initSet(testing.allocator, -10);
	1695	defer a.deinit();
1666	1696
1667	1697	testing.expect((try a.to(i32)) == -10);
1668	1698	}
1669	1699
1670	1700	test "big.int compare" {
1671		var a = try Int.initSet(al, -11);
1672		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();
1673	1705
1674	1706	testing.expect(a.cmpAbs(b) == 1);
1675	1707	testing.expect(a.cmp(b) == -1);
1676	1708	}
1677	1709
1678	1710	test "big.int compare similar" {
1679		var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);
1680		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();
1681	1715
1682	1716	testing.expect(a.cmpAbs(b) == -1);
1683	1717	testing.expect(b.cmpAbs(a) == 1);
1684	1718	}
1685	1719
1686	1720	test "big.int compare different limb size" {
1687		var a = try Int.initSet(al, maxInt(Limb) + 1);
1688		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();
1689	1725
1690	1726	testing.expect(a.cmpAbs(b) == 1);
1691	1727	testing.expect(b.cmpAbs(a) == -1);
1692	1728	}
1693	1729
1694	1730	test "big.int compare multi-limb" {
1695		var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
1696		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();
1697	1735
1698	1736	testing.expect(a.cmpAbs(b) == 1);
1699	1737	testing.expect(a.cmp(b) == -1);
1700	1738	}
1701	1739
1702	1740	test "big.int equality" {
1703		var a = try Int.initSet(al, 0xffffffff1);
1704		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();
1705	1745
1706	1746	testing.expect(a.eqAbs(b));
1707	1747	testing.expect(!a.eq(b));
1708	1748	}
1709	1749
1710	1750	test "big.int abs" {
1711		var a = try Int.initSet(al, -5);
	1751	var a = try Int.initSet(testing.allocator, -5);
	1752	defer a.deinit();
1712	1753
1713	1754	a.abs();
1714	1755	testing.expect((try a.to(u32)) == 5);
...	...	@@ -1718,7 +1759,8 @@ test "big.int abs" {
1718	1759	}
1719	1760
1720	1761	test "big.int negate" {
1721		var a = try Int.initSet(al, 5);
	1762	var a = try Int.initSet(testing.allocator, 5);
	1763	defer a.deinit();
1722	1764
1723	1765	a.negate();
1724	1766	testing.expect((try a.to(i32)) == -5);
...	...	@@ -1728,20 +1770,26 @@ test "big.int negate" {
1728	1770	}
1729	1771
1730	1772	test "big.int add single-single" {
1731		var a = try Int.initSet(al, 50);
1732		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();
1733	1777
1734		var c = try Int.init(al);
	1778	var c = try Int.init(testing.allocator);
	1779	defer c.deinit();
1735	1780	try c.add(a, b);
1736	1781
1737	1782	testing.expect((try c.to(u32)) == 55);
1738	1783	}
1739	1784
1740	1785	test "big.int add multi-single" {
1741		var a = try Int.initSet(al, maxInt(Limb) + 1);
1742		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();
1743	1790
1744		var c = try Int.init(al);
	1791	var c = try Int.init(testing.allocator);
	1792	defer c.deinit();
1745	1793
1746	1794	try c.add(a, b);
1747	1795	testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
...	...	@@ -1753,20 +1801,26 @@ test "big.int add multi-single" {
1753	1801	test "big.int add multi-multi" {
1754	1802	const op1 = 0xefefefef7f7f7f7f;
1755	1803	const op2 = 0xfefefefe9f9f9f9f;
1756		var a = try Int.initSet(al, op1);
1757		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();
1758	1808
1759		var c = try Int.init(al);
	1809	var c = try Int.init(testing.allocator);
	1810	defer c.deinit();
1760	1811	try c.add(a, b);
1761	1812
1762	1813	testing.expect((try c.to(u128)) == op1 + op2);
1763	1814	}
1764	1815
1765	1816	test "big.int add zero-zero" {
1766		var a = try Int.initSet(al, 0);
1767		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();
1768	1821
1769		var c = try Int.init(al);
	1822	var c = try Int.init(testing.allocator);
	1823	defer c.deinit();
1770	1824	try c.add(a, b);
1771	1825
1772	1826	testing.expect((try c.to(u32)) == 0);
...	...	@@ -1774,8 +1828,10 @@ test "big.int add zero-zero" {
1774	1828
1775	1829	test "big.int add alias multi-limb nonzero-zero" {
1776	1830	const op1 = 0xffffffff777777771;
1777		var a = try Int.initSet(al, op1);
1778		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();
1779	1835
1780	1836	try a.add(a, b);
1781	1837
...	...	@@ -1783,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {
1783	1839	}
1784	1840
1785	1841	test "big.int add sign" {
1786		var a = try Int.init(al);
1787
1788		const one = try Int.initSet(al, 1);
1789		const two = try Int.initSet(al, 2);
1790		const neg_one = try Int.initSet(al, -1);
1791		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();
1792	1853
1793	1854	try a.add(one, two);
1794	1855	testing.expect((try a.to(i32)) == 3);
...	...	@@ -1804,20 +1865,26 @@ test "big.int add sign" {
1804	1865	}
1805	1866
1806	1867	test "big.int sub single-single" {
1807		var a = try Int.initSet(al, 50);
1808		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();
1809	1872
1810		var c = try Int.init(al);
	1873	var c = try Int.init(testing.allocator);
	1874	defer c.deinit();
1811	1875	try c.sub(a, b);
1812	1876
1813	1877	testing.expect((try c.to(u32)) == 45);
1814	1878	}
1815	1879
1816	1880	test "big.int sub multi-single" {
1817		var a = try Int.initSet(al, maxInt(Limb) + 1);
1818		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();
1819	1885
1820		var c = try Int.init(al);
	1886	var c = try Int.init(testing.allocator);
	1887	defer c.deinit();
1821	1888	try c.sub(a, b);
1822	1889
1823	1890	testing.expect((try c.to(Limb)) == maxInt(Limb));
...	...	@@ -1827,32 +1894,43 @@ test "big.int sub multi-multi" {
1827	1894	const op1 = 0xefefefefefefefefefefefef;
1828	1895	const op2 = 0xabababababababababababab;
1829	1896
1830		var a = try Int.initSet(al, op1);
1831		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();
1832	1901
1833		var c = try Int.init(al);
	1902	var c = try Int.init(testing.allocator);
	1903	defer c.deinit();
1834	1904	try c.sub(a, b);
1835	1905
1836	1906	testing.expect((try c.to(u128)) == op1 - op2);
1837	1907	}
1838	1908
1839	1909	test "big.int sub equal" {
1840		var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);
1841		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();
1842	1914
1843		var c = try Int.init(al);
	1915	var c = try Int.init(testing.allocator);
	1916	defer c.deinit();
1844	1917	try c.sub(a, b);
1845	1918
1846	1919	testing.expect((try c.to(u32)) == 0);
1847	1920	}
1848	1921
1849	1922	test "big.int sub sign" {
1850		var a = try Int.init(al);
1851
1852		const one = try Int.initSet(al, 1);
1853		const two = try Int.initSet(al, 2);
1854		const neg_one = try Int.initSet(al, -1);
1855		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();
1856	1934
1857	1935	try a.sub(one, two);
1858	1936	testing.expect((try a.to(i32)) == -1);
...	...	@@ -1871,20 +1949,26 @@ test "big.int sub sign" {
1871	1949	}
1872	1950
1873	1951	test "big.int mul single-single" {
1874		var a = try Int.initSet(al, 50);
1875		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();
1876	1956
1877		var c = try Int.init(al);
	1957	var c = try Int.init(testing.allocator);
	1958	defer c.deinit();
1878	1959	try c.mul(a, b);
1879	1960
1880	1961	testing.expect((try c.to(u64)) == 250);
1881	1962	}
1882	1963
1883	1964	test "big.int mul multi-single" {
1884		var a = try Int.initSet(al, maxInt(Limb));
1885		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();
1886	1969
1887		var c = try Int.init(al);
	1970	var c = try Int.init(testing.allocator);
	1971	defer c.deinit();
1888	1972	try c.mul(a, b);
1889	1973
1890	1974	testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));
...	...	@@ -1893,18 +1977,23 @@ test "big.int mul multi-single" {
1893	1977	test "big.int mul multi-multi" {
1894	1978	const op1 = 0x998888efefefefefefefef;
1895	1979	const op2 = 0x333000abababababababab;
1896		var a = try Int.initSet(al, op1);
1897		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();
1898	1984
1899		var c = try Int.init(al);
	1985	var c = try Int.init(testing.allocator);
	1986	defer c.deinit();
1900	1987	try c.mul(a, b);
1901	1988
1902	1989	testing.expect((try c.to(u256)) == op1 * op2);
1903	1990	}
1904	1991
1905	1992	test "big.int mul alias r with a" {
1906		var a = try Int.initSet(al, maxInt(Limb));
1907		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();
1908	1997
1909	1998	try a.mul(a, b);
1910	1999
...	...	@@ -1912,8 +2001,10 @@ test "big.int mul alias r with a" {
1912	2001	}
1913	2002
1914	2003	test "big.int mul alias r with b" {
1915		var a = try Int.initSet(al, maxInt(Limb));
1916		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();
1917	2008
1918	2009	try a.mul(b, a);
1919	2010
...	...	@@ -1921,7 +2012,8 @@ test "big.int mul alias r with b" {
1921	2012	}
1922	2013
1923	2014	test "big.int mul alias r with a and b" {
1924		var a = try Int.initSet(al, maxInt(Limb));
	2015	var a = try Int.initSet(testing.allocator, maxInt(Limb));
	2016	defer a.deinit();
1925	2017
1926	2018	try a.mul(a, a);
1927	2019
...	...	@@ -1929,31 +2021,41 @@ test "big.int mul alias r with a and b" {
1929	2021	}
1930	2022
1931	2023	test "big.int mul a*0" {
1932		var a = try Int.initSet(al, 0xefefefefefefefef);
1933		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();
1934	2028
1935		var c = try Int.init(al);
	2029	var c = try Int.init(testing.allocator);
	2030	defer c.deinit();
1936	2031	try c.mul(a, b);
1937	2032
1938	2033	testing.expect((try c.to(u32)) == 0);
1939	2034	}
1940	2035
1941	2036	test "big.int mul 0*0" {
1942		var a = try Int.initSet(al, 0);
1943		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();
1944	2041
1945		var c = try Int.init(al);
	2042	var c = try Int.init(testing.allocator);
	2043	defer c.deinit();
1946	2044	try c.mul(a, b);
1947	2045
1948	2046	testing.expect((try c.to(u32)) == 0);
1949	2047	}
1950	2048
1951	2049	test "big.int div single-single no rem" {
1952		var a = try Int.initSet(al, 50);
1953		var b = try Int.initSet(al, 5);
1954
1955		var q = try Int.init(al);
1956		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();
1957	2059	try Int.divTrunc(&q, &r, a, b);
1958	2060
1959	2061	testing.expect((try q.to(u32)) == 10);
...	...	@@ -1961,11 +2063,15 @@ test "big.int div single-single no rem" {
1961	2063	}
1962	2064
1963	2065	test "big.int div single-single with rem" {
1964		var a = try Int.initSet(al, 49);
1965		var b = try Int.initSet(al, 5);
1966
1967		var q = try Int.init(al);
1968		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();
1969	2075	try Int.divTrunc(&q, &r, a, b);
1970	2076
1971	2077	testing.expect((try q.to(u32)) == 9);
...	...	@@ -1976,11 +2082,15 @@ test "big.int div multi-single no rem" {
1976	2082	const op1 = 0xffffeeeeddddcccc;
1977	2083	const op2 = 34;
1978	2084
1979		var a = try Int.initSet(al, op1);
1980		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();
1981	2089
1982		var q = try Int.init(al);
1983		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();
1984	2094	try Int.divTrunc(&q, &r, a, b);
1985	2095
1986	2096	testing.expect((try q.to(u64)) == op1 / op2);
...	...	@@ -1991,11 +2101,15 @@ test "big.int div multi-single with rem" {
1991	2101	const op1 = 0xffffeeeeddddcccf;
1992	2102	const op2 = 34;
1993	2103
1994		var a = try Int.initSet(al, op1);
1995		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();
1996	2108
1997		var q = try Int.init(al);
1998		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();
1999	2113	try Int.divTrunc(&q, &r, a, b);
2000	2114
2001	2115	testing.expect((try q.to(u64)) == op1 / op2);
...	...	@@ -2006,11 +2120,15 @@ test "big.int div multi>2-single" {
2006	2120	const op1 = 0xfefefefefefefefefefefefefefefefe;
2007	2121	const op2 = 0xefab8;
2008	2122
2009		var a = try Int.initSet(al, op1);
2010		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();
2011	2127
2012		var q = try Int.init(al);
2013		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();
2014	2132	try Int.divTrunc(&q, &r, a, b);
2015	2133
2016	2134	testing.expect((try q.to(u128)) == op1 / op2);
...	...	@@ -2018,11 +2136,15 @@ test "big.int div multi>2-single" {
2018	2136	}
2019	2137
2020	2138	test "big.int div single-single q < r" {
2021		var a = try Int.initSet(al, 0x0078f432);
2022		var b = try Int.initSet(al, 0x01000000);
2023
2024		var q = try Int.init(al);
2025		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();
2026	2148	try Int.divTrunc(&q, &r, a, b);
2027	2149
2028	2150	testing.expect((try q.to(u64)) == 0);
...	...	@@ -2030,11 +2152,15 @@ test "big.int div single-single q < r" {
2030	2152	}
2031	2153
2032	2154	test "big.int div single-single q == r" {
2033		var a = try Int.initSet(al, 10);
2034		var b = try Int.initSet(al, 10);
2035
2036		var q = try Int.init(al);
2037		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();
2038	2164	try Int.divTrunc(&q, &r, a, b);
2039	2165
2040	2166	testing.expect((try q.to(u64)) == 1);
...	...	@@ -2042,8 +2168,10 @@ test "big.int div single-single q == r" {
2042	2168	}
2043	2169
2044	2170	test "big.int div q=0 alias" {
2045		var a = try Int.initSet(al, 3);
2046		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();
2047	2175
2048	2176	try Int.divTrunc(&a, &b, a, b);
2049	2177
...	...	@@ -2054,11 +2182,15 @@ test "big.int div q=0 alias" {
2054	2182	test "big.int div multi-multi q < r" {
2055	2183	const op1 = 0x1ffffffff0078f432;
2056	2184	const op2 = 0x1ffffffff01000000;
2057		var a = try Int.initSet(al, op1);
2058		var b = try Int.initSet(al, op2);
2059
2060		var q = try Int.init(al);
2061		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();
2062	2194	try Int.divTrunc(&q, &r, a, b);
2063	2195
2064	2196	testing.expect((try q.to(u128)) == 0);
...	...	@@ -2069,11 +2201,15 @@ test "big.int div trunc single-single +/+" {
2069	2201	const u: i32 = 5;
2070	2202	const v: i32 = 3;
2071	2203
2072		var a = try Int.initSet(al, u);
2073		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();
2074	2208
2075		var q = try Int.init(al);
2076		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();
2077	2213	try Int.divTrunc(&q, &r, a, b);
2078	2214
2079	2215	// n = q * d + r
...	...	@@ -2089,11 +2225,15 @@ test "big.int div trunc single-single -/+" {
2089	2225	const u: i32 = -5;
2090	2226	const v: i32 = 3;
2091	2227
2092		var a = try Int.initSet(al, u);
2093		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();
2094	2232
2095		var q = try Int.init(al);
2096		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();
2097	2237	try Int.divTrunc(&q, &r, a, b);
2098	2238
2099	2239	// n = q * d + r
...	...	@@ -2109,11 +2249,15 @@ test "big.int div trunc single-single +/-" {
2109	2249	const u: i32 = 5;
2110	2250	const v: i32 = -3;
2111	2251
2112		var a = try Int.initSet(al, u);
2113		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();
2114	2256
2115		var q = try Int.init(al);
2116		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();
2117	2261	try Int.divTrunc(&q, &r, a, b);
2118	2262
2119	2263	// n = q * d + r
...	...	@@ -2129,11 +2273,15 @@ test "big.int div trunc single-single -/-" {
2129	2273	const u: i32 = -5;
2130	2274	const v: i32 = -3;
2131	2275
2132		var a = try Int.initSet(al, u);
2133		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();
2134	2280
2135		var q = try Int.init(al);
2136		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();
2137	2285	try Int.divTrunc(&q, &r, a, b);
2138	2286
2139	2287	// n = q * d + r
...	...	@@ -2149,11 +2297,15 @@ test "big.int div floor single-single +/+" {
2149	2297	const u: i32 = 5;
2150	2298	const v: i32 = 3;
2151	2299
2152		var a = try Int.initSet(al, u);
2153		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();
2154	2304
2155		var q = try Int.init(al);
2156		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();
2157	2309	try Int.divFloor(&q, &r, a, b);
2158	2310
2159	2311	// n = q * d + r
...	...	@@ -2169,11 +2321,15 @@ test "big.int div floor single-single -/+" {
2169	2321	const u: i32 = -5;
2170	2322	const v: i32 = 3;
2171	2323
2172		var a = try Int.initSet(al, u);
2173		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();
2174	2328
2175		var q = try Int.init(al);
2176		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();
2177	2333	try Int.divFloor(&q, &r, a, b);
2178	2334
2179	2335	// n = q * d + r
...	...	@@ -2189,11 +2345,15 @@ test "big.int div floor single-single +/-" {
2189	2345	const u: i32 = 5;
2190	2346	const v: i32 = -3;
2191	2347
2192		var a = try Int.initSet(al, u);
2193		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();
2194	2352
2195		var q = try Int.init(al);
2196		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();
2197	2357	try Int.divFloor(&q, &r, a, b);
2198	2358
2199	2359	// n = q * d + r
...	...	@@ -2209,11 +2369,15 @@ test "big.int div floor single-single -/-" {
2209	2369	const u: i32 = -5;
2210	2370	const v: i32 = -3;
2211	2371
2212		var a = try Int.initSet(al, u);
2213		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();
2214	2376
2215		var q = try Int.init(al);
2216		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();
2217	2381	try Int.divFloor(&q, &r, a, b);
2218	2382
2219	2383	// n = q * d + r
...	...	@@ -2226,11 +2390,15 @@ test "big.int div floor single-single -/-" {
2226	2390	}
2227	2391
2228	2392	test "big.int div multi-multi with rem" {
2229		var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
2230		var b = try Int.initSet(al, 0x99990000111122223333);
2231
2232		var q = try Int.init(al);
2233		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();
2234	2402	try Int.divTrunc(&q, &r, a, b);
2235	2403
2236	2404	testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...	...	@@ -2238,11 +2406,15 @@ test "big.int div multi-multi with rem" {
2238	2406	}
2239	2407
2240	2408	test "big.int div multi-multi no rem" {
2241		var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
2242		var b = try Int.initSet(al, 0x99990000111122223333);
2243
2244		var q = try Int.init(al);
2245		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();
2246	2418	try Int.divTrunc(&q, &r, a, b);
2247	2419
2248	2420	testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
...	...	@@ -2250,11 +2422,15 @@ test "big.int div multi-multi no rem" {
2250	2422	}
2251	2423
2252	2424	test "big.int div multi-multi (2 branch)" {
2253		var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);
2254		var b = try Int.initSet(al, 0x86666666555555554444444433333333);
2255
2256		var q = try Int.init(al);
2257		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();
2258	2434	try Int.divTrunc(&q, &r, a, b);
2259	2435
2260	2436	testing.expect((try q.to(u128)) == 0x10000000000000000);
...	...	@@ -2262,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" {
2262	2438	}
2263	2439
2264	2440	test "big.int div multi-multi (3.1/3.3 branch)" {
2265		var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);
2266		var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);
2267
2268		var q = try Int.init(al);
2269		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();
2270	2450	try Int.divTrunc(&q, &r, a, b);
2271	2451
2272	2452	testing.expect((try q.to(u128)) == 0xfffffffffffffffffff);
...	...	@@ -2274,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
2274	2454	}
2275	2455
2276	2456	test "big.int div multi-single zero-limb trailing" {
2277		var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000);
2278		var b = try Int.initSet(al, 0x10000000000000000);
2279
2280		var q = try Int.init(al);
2281		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();
2282	2466	try Int.divTrunc(&q, &r, a, b);
2283	2467
2284		var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000);
	2468	var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000);
	2469	defer expected.deinit();
2285	2470	testing.expect(q.eq(expected));
2286	2471	testing.expect(r.eqZero());
2287	2472	}
2288	2473
2289	2474	test "big.int div multi-multi zero-limb trailing (with rem)" {
2290		var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
2291		var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
2292
2293		var q = try Int.init(al);
2294		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();
2295	2484	try Int.divTrunc(&q, &r, a, b);
2296	2485
2297	2486	testing.expect((try q.to(u128)) == 0x10000000000000000);
2298	2487
2299		const rs = try r.toString(al, 16);
	2488	const rs = try r.toString(testing.allocator, 16);
	2489	defer testing.allocator.free(rs);
2300	2490	testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));
2301	2491	}
2302	2492
2303	2493	test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
2304		var a = try Int.initSet(al, 0x8666666655555555888888877777777611111111111111110000000000000000);
2305		var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
2306
2307		var q = try Int.init(al);
2308		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();
2309	2503	try Int.divTrunc(&q, &r, a, b);
2310	2504
2311	2505	testing.expect((try q.to(u128)) == 0x1);
2312	2506
2313		const rs = try r.toString(al, 16);
	2507	const rs = try r.toString(testing.allocator, 16);
	2508	defer testing.allocator.free(rs);
2314	2509	testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));
2315	2510	}
2316	2511
2317	2512	test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
2318		var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
2319		var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000);
2320
2321		var q = try Int.init(al);
2322		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();
2323	2522	try Int.divTrunc(&q, &r, a, b);
2324	2523
2325		const qs = try q.toString(al, 16);
	2524	const qs = try q.toString(testing.allocator, 16);
	2525	defer testing.allocator.free(qs);
2326	2526	testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f"));
2327	2527
2328		const rs = try r.toString(al, 16);
	2528	const rs = try r.toString(testing.allocator, 16);
	2529	defer testing.allocator.free(rs);
2329	2530	testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));
2330	2531	}
2331	2532
2332	2533	test "big.int div multi-multi fuzz case #1" {
2333		var a = try Int.init(al);
2334		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();
2335	2538
2336	2539	try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
2337	2540	try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff");
2338	2541
2339		var q = try Int.init(al);
2340		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();
2341	2546	try Int.divTrunc(&q, &r, a, b);
2342	2547
2343		const qs = try q.toString(al, 16);
	2548	const qs = try q.toString(testing.allocator, 16);
	2549	defer testing.allocator.free(qs);
2344	2550	testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1"));
2345	2551
2346		const rs = try r.toString(al, 16);
	2552	const rs = try r.toString(testing.allocator, 16);
	2553	defer testing.allocator.free(rs);
2347	2554	testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));
2348	2555	}
2349	2556
2350	2557	test "big.int div multi-multi fuzz case #2" {
2351		var a = try Int.init(al);
2352		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();
2353	2562
2354	2563	try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000");
2355	2564	try b.setString(16, "ffc0000000000000000000000000000000000000000000000000");
2356	2565
2357		var q = try Int.init(al);
2358		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();
2359	2570	try Int.divTrunc(&q, &r, a, b);
2360	2571
2361		const qs = try q.toString(al, 16);
	2572	const qs = try q.toString(testing.allocator, 16);
	2573	defer testing.allocator.free(qs);
2362	2574	testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4"));
2363	2575
2364		const rs = try r.toString(al, 16);
	2576	const rs = try r.toString(testing.allocator, 16);
	2577	defer testing.allocator.free(rs);
2365	2578	testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));
2366	2579	}
2367	2580
2368	2581	test "big.int shift-right single" {
2369		var a = try Int.initSet(al, 0xffff0000);
	2582	var a = try Int.initSet(testing.allocator, 0xffff0000);
	2583	defer a.deinit();
2370	2584	try a.shiftRight(a, 16);
2371	2585
2372	2586	testing.expect((try a.to(u32)) == 0xffff);
2373	2587	}
2374	2588
2375	2589	test "big.int shift-right multi" {
2376		var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333);
	2590	var a = try Int.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333);
	2591	defer a.deinit();
2377	2592	try a.shiftRight(a, 67);
2378	2593
2379	2594	testing.expect((try a.to(u64)) == 0x1fffe0001dddc222);
2380	2595	}
2381	2596
2382	2597	test "big.int shift-left single" {
2383		var a = try Int.initSet(al, 0xffff);
	2598	var a = try Int.initSet(testing.allocator, 0xffff);
	2599	defer a.deinit();
2384	2600	try a.shiftLeft(a, 16);
2385	2601
2386	2602	testing.expect((try a.to(u64)) == 0xffff0000);
2387	2603	}
2388	2604
2389	2605	test "big.int shift-left multi" {
2390		var a = try Int.initSet(al, 0x1fffe0001dddc222);
	2606	var a = try Int.initSet(testing.allocator, 0x1fffe0001dddc222);
	2607	defer a.deinit();
2391	2608	try a.shiftLeft(a, 67);
2392	2609
2393	2610	testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
2394	2611	}
2395	2612
2396	2613	test "big.int shift-right negative" {
2397		var a = try Int.init(al);
	2614	var a = try Int.init(testing.allocator);
	2615	defer a.deinit();
2398	2616
2399		try a.shiftRight(try Int.initSet(al, -20), 2);
	2617	try a.shiftRight(try Int.initSet(testing.allocator, -20), 2);
	2618	defer a.deinit();
2400	2619	testing.expect((try a.to(i32)) == -20 >> 2);
2401	2620
2402		try a.shiftRight(try Int.initSet(al, -5), 10);
	2621	try a.shiftRight(try Int.initSet(testing.allocator, -5), 10);
	2622	defer a.deinit();
2403	2623	testing.expect((try a.to(i32)) == -5 >> 10);
2404	2624	}
2405	2625
2406	2626	test "big.int shift-left negative" {
2407		var a = try Int.init(al);
	2627	var a = try Int.init(testing.allocator);
	2628	defer a.deinit();
2408	2629
2409		try a.shiftRight(try Int.initSet(al, -10), 1232);
	2630	try a.shiftRight(try Int.initSet(testing.allocator, -10), 1232);
	2631	defer a.deinit();
2410	2632	testing.expect((try a.to(i32)) == -10 >> 1232);
2411	2633	}
2412	2634
2413	2635	test "big.int bitwise and simple" {
2414		var a = try Int.initSet(al, 0xffffffff11111111);
2415		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();
2416	2640
2417	2641	try a.bitAnd(a, b);
2418	2642
...	...	@@ -2420,8 +2644,10 @@ test "big.int bitwise and simple" {
2420	2644	}
2421	2645
2422	2646	test "big.int bitwise and multi-limb" {
2423		var a = try Int.initSet(al, maxInt(Limb) + 1);
2424		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();
2425	2651
2426	2652	try a.bitAnd(a, b);
2427	2653
...	...	@@ -2429,8 +2655,10 @@ test "big.int bitwise and multi-limb" {
2429	2655	}
2430	2656
2431	2657	test "big.int bitwise xor simple" {
2432		var a = try Int.initSet(al, 0xffffffff11111111);
2433		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();
2434	2662
2435	2663	try a.bitXor(a, b);
2436	2664
...	...	@@ -2438,8 +2666,10 @@ test "big.int bitwise xor simple" {
2438	2666	}
2439	2667
2440	2668	test "big.int bitwise xor multi-limb" {
2441		var a = try Int.initSet(al, maxInt(Limb) + 1);
2442		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();
2443	2673
2444	2674	try a.bitXor(a, b);
2445	2675
...	...	@@ -2447,8 +2677,10 @@ test "big.int bitwise xor multi-limb" {
2447	2677	}
2448	2678
2449	2679	test "big.int bitwise or simple" {
2450		var a = try Int.initSet(al, 0xffffffff11111111);
2451		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();
2452	2684
2453	2685	try a.bitOr(a, b);
2454	2686
...	...	@@ -2456,8 +2688,10 @@ test "big.int bitwise or simple" {
2456	2688	}
2457	2689
2458	2690	test "big.int bitwise or multi-limb" {
2459		var a = try Int.initSet(al, maxInt(Limb) + 1);
2460		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();
2461	2695
2462	2696	try a.bitOr(a, b);
2463	2697
...	...	@@ -2466,11 +2700,19 @@ test "big.int bitwise or multi-limb" {
2466	2700	}
2467	2701
2468	2702	test "big.int var args" {
2469		var a = try Int.initSet(al, 5);
	2703	var a = try Int.initSet(testing.allocator, 5);
	2704	defer a.deinit();
2470	2705
2471		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);
2472	2709	testing.expect((try a.to(u64)) == 11);
2473	2710
2474		testing.expect(a.cmp(try Int.initSet(al, 11)) == 0);
2475		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);
2476	2718	}