authorgravatar for git@mtlynch.ioMichael Lynch <git@mtlynch.io> 2024-03-30 16:53:15-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-04-02 13:46:51-07:00
log2a7cedfeb99fb1c230af6ceab75f9137920a3639
treecd02e44bb615a65e46b75bdd3005c68d0df27030
parent5835e5ec9a53dd6fc6d26e3195e4b1e408bee641

Refactor ArrayList replaceRange tests

1 files changed, 186 insertions(+), 82 deletions(-)

lib/std/array_list.zig+186-82
......@@ -1651,115 +1651,219 @@ test "insertSlice" {
16511651 }
16521652}
16531653
1654test "replaceRange" {
1655 var arena = std.heap.ArenaAllocator.init(testing.allocator);
1656 defer arena.deinit();
1657 const a = arena.allocator();
1654test "ArrayList.replaceRange" {
1655 const a = testing.allocator;
1656
1657 {
1658 var list = ArrayList(i32).init(a);
1659 defer list.deinit();
1660 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1661
1662 try list.replaceRange(1, 0, &[_]i32{ 0, 0, 0 });
1663
1664 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
1665 }
1666 {
1667 var list = ArrayList(i32).init(a);
1668 defer list.deinit();
1669 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1670
1671 try list.replaceRange(1, 1, &[_]i32{ 0, 0, 0 });
1672
1673 try testing.expectEqualSlices(
1674 i32,
1675 &[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
1676 list.items,
1677 );
1678 }
1679 {
1680 var list = ArrayList(i32).init(a);
1681 defer list.deinit();
1682 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1683
1684 try list.replaceRange(1, 2, &[_]i32{ 0, 0, 0 });
1685
1686 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
1687 }
1688 {
1689 var list = ArrayList(i32).init(a);
1690 defer list.deinit();
1691 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1692
1693 try list.replaceRange(1, 3, &[_]i32{ 0, 0, 0 });
1694
1695 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
1696 }
1697 {
1698 var list = ArrayList(i32).init(a);
1699 defer list.deinit();
1700 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1701
1702 try list.replaceRange(1, 4, &[_]i32{ 0, 0, 0 });
1703
1704 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
1705 }
1706}
1707
1708test "ArrayList.replaceRangeAssumeCapacity" {
1709 const a = testing.allocator;
1710
1711 {
1712 var list = ArrayList(i32).init(a);
1713 defer list.deinit();
1714 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1715
1716 list.replaceRangeAssumeCapacity(1, 0, &[_]i32{ 0, 0, 0 });
1717
1718 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
1719 }
1720 {
1721 var list = ArrayList(i32).init(a);
1722 defer list.deinit();
1723 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1724
1725 list.replaceRangeAssumeCapacity(1, 1, &[_]i32{ 0, 0, 0 });
1726
1727 try testing.expectEqualSlices(
1728 i32,
1729 &[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
1730 list.items,
1731 );
1732 }
1733 {
1734 var list = ArrayList(i32).init(a);
1735 defer list.deinit();
1736 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1737
1738 list.replaceRangeAssumeCapacity(1, 2, &[_]i32{ 0, 0, 0 });
1739
1740 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
1741 }
1742 {
1743 var list = ArrayList(i32).init(a);
1744 defer list.deinit();
1745 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
1746
1747 list.replaceRangeAssumeCapacity(1, 3, &[_]i32{ 0, 0, 0 });
1748
1749 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
1750 }
1751 {
1752 var list = ArrayList(i32).init(a);
1753 defer list.deinit();
1754 try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
16581755
1659 const init = [_]i32{ 1, 2, 3, 4, 5 };
1660 const new = [_]i32{ 0, 0, 0 };
1756 list.replaceRangeAssumeCapacity(1, 4, &[_]i32{ 0, 0, 0 });
16611757
1662 const result_zero = [_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 };
1663 const result_eq = [_]i32{ 1, 0, 0, 0, 5 };
1664 const result_le = [_]i32{ 1, 0, 0, 0, 4, 5 };
1665 const result_gt = [_]i32{ 1, 0, 0, 0 };
1758 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
1759 }
1760}
1761
1762test "ArrayListUnmanaged.replaceRange" {
1763 const a = testing.allocator;
16661764
16671765 {
1668 var list_zero = ArrayList(i32).init(a);
1669 var list_eq = ArrayList(i32).init(a);
1670 var list_lt = ArrayList(i32).init(a);
1671 var list_gt = ArrayList(i32).init(a);
1766 var list = ArrayListUnmanaged(i32){};
1767 defer list.deinit(a);
1768 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
16721769
1673 try list_zero.appendSlice(&init);
1674 try list_eq.appendSlice(&init);
1675 try list_lt.appendSlice(&init);
1676 try list_gt.appendSlice(&init);
1770 try list.replaceRange(a, 1, 0, &[_]i32{ 0, 0, 0 });
16771771
1678 try list_zero.replaceRange(1, 0, &new);
1679 try list_eq.replaceRange(1, 3, &new);
1680 try list_lt.replaceRange(1, 2, &new);
1772 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
1773 }
1774 {
1775 var list = ArrayListUnmanaged(i32){};
1776 defer list.deinit(a);
1777 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
16811778
1682 // after_range > new_items.len in function body
1683 try testing.expect(1 + 4 > new.len);
1684 try list_gt.replaceRange(1, 4, &new);
1779 try list.replaceRange(a, 1, 1, &[_]i32{ 0, 0, 0 });
16851780
1686 try testing.expectEqualSlices(i32, list_zero.items, &result_zero);
1687 try testing.expectEqualSlices(i32, list_eq.items, &result_eq);
1688 try testing.expectEqualSlices(i32, list_lt.items, &result_le);
1689 try testing.expectEqualSlices(i32, list_gt.items, &result_gt);
1781 try testing.expectEqualSlices(
1782 i32,
1783 &[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
1784 list.items,
1785 );
16901786 }
16911787 {
1692 var list_zero = ArrayListUnmanaged(i32){};
1693 var list_eq = ArrayListUnmanaged(i32){};
1694 var list_lt = ArrayListUnmanaged(i32){};
1695 var list_gt = ArrayListUnmanaged(i32){};
1788 var list = ArrayListUnmanaged(i32){};
1789 defer list.deinit(a);
1790 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
16961791
1697 try list_zero.appendSlice(a, &init);
1698 try list_eq.appendSlice(a, &init);
1699 try list_lt.appendSlice(a, &init);
1700 try list_gt.appendSlice(a, &init);
1792 try list.replaceRange(a, 1, 2, &[_]i32{ 0, 0, 0 });
17011793
1702 try list_zero.replaceRange(a, 1, 0, &new);
1703 try list_eq.replaceRange(a, 1, 3, &new);
1704 try list_lt.replaceRange(a, 1, 2, &new);
1794 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
1795 }
1796 {
1797 var list = ArrayListUnmanaged(i32){};
1798 defer list.deinit(a);
1799 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
17051800
1706 // after_range > new_items.len in function body
1707 try testing.expect(1 + 4 > new.len);
1708 try list_gt.replaceRange(a, 1, 4, &new);
1801 try list.replaceRange(a, 1, 3, &[_]i32{ 0, 0, 0 });
17091802
1710 try testing.expectEqualSlices(i32, list_zero.items, &result_zero);
1711 try testing.expectEqualSlices(i32, list_eq.items, &result_eq);
1712 try testing.expectEqualSlices(i32, list_lt.items, &result_le);
1713 try testing.expectEqualSlices(i32, list_gt.items, &result_gt);
1803 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
17141804 }
1805 {
1806 var list = ArrayListUnmanaged(i32){};
1807 defer list.deinit(a);
1808 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
1809
1810 try list.replaceRange(a, 1, 4, &[_]i32{ 0, 0, 0 });
1811
1812 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
1813 }
1814}
1815
1816test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
1817 const a = testing.allocator;
1818
1819 {
1820 var list = ArrayListUnmanaged(i32){};
1821 defer list.deinit(a);
1822 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
1823
1824 list.replaceRangeAssumeCapacity(1, 0, &[_]i32{ 0, 0, 0 });
17151825
1826 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
1827 }
17161828 {
1717 var list_zero = ArrayList(i32).init(a);
1718 var list_eq = ArrayList(i32).init(a);
1719 var list_lt = ArrayList(i32).init(a);
1720 var list_gt = ArrayList(i32).init(a);
1829 var list = ArrayListUnmanaged(i32){};
1830 defer list.deinit(a);
1831 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
17211832
1722 try list_zero.appendSlice(&init);
1723 try list_eq.appendSlice(&init);
1724 try list_lt.appendSlice(&init);
1725 try list_gt.appendSlice(&init);
1833 list.replaceRangeAssumeCapacity(1, 1, &[_]i32{ 0, 0, 0 });
17261834
1727 list_zero.replaceRangeAssumeCapacity(1, 0, &new);
1728 list_eq.replaceRangeAssumeCapacity(1, 3, &new);
1729 list_lt.replaceRangeAssumeCapacity(1, 2, &new);
1835 try testing.expectEqualSlices(
1836 i32,
1837 &[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
1838 list.items,
1839 );
1840 }
1841 {
1842 var list = ArrayListUnmanaged(i32){};
1843 defer list.deinit(a);
1844 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
17301845
1731 // after_range > new_items.len in function body
1732 try testing.expect(1 + 4 > new.len);
1733 list_gt.replaceRangeAssumeCapacity(1, 4, &new);
1846 list.replaceRangeAssumeCapacity(1, 2, &[_]i32{ 0, 0, 0 });
17341847
1735 try testing.expectEqualSlices(i32, list_zero.items, &result_zero);
1736 try testing.expectEqualSlices(i32, list_eq.items, &result_eq);
1737 try testing.expectEqualSlices(i32, list_lt.items, &result_le);
1738 try testing.expectEqualSlices(i32, list_gt.items, &result_gt);
1848 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
17391849 }
17401850 {
1741 var list_zero = ArrayListUnmanaged(i32){};
1742 var list_eq = ArrayListUnmanaged(i32){};
1743 var list_lt = ArrayListUnmanaged(i32){};
1744 var list_gt = ArrayListUnmanaged(i32){};
1851 var list = ArrayListUnmanaged(i32){};
1852 defer list.deinit(a);
1853 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
17451854
1746 try list_zero.appendSlice(a, &init);
1747 try list_eq.appendSlice(a, &init);
1748 try list_lt.appendSlice(a, &init);
1749 try list_gt.appendSlice(a, &init);
1855 list.replaceRangeAssumeCapacity(1, 3, &[_]i32{ 0, 0, 0 });
17501856
1751 list_zero.replaceRangeAssumeCapacity(1, 0, &new);
1752 list_eq.replaceRangeAssumeCapacity(1, 3, &new);
1753 list_lt.replaceRangeAssumeCapacity(1, 2, &new);
1857 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
1858 }
1859 {
1860 var list = ArrayListUnmanaged(i32){};
1861 defer list.deinit(a);
1862 try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
17541863
1755 // after_range > new_items.len in function body
1756 try testing.expect(1 + 4 > new.len);
1757 list_gt.replaceRangeAssumeCapacity(1, 4, &new);
1864 list.replaceRangeAssumeCapacity(1, 4, &[_]i32{ 0, 0, 0 });
17581865
1759 try testing.expectEqualSlices(i32, list_zero.items, &result_zero);
1760 try testing.expectEqualSlices(i32, list_eq.items, &result_eq);
1761 try testing.expectEqualSlices(i32, list_lt.items, &result_le);
1762 try testing.expectEqualSlices(i32, list_gt.items, &result_gt);
1866 try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
17631867 }
17641868}
17651869