fix

Author: tinkerer-shubh

packages/tokens/fungible/src/extensions/burnable/test.rs

@@ -7,7 +7,10 @@ use stellar_event_assertion::EventAssertion;
 
 use crate::{
     extensions::{
-        burnable::{emit_burn, storage::{burn, burn_from}},
+        burnable::{
+            emit_burn,
+            storage::{burn, burn_from},
+        },
         mintable::mint,
     },
     storage::{allowance, approve, balance, total_supply},
@@ -116,7 +119,7 @@ fn emit_burn_works() {
     e.as_contract(&address, || {
         // Directly test the emit_burn function
         emit_burn(&e, &account, 50);
-        
+
         // Verify the event was emitted correctly
         let event_assert = EventAssertion::new(&e, address.clone());
         event_assert.assert_event_count(1);

packages/tokens/fungible/src/extensions/capped/test.rs

@@ -130,28 +130,31 @@ fn test_cap_not_set() {
     e.as_contract(&token, || {
         // First verify the cap is not set by querying total supply
         assert_eq!(total_supply(&e), 0);
-        
-        // Attempt to check cap without setting it first - should panic with CapNotSet (error code 208)
+
+        // Attempt to check cap without setting it first - should panic with CapNotSet
+        // (error code 208)
         check_cap(&e, 100);
-        
+
         // The following should never execute due to the panic
-        assert!(false, "This code should not be reached");
+        panic!("This code should not be reached");
     });
 }
 
 #[test]
 fn test_query_cap_direct_error_path() {
     let e = Env::default();
-    e.as_contract(&e.register_contract(None, TestToken), || {
+    e.as_contract(&e.register(TestToken, ()), || {
         // Check the cap is initially unset
-        let result: Option<i128> = e.storage().instance().get(&crate::extensions::capped::storage::CAP_KEY);
+        let result: Option<i128> =
+            e.storage().instance().get(&crate::extensions::capped::storage::CAP_KEY);
         assert_eq!(result, None);
-        
+
         // Set a cap
         e.storage().instance().set(&crate::extensions::capped::storage::CAP_KEY, &1000_i128);
-        
+
         // Verify the cap was set correctly
-        let result: Option<i128> = e.storage().instance().get(&crate::extensions::capped::storage::CAP_KEY);
+        let result: Option<i128> =
+            e.storage().instance().get(&crate::extensions::capped::storage::CAP_KEY);
         assert_eq!(result, Some(1000_i128));
     });
 }

packages/tokens/fungible/src/extensions/metadata/test.rs

@@ -2,9 +2,11 @@
 
 extern crate std;
 
-use soroban_sdk::{contract, Env, IntoVal, String};
+use soroban_sdk::{contract, Env, String};
 
-use crate::extensions::metadata::storage::{decimals, name, set_metadata, symbol, Metadata, METADATA_KEY};
+use crate::extensions::metadata::storage::{
+    decimals, name, set_metadata, symbol, Metadata, METADATA_KEY,
+};
 
 #[contract]
 struct TestToken;
@@ -67,44 +69,42 @@ fn test_metadata_struct() {
             name: String::from_str(&e, "Test Token"),
             symbol: String::from_str(&e, "TST"),
         };
-        
+
         // Store and retrieve to verify serialization
         e.storage().instance().set(&METADATA_KEY, &metadata1);
         let retrieved1: Metadata = e.storage().instance().get(&METADATA_KEY).unwrap();
-        
+
         assert_eq!(retrieved1.decimals, 9);
         assert_eq!(retrieved1.name, String::from_str(&e, "Test Token"));
         assert_eq!(retrieved1.symbol, String::from_str(&e, "TST"));
-        
+
         // Test case 2: Edge cases - empty strings and maximum decimal value
         let metadata2 = Metadata {
             decimals: u32::MAX,
             name: String::from_str(&e, ""),
             symbol: String::from_str(&e, ""),
         };
-        
+
         // Store and retrieve edge case metadata
         e.storage().instance().set(&METADATA_KEY, &metadata2);
         let retrieved2: Metadata = e.storage().instance().get(&METADATA_KEY).unwrap();
-        
+
         assert_eq!(retrieved2.decimals, u32::MAX);
         assert_eq!(retrieved2.name, String::from_str(&e, ""));
         assert_eq!(retrieved2.symbol, String::from_str(&e, ""));
-        
+
         // Test case 3: Long strings
-        let long_name = String::from_str(&e, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
+        let long_name =
+            String::from_str(&e, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
         let long_symbol = String::from_str(&e, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
-        
-        let metadata3 = Metadata {
-            decimals: 0,
-            name: long_name.clone(),
-            symbol: long_symbol.clone(),
-        };
-        
+
+        let metadata3 =
+            Metadata { decimals: 0, name: long_name.clone(), symbol: long_symbol.clone() };
+
         // Store and retrieve with long strings
         e.storage().instance().set(&METADATA_KEY, &metadata3);
         let retrieved3: Metadata = e.storage().instance().get(&METADATA_KEY).unwrap();
-        
+
         assert_eq!(retrieved3.decimals, 0);
         assert_eq!(retrieved3.name, long_name);
         assert_eq!(retrieved3.symbol, long_symbol);

packages/tokens/fungible/src/extensions/mintable/test.rs

@@ -63,7 +63,7 @@ fn emit_mint_works() {
     e.as_contract(&address, || {
         // Directly test the emit_mint function
         emit_mint(&e, &account, 100);
-        
+
         // Verify the event was emitted correctly
         let event_assert = EventAssertion::new(&e, address.clone());
         event_assert.assert_event_count(1);

packages/tokens/fungible/src/fungible_trait_test.rs

@@ -1,12 +1,6 @@
-#![cfg(test)]
-
-extern crate std;
-
 use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Env, IntoVal, String};
 
-use crate::fungible::FungibleToken;
-use crate::storage;
-use crate::mintable::mint;
+use crate::{fungible::FungibleToken, mintable::mint, storage};
 
 #[contract]
 pub struct TestToken;
@@ -57,40 +51,40 @@ impl FungibleToken for TestToken {
 fn test_fungible_token_trait() {
     let e = Env::default();
     e.mock_all_auths();
-    
+
     let contract_id = e.register(TestToken, ());
     let client = TestTokenClient::new(&e, &contract_id);
     let user1 = Address::generate(&e);
     let user2 = Address::generate(&e);
-    
+
     // Test implementation of the trait
-    
+
     // Mint some tokens for testing (using the internal functions)
     e.as_contract(&contract_id, || {
         mint(&e, &user1, 1000);
     });
-    
+
     // Test the trait functions
     assert_eq!(client.total_supply(), 1000);
     assert_eq!(client.balance(&user1), 1000);
     assert_eq!(client.balance(&user2), 0);
     assert_eq!(client.name(), "Test Token".into_val(&e));
     assert_eq!(client.symbol(), "TEST".into_val(&e));
     assert_eq!(client.decimals(), 7);
-    
+
     // Test transfer function
     client.transfer(&user1, &user2, &300);
     assert_eq!(client.balance(&user1), 700);
     assert_eq!(client.balance(&user2), 300);
-    
+
     // Test approve and allowance functions
     let expiration = e.ledger().sequence() + 1000;
     client.approve(&user1, &user2, &200, &expiration);
     assert_eq!(client.allowance(&user1, &user2), 200);
-    
+
     // Test transfer_from function
     client.transfer_from(&user2, &user1, &user2, &100);
     assert_eq!(client.balance(&user1), 600);
     assert_eq!(client.balance(&user2), 400);
     assert_eq!(client.allowance(&user1, &user2), 100);
-} 
+}

packages/tokens/fungible/src/storage_test.rs

@@ -1,26 +1,20 @@
-#![cfg(test)]
-
-extern crate std;
-
 use soroban_sdk::{contract, testutils::Address as _, Address, Env};
 
 use crate::storage::{AllowanceData, AllowanceKey, StorageKey};
 
 #[contract]
+#[allow(dead_code)]
 struct MockStorageContract;
 
 #[test]
 fn test_allowance_key_struct() {
     let e = Env::default();
     let owner = Address::generate(&e);
     let spender = Address::generate(&e);
-    
+
     // Test creating AllowanceKey
-    let key = AllowanceKey {
-        owner: owner.clone(),
-        spender: spender.clone(),
-    };
-    
+    let key = AllowanceKey { owner: owner.clone(), spender: spender.clone() };
+
     // Verify the struct fields
     assert_eq!(key.owner, owner);
     assert_eq!(key.spender, spender);
@@ -29,11 +23,8 @@ fn test_allowance_key_struct() {
 #[test]
 fn test_allowance_data_struct() {
     // Test creating AllowanceData
-    let data = AllowanceData {
-        amount: 100,
-        live_until_ledger: 1000,
-    };
-    
+    let data = AllowanceData { amount: 100, live_until_ledger: 1000 };
+
     // Verify the struct fields
     assert_eq!(data.amount, 100);
     assert_eq!(data.live_until_ledger, 1000);
@@ -45,34 +36,31 @@ fn test_storage_key_enum() {
     let address = Address::generate(&e);
     let owner = Address::generate(&e);
     let spender = Address::generate(&e);
-    
+
     // Test TotalSupply variant
     let key1 = StorageKey::TotalSupply;
-    
+
     // Test Balance variant
     let key2 = StorageKey::Balance(address);
-    
+
     // Test Allowance variant
-    let allowance_key = AllowanceKey {
-        owner,
-        spender,
-    };
+    let allowance_key = AllowanceKey { owner, spender };
     let key3 = StorageKey::Allowance(allowance_key);
-    
+
     // Simple assertions to make sure the code executes
     // We're mostly verifying these can be created without errors
     match key1 {
-        StorageKey::TotalSupply => assert!(true),
+        StorageKey::TotalSupply => {}
         _ => panic!("Expected TotalSupply"),
     }
-    
+
     match key2 {
-        StorageKey::Balance(_) => assert!(true),
+        StorageKey::Balance(_) => {}
         _ => panic!("Expected Balance"),
     }
-    
+
     match key3 {
-        StorageKey::Allowance(_) => assert!(true),
+        StorageKey::Allowance(_) => {}
         _ => panic!("Expected Allowance"),
     }
-} 
+}