Add discard functionality for conditional tests

example/contracts/slice.tests.clar

@@ -5,10 +5,8 @@
 
 (define-public (test-slice-list-int (seq (list 127 int)) (skip int) (n int))
   (if
-    ;; Early return if the input is invalid.
-    (or
-      (not (and (<= 0 n) (<= n 127)))
-      (not (and (<= 0 skip) (<= skip 127))))
+    ;; Early return if the preliminary function returns false.
+    (not (can-test-slice-list-int seq skip n))
     (ok true)
     (let (
         (result (contract-call? .slice slice seq skip n))
@@ -32,6 +30,28 @@
           (asserts! (is-eq (len result) (to-uint n)) ERR_ASSERTION_FAILED_3)))
       (ok true))))
 
+;; If a property test is conditional (https://www.cse.chalmers.se/~rjmh/
+;; QuickCheck/manual_body.html#6), it requires a preliminary function to check
+;; the input validity before running the test.
+;; 
+;; The preliminary function must follow these rules:
+;; - It must have read-only access.
+;; - Its name should match the property test function's name, prefixed with
+;;   "can-".
+;; - Its parameters should mirror those of the property test function.
+;; - It must return a boolean indicating whether the inputs are valid.
+;; 
+;; Rendezvous will first call the preliminary function; if it returns false, a
+;; warning will be logged. In the future, with config file support, users will
+;; be able to customize generated argument values based on the preliminary
+;; function's result.
+(define-read-only (can-test-slice-list-int (seq (list 127 int))
+                                                   (skip int)
+                                                   (n int))
+  (and
+    (and (<= 0 n) (<= n 127))
+    (and (<= 0 skip) (<= skip 127))))
+
 (define-public (test-slice-list-uint (seq (list 127 uint)) (skip int) (n int))
   (if
     ;; Early return if the input is invalid.

property.ts

@@ -59,6 +59,38 @@ export const checkProperties = (
     `\nStarting property testing type for the ${sutContractName} contract...`
   );
 
+  // Search for preliminary functions, for each test function. This map will
+  // be used to pair the test functions with their corresponding preliminary
+  // functions.
+  const testContractsPreliminaryFunctions = new Map(
+    Array.from(testContractsAllFunctions, ([contractId, functions]) => [
+      contractId,
+      functions.filter(
+        (f) => f.access === "read_only" && f.name.startsWith("can-")
+      ),
+    ])
+  );
+
+  // Pair each test function with its corresponding preliminary function. When
+  // a test function is selected, Rendezvous will first call its preliminary
+  // function, if available, to validate that the generated test arguments are
+  // meaningful. This way, we are reducing the risk of false positives in test
+  // results.
+  const testContractsPairedFunctions = new Map(
+    Array.from(testContractsTestFunctions, ([contractId, functions]) => [
+      contractId,
+      new Map(
+        functions.map((f) => {
+          const preliminaryFunction = testContractsPreliminaryFunctions
+            .get(contractId)
+            ?.find((pf) => pf.name === `can-${f.name}`);
+
+          return [f.name, preliminaryFunction?.name];
+        })
+      ),
+    ])
+  );
+
   const radioReporter = (runDetails: any) => {
     reporter(runDetails, radio, "test");
   };