Fix the usage of #[trace] attributes in rstest-based tests

api-server/stack-test-suite/tests/v2/orders.rs

@@ -21,10 +21,9 @@ use common::chain::{
 use super::*;
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 #[tokio::test]
 async fn create_fill_conclude_order(#[case] seed: Seed, #[case] version: OrdersVersion) {
     use common::chain::config::create_unit_test_config_builder;

chainstate/constraints-value-accumulator/src/tests/orders_constraints.rs

@@ -254,10 +254,9 @@ fn create_order_constraints(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -608,10 +607,9 @@ fn fill_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 

chainstate/test-suite/src/tests/data_deposit.rs

@@ -29,10 +29,9 @@ use test_utils::random::{Seed, make_seedable_rng};
 use tx_verifier::CheckTransactionError;
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true)]
-#[trace]
 #[case(Seed::from_entropy(), false)]
+#[trace]
 fn data_deposited_too_large(#[case] seed: Seed, #[case] expect_success: bool) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -84,14 +83,11 @@ fn data_deposited_too_large(#[case] seed: Seed, #[case] expect_success: bool) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true, 1)]
-#[trace]
 #[case(Seed::from_entropy(), false, 1)]
-#[trace]
 #[case(Seed::from_entropy(), true, 2)]
-#[trace]
 #[case(Seed::from_entropy(), false, 2)]
+#[trace]
 fn data_deposit_insufficient_fee(
     #[case] seed: Seed,
     #[case] expect_success: bool,

chainstate/test-suite/src/tests/fungible_tokens_v1.rs

@@ -2575,10 +2575,9 @@ fn check_lockable_supply(#[case] seed: Seed) {
 // Issue a token.
 // Check that Unlimited and Fixed supplies cannot be locked.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), TokenTotalSupply::Unlimited)]
-#[trace]
 #[case(Seed::from_entropy(), TokenTotalSupply::Fixed(Amount::from_atoms(1)))]
+#[trace]
 fn try_lock_not_lockable_supply(#[case] seed: Seed, #[case] supply: TokenTotalSupply) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);

chainstate/test-suite/src/tests/input_commitments.rs

@@ -298,10 +298,9 @@ fn pool_decommissioning(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_fill(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -585,10 +584,9 @@ fn order_fill(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_conclude(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 

chainstate/test-suite/src/tests/orders_tests.rs

@@ -732,10 +732,9 @@ fn create_order_tokens_for_tokens(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -822,10 +821,9 @@ fn conclude_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersi
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -921,10 +919,9 @@ fn conclude_order_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersio
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1061,10 +1058,9 @@ fn fill_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion)
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1283,10 +1279,9 @@ fn fill_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn try_overbid_order_in_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1396,10 +1391,9 @@ fn try_overbid_order_in_multiple_txs(#[case] seed: Seed, #[case] version: Orders
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_completely_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1585,10 +1579,9 @@ fn fill_completely_then_conclude(#[case] seed: Seed, #[case] version: OrdersVers
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_check_signature(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1720,10 +1713,9 @@ fn conclude_order_check_signature(#[case] seed: Seed, #[case] version: OrdersVer
 // Create a chain with an order which is filled partially.
 // Reorg from a point before the order was created, so that after reorg storage has no information on the order
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn reorg_before_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1819,10 +1811,9 @@ fn reorg_before_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
 // Create a chain with an order which is filled partially or completely and then concluded.
 // Reorg from a point after the order was created, so that after reorg storage has original information on the order
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn reorg_after_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2025,10 +2016,9 @@ fn test_activation(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn create_order_with_nft(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2469,10 +2459,9 @@ fn partially_fill_order_with_nft_v1(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_with_zero(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2554,10 +2543,9 @@ fn fill_order_with_zero(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_underbid(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         use orders_accounting::calculate_filled_amount;
@@ -3064,10 +3052,9 @@ fn create_order_fill_activate_fork_fill_conclude(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn freeze_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -3497,10 +3484,9 @@ fn fill_freeze_conclude_order(#[case] seed: Seed) {
 
 // Orders with zero values are not allowed.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_with_zero_value(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -3943,10 +3929,9 @@ fn fill_order_v1_must_not_be_signed(#[case] seed: Seed) {
 // it creates a block with 2 identical inputs among its transactions (which would normally be
 // rejected with the DuplicateInputInBlock error, but v1 FillOrder inputs are an exception).
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_twice_in_same_block(
     #[case] seed: Seed,
     #[case] version: OrdersVersion,

chainstate/test-suite/src/tests/pos_accounting_reorg.rs

@@ -49,7 +49,6 @@ use test_utils::random::{Seed, make_seedable_rng};
 // Block `a` and block `c` have stake pool operation.
 // Check that after reorg all accounting data from block `a` was removed and from block `c` added to storage.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 0)]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 1)]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 2)]
@@ -59,6 +58,7 @@ use test_utils::random::{Seed, make_seedable_rng};
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 0)]
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 1)]
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 2)]
+#[trace]
 fn stake_pool_reorg(
     #[case] seed: Seed,
     #[case] epoch_length: NonZeroU64,

chainstate/test-suite/src/tests/signature_tests.rs

@@ -499,9 +499,9 @@ fn signed_classical_multisig_tx_missing_sigs(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true)]
 #[case(Seed::from_entropy(), false)]
+#[trace]
 fn too_large_no_sig_data(#[case] seed: Seed, #[case] valid_size: bool) {
     utils::concurrency::model(move || {
         let mut rng = test_utils::random::make_seedable_rng(seed);
@@ -567,11 +567,11 @@ fn too_large_no_sig_data(#[case] seed: Seed, #[case] valid_size: bool) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true, true)]
 #[case(Seed::from_entropy(), true, false)]
 #[case(Seed::from_entropy(), false, true)]
 #[case(Seed::from_entropy(), false, false)]
+#[trace]
 fn no_sig_data_not_allowed(
     #[case] seed: Seed,
     #[case] data_allowed: bool,

chainstate/tx-verifier/src/transaction_verifier/reward_distribution.rs

@@ -647,9 +647,9 @@ mod tests {
     // and that pool_b and its delegations were not affected.
     // Then undo everything and check that original state was restored.
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn distribution_basic(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));
@@ -810,9 +810,9 @@ mod tests {
     // Create a pool with 2 delegations and random balances and reward.
     // Check distribution properties.
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn distribution_properties(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));
@@ -959,9 +959,9 @@ mod tests {
 
     // Check that if delegation is present but its balance is 0 then all the reward goes to staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn total_delegations_balance_zero(
         #[case] seed: Seed,
         #[case] version: RewardDistributionVersion,
@@ -1034,9 +1034,9 @@ mod tests {
 
     // Check that staker can set its reward to 100% and the reward goes entirely to the staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn total_delegations_reward_zero(
         #[case] seed: Seed,
         #[case] version: RewardDistributionVersion,
@@ -1109,9 +1109,9 @@ mod tests {
 
     // Check that if there are no delegations then the whole reward goes to the staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn no_delegations(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));

consensus/src/pos/effective_pool_balance.rs

@@ -333,10 +333,9 @@ mod tests {
     }
 
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), Amount::from_atoms(600_000))]
-    #[trace]
     #[case(Seed::from_entropy(), CoinUnit::from_coins(600_000_000).to_amount_atoms())]
+    #[trace]
     fn calculate_effective_pool_balance_not_saturated(
         #[case] seed: Seed,
         #[case] final_supply: Amount,
@@ -358,10 +357,9 @@ mod tests {
     }
 
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), Amount::from_atoms(600_000))]
-    #[trace]
     #[case(Seed::from_entropy(), CoinUnit::from_coins(600_000_000).to_amount_atoms())]
+    #[trace]
     fn calculate_effective_balance_capped(#[case] seed: Seed, #[case] final_supply: Amount) {
         let mut rng = make_seedable_rng(seed);