more parametrization for suspended yang test

Author: tserg

src/tests/purger/test_purger.cairo

@@ -3884,23 +3884,12 @@ mod test_purger {
     }
 
     fn test_liquidate_suspended_yang_threshold_near_zero(
-        starting_ltv: Ray, liquidate_via_absorption: bool, is_recovery_mode: bool
+        starting_ltv: Ray, liquidate_via_absorption: bool, is_recovery_mode: bool, desired_threshold: Ray
     ) {
         let (shrine, abbot, seer, absorber, purger, yangs, gates) = purger_utils::purger_deploy_with_searcher(
             purger_utils::SEARCHER_YIN.into(), Option::None
         );
 
-        // We also parametrize the test with the desired threshold for liquidation
-        let mut desired_threshold_params: Span<Ray> = array![
-            RAY_PERCENT.into(),
-            (RAY_PERCENT / 4).into(),
-            // This is the smallest possible desired threshold that
-            // doesn't result in advancing the time enough to make
-            // the suspension permanent
-            (RAY_ONE + 1).into() / (RAY_ONE * shrine_contract::SUSPENSION_GRACE_PERIOD.into()).into(),
-        ]
-            .span();
-
         let eth: ContractAddress = *yangs[0];
         let eth_gate: IGateDispatcher = *gates[0];
         let eth_amt: u128 = WAD_ONE;
@@ -3925,149 +3914,266 @@ mod test_purger {
         // the lowered threshold from suspension
         purger_utils::create_whale_trove(abbot, yangs, gates);
 
-        loop {
-            match desired_threshold_params.pop_front() {
-                Option::Some(desired_threshold) => {
-                    let (eth_price, _, _) = shrine.get_current_yang_price(eth);
-                    let forge_amt: Wad = wadray::rmul_wr(eth_amt.into() * eth_price, starting_ltv);
-                    let target_trove: u64 = common::open_trove_helper(
-                        abbot,
-                        target_user,
-                        array![eth].span(),
-                        array![eth_amt].span(),
-                        array![eth_gate].span(),
-                        forge_amt
-                    );
+        let (eth_price, _, _) = shrine.get_current_yang_price(eth);
+        let forge_amt: Wad = wadray::rmul_wr(eth_amt.into() * eth_price, starting_ltv);
+        let target_trove: u64 = common::open_trove_helper(
+            abbot, target_user, array![eth].span(), array![eth_amt].span(), array![eth_gate].span(), forge_amt
+        );
 
-                    // Suspend ETH
-                    start_prank(CheatTarget::One(shrine.contract_address), shrine_utils::admin());
-                    shrine.suspend_yang(eth);
-                    stop_prank(CheatTarget::One(shrine.contract_address));
+        // Suspend ETH
+        start_prank(CheatTarget::One(shrine.contract_address), shrine_utils::admin());
+        shrine.suspend_yang(eth);
+        stop_prank(CheatTarget::One(shrine.contract_address));
 
-                    // Advance the time stamp such that the ETH threshold falls to `desired_threshold`
-                    let decrease_factor: Ray = *desired_threshold / eth_threshold;
-                    let ts_diff: u64 = shrine_contract::SUSPENSION_GRACE_PERIOD
-                        - scale_u128_by_ray(shrine_contract::SUSPENSION_GRACE_PERIOD.into(), decrease_factor)
-                            .try_into()
-                            .unwrap();
+        // Advance the time stamp such that the ETH threshold falls to `desired_threshold`
+        let decrease_factor: Ray = desired_threshold / eth_threshold;
+        let ts_diff: u64 = shrine_contract::SUSPENSION_GRACE_PERIOD
+            - scale_u128_by_ray(shrine_contract::SUSPENSION_GRACE_PERIOD.into(), decrease_factor).try_into().unwrap();
 
-                    shrine_utils::advance_prices_periodically(shrine, yangs, ts_diff);
+        shrine_utils::advance_prices_periodically(shrine, yangs, ts_diff);
 
-                    // Check that the threshold has decreased to the desired value
-                    // The trove's threshold is equivalent to ETH's threshold since it 
-                    // has deposited only ETH.
-                    let threshold_before_liquidation = shrine.get_trove_health(target_trove).threshold;
+        // Check that the threshold has decreased to the desired value
+        // The trove's threshold is equivalent to ETH's threshold since it 
+        // has deposited only ETH.
+        let threshold_before_liquidation = shrine.get_trove_health(target_trove).threshold;
+
+        common::assert_equalish(
+            threshold_before_liquidation,
+            desired_threshold, // 0.0000001 = 10^-7 (ray). Precision
+            // is limited by the precision of timestamps,
+            // which is only in seconds
+            100000000000000000000_u128.into(),
+            'wrong eth threshold'
+        );
+
+        // We want to compare the yin balance of the liquidator
+        // before and after the liquidation. In the case of absorption
+        // we check the absorber's balance, and in the case of
+        // searcher liquidation we check the searcher's balance.
+        let before_liquidation_yin_balance: u256 = if liquidate_via_absorption {
+            yin_erc20.balance_of(absorber.contract_address)
+        } else {
+            yin_erc20.balance_of(searcher)
+        };
 
-                    common::assert_equalish(
-                        threshold_before_liquidation,
-                        *desired_threshold,
-                        // 0.0000001 = 10^-7 (ray). Precision
-                        // is limited by the precision of timestamps,
-                        // which is only in seconds
-                        100000000000000000000_u128.into(),
-                        'wrong eth threshold'
-                    );
+        let in_recovery_mode: bool = shrine.is_recovery_mode();
+        if is_recovery_mode {
+            if !in_recovery_mode {
+                purger_utils::trigger_recovery_mode(shrine, seer, yangs, common::RecoveryModeSetupType::ExceedsBuffer);
+            }
+        } else {
+            assert(!in_recovery_mode, 'in recovery mode');
+        }
 
-                    // We want to compare the yin balance of the liquidator
-                    // before and after the liquidation. In the case of absorption
-                    // we check the absorber's balance, and in the case of
-                    // searcher liquidation we check the searcher's balance.
-                    let before_liquidation_yin_balance: u256 = if liquidate_via_absorption {
-                        yin_erc20.balance_of(absorber.contract_address)
-                    } else {
-                        yin_erc20.balance_of(searcher)
-                    };
+        // Liquidate the trove
+        start_prank(CheatTarget::One(purger.contract_address), searcher);
 
-                    let in_recovery_mode: bool = shrine.is_recovery_mode();
-                    if is_recovery_mode {
-                        if !in_recovery_mode {
-                            purger_utils::trigger_recovery_mode(
-                                shrine, seer, yangs, common::RecoveryModeSetupType::ExceedsBuffer
-                            );
-                        }
-                    } else {
-                        assert(!in_recovery_mode, 'in recovery mode');
-                    }
+        if liquidate_via_absorption {
+            purger.absorb(target_trove);
+        } else {
+            // Get the updated debt with accrued interest
+            let before_liquidation_health: Health = shrine.get_trove_health(target_trove);
+            purger.liquidate(target_trove, before_liquidation_health.debt, searcher);
+        }
 
-                    // Liquidate the trove
-                    start_prank(CheatTarget::One(purger.contract_address), searcher);
+        // Sanity checks
+        let target_trove_after_health: Health = shrine.get_trove_health(target_trove);
 
-                    if liquidate_via_absorption {
-                        purger.absorb(target_trove);
-                    } else {
-                        // Get the updated debt with accrued interest
-                        let before_liquidation_health: Health = shrine.get_trove_health(target_trove);
-                        purger.liquidate(target_trove, before_liquidation_health.debt, searcher);
-                    }
+        assert(target_trove_after_health.debt < forge_amt, 'trove not correctly liquidated');
 
-                    // Sanity checks
-                    let target_trove_after_health: Health = shrine.get_trove_health(target_trove);
+        // Checking that the liquidator's yin balance has decreased
+        // after liquidation
+        if liquidate_via_absorption {
+            assert(
+                yin_erc20.balance_of(absorber.contract_address) < before_liquidation_yin_balance,
+                'absorber yin not used'
+            );
+        } else {
+            assert(yin_erc20.balance_of(searcher) < before_liquidation_yin_balance, 'searcher yin not used');
+        }
+    }
 
-                    assert(target_trove_after_health.debt < forge_amt, 'trove not correctly liquidated');
+    fn suspended_yang_desired_thresholds() -> Span<Ray> {
+        array![
+            RAY_PERCENT.into(),
+            (RAY_PERCENT / 4).into(),
+            // This is the smallest possible desired threshold that
+            // doesn't result in advancing the time enough to make
+            // the suspension permanent
+            (RAY_ONE + 1).into() / (RAY_ONE * shrine_contract::SUSPENSION_GRACE_PERIOD.into()).into(),
+        ]
+            .span()
+    }
 
-                    // Checking that the liquidator's yin balance has decreased
-                    // after liquidation
-                    if liquidate_via_absorption {
-                        assert(
-                            yin_erc20.balance_of(absorber.contract_address) < before_liquidation_yin_balance,
-                            'absorber yin not used'
-                        );
-                    } else {
-                        assert(
-                            yin_erc20.balance_of(searcher) < before_liquidation_yin_balance, 'searcher yin not used'
-                        );
-                    }
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized1a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, true, desired_threshold);
+    }
 
-                    start_prank(CheatTarget::One(shrine.contract_address), shrine_utils::admin());
-                    shrine.unsuspend_yang(eth);
-                    stop_prank(CheatTarget::One(shrine.contract_address));
-                },
-                Option::None => { break; }
-            }
-        };
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized1b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, true, desired_threshold);
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized1() {
-        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, true);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized1c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, true, desired_threshold);
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized2() {
-        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, true);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized2a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, true, desired_threshold);
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized3() {
-        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, false);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized2b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, true, desired_threshold);
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized4() {
-        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, false);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized2c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, true, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized3a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, false, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized3b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, false, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized3c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), true, false, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized4a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, false, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized4b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, false, desired_threshold);
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized4c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero((50 * RAY_PERCENT).into(), false, false, desired_threshold);
     }
 
     // The minimum LTV for absorption at 1% threshold is approximately 1.097%, so it is rounded
     // up to 1.1% for convenience to ensure the target trove is absorbable after adjusting the 
     // threshold to the desired value.
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized5() {
-        test_liquidate_suspended_yang_threshold_near_zero((RAY_PERCENT + RAY_PERCENT / 10).into(), true, true);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized5a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, true, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized5b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, true, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized5c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, true, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized6a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, true, desired_threshold
+        );
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized6() {
-        test_liquidate_suspended_yang_threshold_near_zero((RAY_PERCENT + RAY_PERCENT / 10).into(), false, true);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized6b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, true, desired_threshold
+        );
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized7() {
-        test_liquidate_suspended_yang_threshold_near_zero((RAY_PERCENT + RAY_PERCENT / 10).into(), true, false);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized6c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, true, desired_threshold
+        );
     }
 
     #[test]
-    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized8() {
-        test_liquidate_suspended_yang_threshold_near_zero((RAY_PERCENT + RAY_PERCENT / 10).into(), false, false);
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized7a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, false, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized7b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, false, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized7c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), true, false, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized8a() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(0);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, false, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized8b() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(1);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, false, desired_threshold
+        );
+    }
+
+    #[test]
+    fn test_liquidate_suspended_yang_threshold_near_zero_parametrized8c() {
+        let desired_threshold = *suspended_yang_desired_thresholds().at(2);
+        test_liquidate_suspended_yang_threshold_near_zero(
+            (RAY_PERCENT + RAY_PERCENT / 10).into(), false, false, desired_threshold
+        );
     }
 
     #[derive(Copy, Drop, PartialEq)]