workspace: rename standalone adjective variables in tests

Author: dan-starkware

crates/apollo_batcher/src/batcher_test.rs

@@ -392,7 +392,7 @@ fn assert_proposal_metrics(
     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 failed_count = PROPOSAL_FAILED.parse_numeric_metric::<u64>(metrics);
     let aborted = PROPOSAL_ABORTED.parse_numeric_metric::<u64>(metrics);
 
     assert_eq!(
@@ -406,9 +406,9 @@ fn assert_proposal_metrics(
         "unexpected value proposal_succeeded, expected {expected_succeeded} got {succeeded:?}",
     );
     assert_eq!(
-        failed,
+        failed_count,
         Some(expected_failed),
-        "unexpected value proposal_failed, expected {expected_failed} got {failed:?}",
+        "unexpected value proposal_failed, expected {expected_failed} got {failed_count:?}",
     );
     assert_eq!(
         aborted,

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,30 @@ 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 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: Vec<_> = mem::take(&mut content.consumed).unwrap_or_default();
         let cancel_requested: Vec<_> = mem::take(&mut content.cancel_requested).unwrap_or_default();
 
         let mut records = IndexMap::with_capacity(
-            pending.len()
-                + rejected.len()
-                + committed.len()
+            pending_txs.len()
+                + rejected_txs.len()
+                + committed_txs.len()
                 + cancel_requested.len()
                 + consumed.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,7 +401,7 @@ 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);

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());
 }