test: use ConcreteHeap contracts

Author: MathisGD

foundry.toml

@@ -0,0 +1,3 @@
+[invariant]
+runs = 256
+depth = 256

test-foundry/TestInvariantHeapOrdering.t.sol

@@ -5,41 +5,18 @@ import "ds-test/test.sol";
 import "forge-std/Vm.sol";
 import "forge-std/console.sol";
 
-import "@contracts/HeapOrdering.sol";
+import "./helpers/ConcreteHeapOrdering.sol";
 
-contract Heap {
+contract Heap is ConcreteHeapOrdering {
     using HeapOrdering for HeapOrdering.HeapArray;
 
     uint256 public MAX_SORTED_USERS = 16;
-    HeapOrdering.HeapArray public heap;
 
     /// Functions to fuzz ///
 
     function update(address _id, uint96 _newValue) public {
         heap.update(_id, heap.getValueOf(_id), _newValue, MAX_SORTED_USERS);
     }
-
-    /// Helpers ///
-
-    function length() public view returns (uint256) {
-        return heap.length();
-    }
-
-    function size() public view returns (uint256) {
-        return heap.size;
-    }
-
-    function accountValue(uint256 i) public view returns (uint256) {
-        return heap.accounts[i].value;
-    }
-
-    function accountId(uint256 i) public view returns (address) {
-        return heap.accounts[i].id;
-    }
-
-    function indexOf(address id) public view returns (uint256) {
-        return heap.indexOf[id];
-    }
 }
 
 contract TestHeapInvariant is DSTest {
@@ -49,18 +26,32 @@ contract TestHeapInvariant is DSTest {
         heap = new Heap();
     }
 
+    struct FuzzSelector {
+        address addr;
+        bytes4[] selectors;
+    }
+
+    // Target specific selectors for invariant testing
+    function targetSelectors() public view returns (FuzzSelector[] memory) {
+        FuzzSelector[] memory targets = new FuzzSelector[](1);
+        bytes4[] memory selectors = new bytes4[](1);
+        selectors[0] = Heap.update.selector;
+        targets[0] = FuzzSelector(address(heap), selectors);
+        return targets;
+    }
+
     // Rule:
     // For all i in [[0, size]],
     // value[i] >= value[2i + 1] and value[i] >= value[2i + 2]
     function invariantHeap() public {
         uint256 length = heap.length();
 
-        for (uint256 i = 1; i < length; ++i) {
+        for (uint256 i; i < length; ++i) {
             assertTrue(
-                (i * 2 + 1 >= length || i * 2 + 1 >= heap.size() || heap.accountValue(i) >= heap.accountValue(i * 2 + 1))
+                (i * 2 + 1 >= length || i * 2 + 1 >= heap.size() || heap.accountsValue(i) >= heap.accountsValue(i * 2 + 1))
             ); // prettier-ignore
             assertTrue(
-                (i * 2 + 2 >= length || i * 2 + 2 >= heap.size() || heap.accountValue(i) >= heap.accountValue(i * 2 + 2))
+                (i * 2 + 2 >= length || i * 2 + 2 >= heap.size() || heap.accountsValue(i) >= heap.accountsValue(i * 2 + 2))
             ); // prettier-ignore
         }
     }
@@ -70,8 +61,8 @@ contract TestHeapInvariant is DSTest {
     function invariantIndexOf() public {
         uint256 length = heap.length();
 
-        for (uint256 i = 1; i < length; ++i) {
-            assertTrue(heap.indexOf(heap.accountId(i)) == i);
+        for (uint256 i; i < length; ++i) {
+            assertTrue(heap.indexes(heap.accountsId(i)) == i);
         }
     }
 

test-foundry/helpers/ConcreteHeapOrdering.sol

@@ -13,6 +13,10 @@ contract ConcreteHeapOrdering is ICommonHeapOrdering {
         return heap.accounts[_index].value;
     }
 
+    function accountsId(uint256 _index) external view returns (address) {
+        return heap.accounts[_index].id;
+    }
+
     function indexes(address _id) external view returns (uint256) {
         return heap.indexOf[_id];
     }

test-foundry/helpers/ConcreteThreeHeapOrdering.sol

@@ -13,6 +13,10 @@ contract ConcreteThreeHeapOrdering is ICommonHeapOrdering {
         return heap.accounts[_index].value;
     }
 
+    function accountsId(uint256 _index) external view returns (address) {
+        return heap.accounts[_index].id;
+    }
+
     function indexes(address _id) external view returns (uint256) {
         return heap.indexes[_id];
     }

test-foundry/helpers/ICommonHeapOrdering.sol

@@ -11,6 +11,8 @@ interface ICommonHeapOrdering {
 
     function accountsValue(uint256 _index) external view returns (uint256);
 
+    function accountsId(uint256 _index) external view returns (address);
+
     function indexes(address _id) external view returns (uint256);
 
     function length() external view returns (uint256);