@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/treasury/test_lz_token_fee_lib.cairo

@@ -0,0 +1,63 @@
+//! LayerZero token fee library tests
+
+use layerzero::treasury::interfaces::lz_token_fee_lib::{
+    ILzTokenFeeLibDispatcher, ILzTokenFeeLibDispatcherTrait,
+};
+use starknet::ContractAddress;
+use crate::fuzzable::contract_address::{FuzzableContractAddress, FuzzableContractAddresses};
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+use crate::mocks::treasury::lz_token_fee_lib::{
+    IMockLzTokenFeeLibAssertionDispatcher, IMockLzTokenFeeLibAssertionDispatcherTrait,
+};
+use crate::treasury::utils::deploy_mock_lz_token_fee_lib;
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_mock_constructor(fee: u256) {
+    deploy_mock_lz_token_fee_lib(fee);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_mock_get_fee(
+    owner: ContractAddress,
+    configured_fee: u256,
+    sender: ContractAddress,
+    dst_eid: Eid,
+    worker_fee: u256,
+    native_treasury_fee: u256,
+) {
+    let library = deploy_mock_lz_token_fee_lib(configured_fee);
+    let dispatcher = ILzTokenFeeLibDispatcher { contract_address: library };
+
+    let fee = dispatcher.get_fee(sender, dst_eid.eid, worker_fee, native_treasury_fee);
+
+    assert(fee == configured_fee, 'Unexpected fee');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_mock_pay_fee(
+    owner: ContractAddress,
+    configured_fee: u256,
+    sender: ContractAddress,
+    dst_eid: Eid,
+    worker_fee: u256,
+    native_treasury_fee: u256,
+) {
+    let library = deploy_mock_lz_token_fee_lib(configured_fee);
+    let dispatcher = ILzTokenFeeLibDispatcher { contract_address: library };
+    let assertion = IMockLzTokenFeeLibAssertionDispatcher { contract_address: library };
+
+    assertion.assert_payment_count(0);
+
+    let fee = dispatcher.pay_fee(sender, dst_eid.eid, worker_fee, native_treasury_fee);
+
+    assert(fee == configured_fee, 'Unexpected fee');
+    assertion.assert_payment_count(1);
+
+    let fee = dispatcher.pay_fee(sender, dst_eid.eid, worker_fee, native_treasury_fee);
+
+    assert(fee == configured_fee, 'Unexpected fee');
+    assertion.assert_payment_count(2);
+}

package/layerzero/tests/treasury/test_treasury.cairo

@@ -0,0 +1,458 @@
+//! Treasury tests
+
+use layerzero::common::constants::DEFAULT_BPS;
+use layerzero::treasury::errors::err_lz_token_not_enabled;
+use layerzero::treasury::events::BasisPointsUpdated;
+use layerzero::treasury::interfaces::layerzero_treasury::{
+    ILayerZeroTreasurySafeDispatcher, ILayerZeroTreasurySafeDispatcherTrait,
+};
+use layerzero::treasury::interfaces::treasury_admin::{
+    ITreasuryAdminSafeDispatcher, ITreasuryAdminSafeDispatcherTrait,
+};
+use layerzero::treasury::treasury::Treasury;
+use openzeppelin::access::ownable::interface::{IOwnableSafeDispatcher, IOwnableSafeDispatcherTrait};
+use openzeppelin::token::erc20::ERC20Component::{Event as ERC20Event, Transfer};
+use openzeppelin::token::erc20::interface::{IERC20SafeDispatcher, IERC20SafeDispatcherTrait};
+use snforge_std::{
+    ContractClassTrait, DeclareResultTrait, EventSpyAssertionsTrait, declare, spy_events,
+    start_cheat_caller_address, stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::{
+    assert_panic_with_error, assert_panic_with_felt_error, cheat_caller_address_once,
+};
+use crate::fuzzable::contract_address::{FuzzableContractAddress, FuzzableContractAddresses};
+use crate::mocks::treasury::lz_token_fee_lib::{
+    IMockLzTokenFeeLibAssertionDispatcher, IMockLzTokenFeeLibAssertionDispatcherTrait,
+};
+use crate::treasury::utils::deploy_mock_lz_token_fee_lib;
+
+// Test constants
+const OWNER: ContractAddress = 'owner'.try_into().unwrap();
+const USER: ContractAddress = 'user'.try_into().unwrap();
+const RECIPIENT: ContractAddress = 'recipient'.try_into().unwrap();
+const ZERO_ADDRESS: ContractAddress = 0.try_into().unwrap();
+
+// Test values
+const INITIAL_TOKEN_SUPPLY: u256 = 1000000_u256; // 1M tokens
+const TEST_BASIS_POINTS: u256 = 500_u256; // 5%
+const TEST_WORKER_FEE: u256 = 10000_u256;
+const TEST_DST_EID: u32 = 102;
+const TEST_EXPECTED_FEE: u32 = 500;
+
+fn deploy_mock_erc20(initial_supply: u256, recipient: ContractAddress) -> ContractAddress {
+    let contract = declare("MockERC20").unwrap().contract_class();
+    // this sis done because u256 does not fit into felt252
+    let (address, _) = contract
+        .deploy(@array![initial_supply.low.into(), initial_supply.high.into(), recipient.into()])
+        .unwrap();
+    address
+}
+
+fn deploy_treasury(owner: ContractAddress) -> ContractAddress {
+    let contract = declare("Treasury").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![owner.into()]).unwrap();
+    address
+}
+
+fn setup() -> (
+    ContractAddress,
+    ContractAddress,
+    ILayerZeroTreasurySafeDispatcher,
+    ITreasuryAdminSafeDispatcher,
+    IOwnableSafeDispatcher,
+    IERC20SafeDispatcher,
+) {
+    let token_address = deploy_mock_erc20(INITIAL_TOKEN_SUPPLY, USER);
+    let treasury_address = deploy_treasury(OWNER);
+
+    (
+        treasury_address,
+        token_address,
+        ILayerZeroTreasurySafeDispatcher { contract_address: treasury_address },
+        ITreasuryAdminSafeDispatcher { contract_address: treasury_address },
+        IOwnableSafeDispatcher { contract_address: treasury_address },
+        IERC20SafeDispatcher { contract_address: token_address },
+    )
+}
+
+fn setup_with_basis_points(
+    basis_points: u256,
+) -> (
+    ContractAddress,
+    ContractAddress,
+    ILayerZeroTreasurySafeDispatcher,
+    ITreasuryAdminSafeDispatcher,
+    IOwnableSafeDispatcher,
+    IERC20SafeDispatcher,
+) {
+    let (
+        treasury_address,
+        token_address,
+        treasury_dispatcher,
+        admin_dispatcher,
+        ownable_dispatcher,
+        token_dispatcher,
+    ) =
+        setup();
+
+    // Set basis points
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher.set_fee_bp(basis_points).unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    (
+        treasury_address,
+        token_address,
+        treasury_dispatcher,
+        admin_dispatcher,
+        ownable_dispatcher,
+        token_dispatcher,
+    )
+}
+
+#[test]
+fn test_constructor() {
+    let (treasury_address, _, _, _, ownable_dispatcher, _) = setup();
+
+    // Test that owner is set correctly
+    assert(ownable_dispatcher.owner().unwrap() == OWNER, 'Owner should be set correctly');
+
+    // Test that basis points start at 0
+    let admin_dispatcher = ITreasuryAdminSafeDispatcher { contract_address: treasury_address };
+    assert(admin_dispatcher.get_fee_bp().unwrap() == 0, 'Basis points should be 0');
+}
+
+#[test]
+fn test_withdraw_tokens_as_owner() {
+    let CUSTOM_BASIS_POINTS = 200;
+
+    let (treasury_address, _, _, admin_dispatcher, _, token_dispatcher) = setup_with_basis_points(
+        CUSTOM_BASIS_POINTS,
+    );
+
+    // First, get some tokens into the treasury by paying a fee
+    // 1999.62 rounded down
+    let expected_treasury_fee = 1_999;
+
+    start_cheat_caller_address(token_dispatcher.contract_address, USER);
+    token_dispatcher.transfer(treasury_address, expected_treasury_fee).unwrap();
+    stop_cheat_caller_address(token_dispatcher.contract_address);
+
+    let mut spy = spy_events();
+    // should be 999.5 => 999
+    let withdraw_amount = expected_treasury_fee / 2;
+
+    // Withdraw tokens as owner
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher
+        .withdraw_tokens(token_dispatcher.contract_address, RECIPIENT, withdraw_amount)
+        .unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    // Verify balances
+    let final_recipient_balance = token_dispatcher.balance_of(RECIPIENT).unwrap();
+    let final_treasury_balance = token_dispatcher.balance_of(treasury_address).unwrap();
+
+    assert(final_recipient_balance == 999, 'Recipient balance incorrect');
+    assert(final_treasury_balance == 1000, 'Treasury balance incorrect');
+
+    let expected_event = ERC20Event::Transfer(
+        Transfer { from: treasury_address, to: RECIPIENT, value: withdraw_amount },
+    );
+    spy.assert_emitted(@array![(token_dispatcher.contract_address, expected_event)]);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_withdraw_tokens_fails_as_non_owner(amount: u256) {
+    let (treasury_address, _, _, admin_dispatcher, _, token_dispatcher) = setup();
+
+    start_cheat_caller_address(treasury_address, USER);
+    let result = admin_dispatcher
+        .withdraw_tokens(token_dispatcher.contract_address, RECIPIENT, amount);
+    stop_cheat_caller_address(treasury_address);
+
+    assert_panic_with_felt_error(result, 'Caller is not the owner');
+}
+
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_withdraw_tokens_fails_with_insufficient_balance(amount: u256) {
+    let (treasury_address, _, _, admin_dispatcher, _, token_dispatcher) = setup();
+
+    start_cheat_caller_address(treasury_address, OWNER);
+    let result = admin_dispatcher
+        .withdraw_tokens(
+            token_dispatcher.contract_address, RECIPIENT, amount + 1,
+        ); // More than treasury has
+    stop_cheat_caller_address(treasury_address);
+
+    assert_panic_with_felt_error(result, 'ERC20: insufficient balance');
+}
+
+// =============================== Native token =================================
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_get_native_fee_with_zero_basis_points(dst_eid: u32, worker_fee: u256) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup();
+
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, worker_fee, false).unwrap();
+    assert(fee == 0, 'Fee should be 0 with 0 bp');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_get_native_fee_with_basis_points(dst_eid: u32, basis_points: u128) {
+    const CUSTOM_WORKER_FEE: u256 = 1000_000_000;
+    let basis_points = basis_points.into();
+
+    let (_, _, treasury_dispatcher, _, _, _) = setup_with_basis_points(basis_points);
+
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, CUSTOM_WORKER_FEE, false).unwrap();
+    assert(fee == 100_000 * basis_points, 'Fee calculation incorrect');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_get_native_fee_edge_cases(dst_eid: u32, worker_fee: u128) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup_with_basis_points(10000); // 100%
+    let worker_fee = worker_fee.into();
+
+    // Test with 100% basis points
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, worker_fee, false).unwrap();
+    assert(fee == worker_fee, '100% fee should equal total');
+
+    // Test with zero total fee
+    let fee_zero = treasury_dispatcher.get_fee(USER, dst_eid, 0, false).unwrap();
+    assert(fee_zero == 0, 'Zero total should give zero fee');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_simple_pay_native_fee(dst_eid: u32, worker_fee: u128) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup_with_basis_points(10000);
+    let worker_fee = worker_fee.into();
+
+    let fee = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, false).unwrap();
+    assert(fee == worker_fee, '100% fee should equal total');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_native_fee_bp_as_owner(basis_points: u256) {
+    let (treasury_address, _, _, admin_dispatcher, _, _) = setup();
+
+    let mut spy = spy_events();
+
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher.set_fee_bp(basis_points).unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    assert(admin_dispatcher.get_fee_bp().unwrap() == basis_points, 'Basis points not updated');
+
+    // Verify event was emitted
+    let expected_event = Treasury::Event::BasisPointsUpdated(
+        BasisPointsUpdated { old_bp: 0, new_bp: basis_points },
+    );
+    spy.assert_emitted(@array![(treasury_address, expected_event)]);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_native_fee_bp_fails_as_non_owner(basis_points: u256) {
+    let (treasury_address, _, _, admin_dispatcher, _, _) = setup();
+
+    start_cheat_caller_address(treasury_address, USER);
+    let result = admin_dispatcher.set_fee_bp(basis_points);
+    stop_cheat_caller_address(treasury_address);
+
+    assert_panic_with_felt_error(result, 'Caller is not the owner');
+}
+
+#[test]
+fn test_basis_points_update_affects_fee_calculation() {
+    let (treasury_address, _, treasury_dispatcher, admin_dispatcher, _, _) = setup();
+
+    // Initially 0 basis points
+    let initial_fee = treasury_dispatcher
+        .get_fee(USER, TEST_DST_EID, TEST_WORKER_FEE, false)
+        .unwrap();
+    assert(initial_fee == 0, 'Initial fee should be 0');
+
+    const CUSTOM_WORKER_FEE: u256 = 8736482;
+    const CUSTOM_BASIS_POINTS: u256 = 721;
+
+    // Update basis points
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher.set_fee_bp(CUSTOM_BASIS_POINTS).unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    // Fee should now be calculated with new basis points
+    // should be 629,900.3522 ~= 629,900
+    let updated_fee = treasury_dispatcher
+        .get_fee(USER, TEST_DST_EID, CUSTOM_WORKER_FEE, false)
+        .unwrap();
+    assert(updated_fee == 629_900, 'Updated fee incorrect');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_keep_integer_part_of_native_fee(dst_eid: u32, amount: u128) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup_with_basis_points(1);
+    let amount = amount.into();
+
+    // The integer part should be kept.
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, amount * DEFAULT_BPS, false).unwrap();
+    assert(fee == amount, 'Invalid fee amount');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_drop_fractional_part_of_native_fee(dst_eid: u32, amount: u256) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup_with_basis_points(1);
+
+    // The fractional part should be truncated.
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, amount % DEFAULT_BPS, false).unwrap();
+    assert(fee == 0, 'Small fee should truncate to 0');
+}
+
+// =============================== LayerZero token =================================
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_get_enabled_lz_token_fee(dst_eid: u32, worker_fee: u256, expected_fee: u256) {
+    let (treasury_address, _, treasury_dispatcher, admin_dispatcher, _, _) = setup();
+
+    let library = deploy_mock_lz_token_fee_lib(0);
+    let library_assertion = IMockLzTokenFeeLibAssertionDispatcher { contract_address: library };
+    cheat_caller_address_once(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(library)).unwrap();
+
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == 0, 'Fee should be 0');
+
+    let library = deploy_mock_lz_token_fee_lib(expected_fee);
+    cheat_caller_address_once(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(library)).unwrap();
+
+    library_assertion.assert_payment_count(0);
+
+    let fee = treasury_dispatcher.get_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == expected_fee, 'Invalid fee amount');
+    library_assertion.assert_payment_count(0);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_get_disabled_lz_token_fee(dst_eid: u32, worker_fee: u256) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup();
+
+    let result = treasury_dispatcher.get_fee(USER, dst_eid, worker_fee, true);
+
+    assert_panic_with_error(result, err_lz_token_not_enabled());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_pay_enabled_lz_token_fee(dst_eid: u32, worker_fee: u256, expected_fee: u256) {
+    let (treasury_address, _, treasury_dispatcher, admin_dispatcher, _, _) = setup();
+
+    let library = deploy_mock_lz_token_fee_lib(0);
+    cheat_caller_address_once(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(library)).unwrap();
+
+    let fee = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == 0, 'Fee should be 0');
+
+    let library = deploy_mock_lz_token_fee_lib(expected_fee);
+    cheat_caller_address_once(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(library)).unwrap();
+
+    let fee = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == expected_fee, 'Invalid fee amount');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_pay_enabled_lz_token_fee_multiple_times(
+    dst_eid: u32, worker_fee: u256, expected_fee: u256,
+) {
+    let (treasury_address, _, treasury_dispatcher, admin_dispatcher, _, _) = setup();
+
+    let library = deploy_mock_lz_token_fee_lib(expected_fee);
+    let library_assertion = IMockLzTokenFeeLibAssertionDispatcher { contract_address: library };
+    cheat_caller_address_once(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(library)).unwrap();
+
+    library_assertion.assert_payment_count(0);
+
+    let fee = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == expected_fee, 'Invalid fee amount');
+    library_assertion.assert_payment_count(1);
+
+    let fee = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, true).unwrap();
+    assert(fee == expected_fee, 'Invalid fee amount');
+    library_assertion.assert_payment_count(2);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_pay_disabled_lz_token_fee(dst_eid: u32, worker_fee: u256) {
+    let (_, _, treasury_dispatcher, _, _, _) = setup();
+
+    let result = treasury_dispatcher.pay_fee(USER, dst_eid, worker_fee, true);
+
+    assert_panic_with_error(result, err_lz_token_not_enabled());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_lz_token_fee_as_owner(
+    dst_eid: u32,
+    worker_fee: u256,
+    first_lz_token_fee_lib: ContractAddress,
+    second_lz_token_fee_lib: ContractAddress,
+) {
+    let (treasury_address, _, _, admin_dispatcher, _, _) = setup();
+
+    assert(admin_dispatcher.get_lz_token_fee_lib().unwrap() == None, 'LZ token fee library set');
+
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(first_lz_token_fee_lib)).unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    assert(
+        admin_dispatcher.get_lz_token_fee_lib().unwrap() == Some(first_lz_token_fee_lib),
+        'Invalid LZ token fee library',
+    );
+
+    start_cheat_caller_address(treasury_address, OWNER);
+    admin_dispatcher.set_lz_token_fee_lib(Some(second_lz_token_fee_lib)).unwrap();
+    stop_cheat_caller_address(treasury_address);
+
+    assert(
+        admin_dispatcher.get_lz_token_fee_lib().unwrap() == Some(second_lz_token_fee_lib),
+        'Invalid LZ token fee library',
+    );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_set_lz_token_fee_lib_as_non_owner(
+    user: ContractAddress, lz_token_fee_lib: ContractAddress,
+) {
+    let (treasury_address, _, _, admin_dispatcher, _, _) = setup();
+
+    cheat_caller_address_once(treasury_address, user);
+    let result = admin_dispatcher.set_lz_token_fee_lib(None);
+
+    assert_panic_with_felt_error(result, 'Caller is not the owner');
+
+    cheat_caller_address_once(treasury_address, user);
+    let result = admin_dispatcher.set_lz_token_fee_lib(Some(lz_token_fee_lib));
+
+    assert_panic_with_felt_error(result, 'Caller is not the owner');
+}

package/layerzero/tests/treasury/utils.cairo

@@ -0,0 +1,8 @@
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use starknet::ContractAddress;
+
+pub fn deploy_mock_lz_token_fee_lib(fee: u256) -> ContractAddress {
+    let contract = declare("MockLzTokenFeeLib").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![fee.low.into(), fee.high.into()]).unwrap();
+    address
+}

package/layerzero/tests/utils.cairo

@@ -0,0 +1,48 @@
+use core::num::traits::SaturatingSub;
+use starknet::ContractAddress;
+use crate::fuzzable::felt_array::{Felt252ArrayList, FuzzableFelt252Array};
+
+pub fn sort_contract_addresses(xs: Array<ContractAddress>) -> Array<ContractAddress> {
+    if xs.len() < 2 {
+        return xs;
+    }
+
+    let pivot = *xs[0];
+    let mut left = array![];
+    let mut right = array![];
+    let mut xs = xs.into_iter();
+    xs.advance_by(1).unwrap();
+
+    for x in xs {
+        if x < pivot {
+            left.append(x);
+        } else {
+            right.append(x);
+        }
+    }
+
+    sort_contract_addresses(left)
+        .into_iter()
+        .chain(Some(pivot))
+        .chain(sort_contract_addresses(right))
+        .collect()
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_sort(list: Felt252ArrayList) {
+    let xs = list.arr.into_iter().map(|x| x.try_into().unwrap()).collect();
+    let ys = sort_contract_addresses(xs.clone());
+
+    assert_eq!(ys.len(), xs.len());
+
+    for x in xs {
+        let mut iterator = ys.span().into_iter();
+
+        assert!(iterator.any(|y| *y == x));
+    }
+
+    for index in 0..ys.len().saturating_sub(1) {
+        assert_le!(ys[index], ys[index + 1]);
+    }
+}