workspace: rename standalone adjective variables in tests

crates/apollo_batcher/src/batcher_test.rs

@@ -382,38 +382,42 @@ fn verify_decision_reached_response(
 
 fn assert_proposal_metrics(
     metrics: &str,
-    expected_started: u64,
-    expected_succeeded: u64,
-    expected_failed: u64,
-    expected_aborted: u64,
+    expected_started_count: u64,
+    expected_succeeded_count: u64,
+    expected_failed_count: u64,
+    expected_aborted_count: u64,
 ) {
-    let n_expected_active_proposals =
-        expected_started - (expected_succeeded + expected_failed + expected_aborted);
+    let n_expected_active_proposals = expected_started_count
+        - (expected_succeeded_count + expected_failed_count + expected_aborted_count);
     assert!(n_expected_active_proposals <= 1);
-    let started = PROPOSAL_STARTED.parse_numeric_metric::<u64>(metrics);
-    let succeeded = PROPOSAL_SUCCEEDED.parse_numeric_metric::<u64>(metrics);
-    let failed = PROPOSAL_FAILED.parse_numeric_metric::<u64>(metrics);
-    let aborted = PROPOSAL_ABORTED.parse_numeric_metric::<u64>(metrics);
+    let actual_started_count = PROPOSAL_STARTED.parse_numeric_metric::<u64>(metrics);
+    let actual_succeeded_count = PROPOSAL_SUCCEEDED.parse_numeric_metric::<u64>(metrics);
+    let actual_failed_count = PROPOSAL_FAILED.parse_numeric_metric::<u64>(metrics);
+    let actual_aborted_count = PROPOSAL_ABORTED.parse_numeric_metric::<u64>(metrics);
 
     assert_eq!(
-        started,
-        Some(expected_started),
-        "unexpected value proposal_started, expected {expected_started} got {started:?}",
+        actual_started_count,
+        Some(expected_started_count),
+        "unexpected value proposal_started, expected {expected_started_count} got \
+         {actual_started_count:?}",
     );
     assert_eq!(
-        succeeded,
-        Some(expected_succeeded),
-        "unexpected value proposal_succeeded, expected {expected_succeeded} got {succeeded:?}",
+        actual_succeeded_count,
+        Some(expected_succeeded_count),
+        "unexpected value proposal_succeeded, expected {expected_succeeded_count} got \
+         {actual_succeeded_count:?}",
     );
     assert_eq!(
-        failed,
-        Some(expected_failed),
-        "unexpected value proposal_failed, expected {expected_failed} got {failed:?}",
+        actual_failed_count,
+        Some(expected_failed_count),
+        "unexpected value proposal_failed, expected {expected_failed_count} got \
+         {actual_failed_count:?}",
     );
     assert_eq!(
-        aborted,
-        Some(expected_aborted),
-        "unexpected value proposal_aborted, expected {expected_aborted} got {aborted:?}",
+        actual_aborted_count,
+        Some(expected_aborted_count),
+        "unexpected value proposal_aborted, expected {expected_aborted_count} got \
+         {actual_aborted_count:?}",
     );
 }
 

crates/apollo_integration_tests/src/monitoring_utils.rs

@@ -211,7 +211,10 @@ pub async fn sequencer_num_accepted_txs(monitoring_client: &MonitoringClient) ->
 }
 
 pub async fn assert_no_reverted_txs(monitoring_client: &MonitoringClient, sequencer_idx: usize) {
-    let reverted =
+    let reverted_count =
         monitoring_client.get_metric::<usize>(REVERTED_TRANSACTIONS.get_name()).await.unwrap();
-    assert_eq!(reverted, 0, "Sequencer {sequencer_idx} has {reverted} reverted transactions");
+    assert_eq!(
+        reverted_count, 0,
+        "Sequencer {sequencer_idx} has {reverted_count} reverted transactions"
+    );
 }

crates/apollo_l1_provider/src/test_utils.rs

@@ -183,9 +183,9 @@ impl L1ProviderContentBuilder {
         mut self,
         committed: impl IntoIterator<Item = (L1HandlerTransaction, u64)>,
     ) -> Self {
-        let committed = committed.into_iter().map(Into::into);
+        let committed_txs = committed.into_iter().map(Into::into);
         self.tx_manager_content_builder =
-            self.tx_manager_content_builder.with_timed_committed(committed);
+            self.tx_manager_content_builder.with_timed_committed(committed_txs);
         self
     }
 
@@ -366,30 +366,31 @@ impl TransactionManagerContent {
 
 impl From<TransactionManagerContent> for TransactionManager {
     fn from(mut content: TransactionManagerContent) -> TransactionManager {
-        let pending: Vec<_> = mem::take(&mut content.uncommitted).unwrap_or_default();
-        let rejected: Vec<_> = mem::take(&mut content.rejected).unwrap_or_default();
-        let committed: Vec<_> = mem::take(&mut content.committed).unwrap_or_default();
-        let consumed: Vec<_> = mem::take(&mut content.consumed).unwrap_or_default();
-        let cancel_requested: Vec<_> = mem::take(&mut content.cancel_requested).unwrap_or_default();
+        let pending_txs: Vec<_> = mem::take(&mut content.uncommitted).unwrap_or_default();
+        let rejected_txs: Vec<_> = mem::take(&mut content.rejected).unwrap_or_default();
+        let committed_txs: Vec<_> = mem::take(&mut content.committed).unwrap_or_default();
+        let consumed_txs: Vec<_> = mem::take(&mut content.consumed).unwrap_or_default();
+        let cancel_requested_txs: Vec<_> =
+            mem::take(&mut content.cancel_requested).unwrap_or_default();
 
         let mut records = IndexMap::with_capacity(
-            pending.len()
-                + rejected.len()
-                + committed.len()
-                + cancel_requested.len()
-                + consumed.len(),
+            pending_txs.len()
+                + rejected_txs.len()
+                + committed_txs.len()
+                + cancel_requested_txs.len()
+                + consumed_txs.len(),
         );
 
         let mut proposable_index: BTreeMap<UnixTimestamp, Vec<TransactionHash>> = BTreeMap::new();
-        for timed_tx in pending {
+        for timed_tx in pending_txs {
             let tx_hash = timed_tx.tx.tx_hash;
             let block_timestamp = timed_tx.timestamp;
             let record = TransactionRecord::from(timed_tx);
             assert_eq!(records.insert(tx_hash, record), None);
             proposable_index.entry(block_timestamp.0).or_default().push(tx_hash);
         }
 
-        for rejected_tx in rejected {
+        for rejected_tx in rejected_txs {
             let tx_hash = rejected_tx.tx_hash;
             let mut record = TransactionRecord::new(TransactionPayload::Full {
                 tx: rejected_tx,
@@ -401,13 +402,13 @@ impl From<TransactionManagerContent> for TransactionManager {
             assert_eq!(records.insert(tx_hash, record), None);
         }
 
-        for committed_tx in committed {
+        for committed_tx in committed_txs {
             let mut record = TransactionRecord::from(committed_tx);
             record.mark_committed();
             assert_eq!(records.insert(record.tx.tx_hash(), record), None);
         }
 
-        for cancel_requested_tx in cancel_requested {
+        for cancel_requested_tx in cancel_requested_txs {
             let tx_hash = cancel_requested_tx.tx.tx_hash;
             let mut record = TransactionRecord::new(TransactionPayload::Full {
                 tx: cancel_requested_tx.tx,
@@ -420,7 +421,7 @@ impl From<TransactionManagerContent> for TransactionManager {
         }
 
         let mut consumed_queue: BTreeMap<BlockTimestamp, Vec<TransactionHash>> = BTreeMap::new();
-        for consumed_tx in consumed {
+        for consumed_tx in consumed_txs {
             let ConsumedTransaction { tx, timestamp } = consumed_tx;
             let tx_hash = tx.tx_hash;
             let mut record = TransactionRecord::new(TransactionPayload::Full {

crates/papyrus_base_layer/src/test_utils.rs

@@ -47,9 +47,9 @@ pub async fn make_block_history_on_anvil(
             .with_from(sender_address)
             .with_to(receiver_address)
             .with_value(U256::from(100));
-        let pending =
+        let pending_tx =
             provider.send_transaction(tx).await.expect("Could not post transaction to base layer");
-        let receipt: alloy::rpc::types::TransactionReceipt = pending
+        let receipt: alloy::rpc::types::TransactionReceipt = pending_tx
             .get_receipt()
             .await
             .expect("Could not get receipt for transaction to base layer");

crates/proving_utils/src/proof_encoding.rs

@@ -140,24 +140,24 @@ mod tests {
     #[case::aligned_4_bytes(vec![0x01, 0x02, 0x03, 0x04])]
     #[case::unaligned_6_bytes(vec![0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF])]
     fn test_proof_bytes_to_proof_round_trip(#[case] data: Vec<u8>) {
-        let original = ProofBytes(data);
-        let proof: Proof = original.clone().into();
+        let original_proof = ProofBytes(data);
+        let proof: Proof = original_proof.clone().into();
         let recovered: ProofBytes = proof.try_into().unwrap();
-        assert_eq!(original, recovered);
+        assert_eq!(original_proof, recovered);
     }
 
     #[rstest]
     #[case::empty(vec![])]
     #[case::small(vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09])]
     #[case::large((0u8..=255).cycle().take(10000).collect())]
     fn test_proof_bytes_file_round_trip(#[case] data: Vec<u8>) {
-        let original = ProofBytes(data);
+        let original_proof = ProofBytes(data);
         let temp_file = tempfile::NamedTempFile::new().unwrap();
         let path = temp_file.path();
 
-        original.to_file(path).unwrap();
+        original_proof.to_file(path).unwrap();
         let recovered = ProofBytes::from_file(path).unwrap();
 
-        assert_eq!(original, recovered);
+        assert_eq!(original_proof, recovered);
     }
 }

crates/starknet_api/src/test_utils.rs

@@ -127,9 +127,9 @@ impl NonceManager {
 
     /// Decrements the nonce of the account, unless it is zero.
     pub fn rollback(&mut self, account_address: ContractAddress) {
-        let current = *self.next_nonce.get(&account_address).unwrap_or(&Felt::default());
-        if current != Felt::ZERO {
-            self.next_nonce.insert(account_address, current - 1);
+        let current_nonce = *self.next_nonce.get(&account_address).unwrap_or(&Felt::default());
+        if current_nonce != Felt::ZERO {
+            self.next_nonce.insert(account_address, current_nonce - 1);
         }
     }
 }

crates/starknet_patricia/src/patricia_merkle_tree/updated_skeleton_tree/create_tree_helper_test.rs

@@ -495,11 +495,12 @@ fn test_update_node_in_nonempty_tree(
 #[tokio::test]
 async fn test_update_non_modified_storage_tree(#[case] root_hash: HashOutput) {
     let mut original_skeleton_tree = OriginalSkeletonTreeImpl::create_unmodified(root_hash);
-    let updated =
+    let updated_tree =
         UpdatedSkeletonTreeImpl::create(&mut original_skeleton_tree, &HashMap::new()).unwrap();
     let empty_map = HashMap::new();
-    let filled = MockTrie::create_with_existing_leaves::<TestTreeHashFunction>(updated, empty_map)
-        .await
-        .unwrap();
+    let filled =
+        MockTrie::create_with_existing_leaves::<TestTreeHashFunction>(updated_tree, empty_map)
+            .await
+            .unwrap();
     assert_eq!(root_hash, filled.get_root_hash());
 }