diff --git a/.cursorrules b/.cursorrules
index e47cb1fb..03cafe27 100644
--- a/.cursorrules
+++ b/.cursorrules
@@ -402,6 +402,7 @@ These rules should serve as guiding principles when developing the RustFS projec
  - Ensure each change provides sufficient test cases to guarantee code correctness
  - Do not arbitrarily modify numbers and constants in test cases, carefully analyze their meaning to ensure test case correctness
  - When writing or modifying tests, check existing test cases to ensure they have scientific naming and rigorous logic testing, if not compliant, modify test cases to ensure scientific and rigorous testing
+ - **Before committing any changes, run `cargo clippy --all-targets --all-features -- -D warnings` to ensure all code passes Clippy checks**
  - After each development completion, first git add . then git commit -m "feat: feature description" or "fix: issue description", ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
  - **Keep commit messages concise and under 72 characters** for the title line, use body for detailed explanations if needed
  - After each development completion, first git push to remote repository
diff --git a/cli/rustfs-gui/src/utils/config.rs b/cli/rustfs-gui/src/utils/config.rs
index a74c573c..1b7ddc9b 100644
--- a/cli/rustfs-gui/src/utils/config.rs
+++ b/cli/rustfs-gui/src/utils/config.rs
@@ -198,15 +198,16 @@ impl RustFSConfig {
         Ok(())
     }
 
-    /// delete the stored configuration
+    /// Clear the stored configuration from the system keyring
     ///
-    /// # Errors
-    /// * If the configuration cannot be deleted from the keyring
+    /// # Returns
+    /// Returns `Ok(())` if the configuration was successfully cleared, or an error if the operation failed.
     ///
     /// # Example
     /// ```
     /// RustFSConfig::clear().unwrap();
     /// ```
+    #[allow(dead_code)]
     pub fn clear() -> Result<(), Box<dyn Error>> {
         let entry = Entry::new(Self::SERVICE_NAME, Self::SERVICE_KEY)?;
         entry.delete_credential()?;
diff --git a/cli/rustfs-gui/src/utils/helper.rs b/cli/rustfs-gui/src/utils/helper.rs
index 103bde76..3c5e9e96 100644
--- a/cli/rustfs-gui/src/utils/helper.rs
+++ b/cli/rustfs-gui/src/utils/helper.rs
@@ -758,7 +758,6 @@ mod tests {
         // Test that show_error function exists and can be called
         // We can't actually test the dialog in a test environment
         // so we just verify the function signature
-        assert!(true); // Function exists and compiles
     }
 
     #[test]
@@ -766,7 +765,6 @@ mod tests {
         // Test that show_info function exists and can be called
         // We can't actually test the dialog in a test environment
         // so we just verify the function signature
-        assert!(true); // Function exists and compiles
     }
 
     #[test]
diff --git a/common/common/src/error.rs b/common/common/src/error.rs
index 08f23c84..c5376515 100644
--- a/common/common/src/error.rs
+++ b/common/common/src/error.rs
@@ -279,8 +279,10 @@ mod tests {
         let result: Result<(), Error> = Err(error);
         assert!(result.is_err());
 
-        let err = result.unwrap_err();
-        assert!(err.is::<io::Error>());
+        // Test the error from the result
+        if let Err(err) = result {
+            assert!(err.is::<io::Error>());
+        }
     }
 
     #[test]
diff --git a/common/common/src/last_minute.rs b/common/common/src/last_minute.rs
index 1bc25e2c..f2dc3936 100644
--- a/common/common/src/last_minute.rs
+++ b/common/common/src/last_minute.rs
@@ -245,8 +245,10 @@ mod tests {
 
     #[test]
     fn test_last_minute_latency_clone() {
-        let mut latency = LastMinuteLatency::default();
-        latency.last_sec = 12345;
+        let mut latency = LastMinuteLatency {
+            last_sec: 12345,
+            ..Default::default()
+        };
         latency.totals[0].total = 100;
 
         let cloned = latency.clone();
@@ -257,8 +259,10 @@ mod tests {
 
     #[test]
     fn test_forward_to_same_time() {
-        let mut latency = LastMinuteLatency::default();
-        latency.last_sec = 100;
+        let mut latency = LastMinuteLatency {
+            last_sec: 100,
+            ..Default::default()
+        };
 
         // Forward to same time should not change anything
         latency.forward_to(100);
@@ -271,8 +275,10 @@ mod tests {
 
     #[test]
     fn test_forward_to_large_gap() {
-        let mut latency = LastMinuteLatency::default();
-        latency.last_sec = 100;
+        let mut latency = LastMinuteLatency {
+            last_sec: 100,
+            ..Default::default()
+        };
         latency.totals[0].total = 999; // Set some data
 
         // Forward by more than 60 seconds should reset all totals
@@ -289,8 +295,10 @@ mod tests {
 
     #[test]
     fn test_forward_to_small_gap() {
-        let mut latency = LastMinuteLatency::default();
-        latency.last_sec = 100;
+        let mut latency = LastMinuteLatency {
+            last_sec: 100,
+            ..Default::default()
+        };
         latency.totals[1].total = 999; // Set some data at index 1
 
         // Forward by 2 seconds
@@ -446,7 +454,7 @@ mod tests {
     #[test]
     fn test_window_index_calculation() {
         // Test that window index calculation works correctly
-        let mut latency = LastMinuteLatency::default();
+        let _latency = LastMinuteLatency::default();
 
         let acc_elem = AccElem {
             total: 1,
@@ -476,10 +484,12 @@ mod tests {
 
     #[test]
     fn test_edge_case_boundary_conditions() {
-        let mut latency = LastMinuteLatency::default();
+        let mut latency = LastMinuteLatency {
+            last_sec: 59,
+            ..Default::default()
+        };
 
         // Test boundary at 60 seconds
-        latency.last_sec = 59;
         latency.forward_to(119); // Exactly 60 seconds later
 
         // Should reset all totals
diff --git a/common/lock/src/drwmutex.rs b/common/lock/src/drwmutex.rs
index 5c15175c..0b861b70 100644
--- a/common/lock/src/drwmutex.rs
+++ b/common/lock/src/drwmutex.rs
@@ -696,12 +696,12 @@ mod tests {
         };
 
         // Test get_lock (result depends on local locker state)
-        let result = mutex.get_lock(&id, &source, &opts).await;
+        let _result = mutex.get_lock(&id, &source, &opts).await;
         // Just ensure the method doesn't panic and returns a boolean
-        assert!(result == true || result == false);
+        // assert!(result || !result); // This is always true, so removed
 
         // If lock was acquired, test unlock
-        if result {
+        if _result {
             assert!(mutex.is_locked(), "Mutex should be in locked state");
             mutex.un_lock().await;
             assert!(!mutex.is_locked(), "Mutex should be unlocked after un_lock");
@@ -722,12 +722,12 @@ mod tests {
         };
 
         // Test get_r_lock (result depends on local locker state)
-        let result = mutex.get_r_lock(&id, &source, &opts).await;
+        let _result = mutex.get_r_lock(&id, &source, &opts).await;
         // Just ensure the method doesn't panic and returns a boolean
-        assert!(result == true || result == false);
+        // assert!(result || !result); // This is always true, so removed
 
         // If read lock was acquired, test runlock
-        if result {
+        if _result {
             assert!(mutex.is_r_locked(), "Mutex should be in read locked state");
             mutex.un_r_lock().await;
             assert!(!mutex.is_r_locked(), "Mutex should be unlocked after un_r_lock");
@@ -752,10 +752,10 @@ mod tests {
         // quorum = 3 - 1 = 2
         // Since it's a write lock and quorum != tolerance, quorum stays 2
         // The result depends on the actual locker implementation
-        let result = mutex.get_lock(&id, &source, &opts).await;
+        let _result = mutex.get_lock(&id, &source, &opts).await;
         // We don't assert success/failure here since it depends on the local locker state
         // Just ensure the method doesn't panic and returns a boolean
-        assert!(result == true || result == false);
+        // assert!(result || !result); // This is always true, so removed
     }
 
     #[tokio::test]
@@ -795,10 +795,10 @@ mod tests {
             retry_interval: Duration::from_millis(10),
         };
 
-        let result = mutex.get_lock(&id, &source, &opts).await;
+        let _result = mutex.get_lock(&id, &source, &opts).await;
         // The result depends on the actual locker implementation
         // Just ensure the method doesn't panic and returns a boolean
-        assert!(result == true || result == false);
+        // assert!(result || !result); // This is always true, so removed
     }
 
     #[tokio::test]
@@ -1049,8 +1049,8 @@ mod tests {
         // tolerance = 0 / 2 = 0
         // quorum = 0 - 0 = 0
         // This should fail because we can't achieve any quorum
-        let result = mutex.get_lock(&id, &source, &opts).await;
-        assert!(!result, "Should fail with zero lockers");
+        let _result = mutex.get_lock(&id, &source, &opts).await;
+        assert!(!_result, "Should fail with zero lockers");
     }
 
     #[test]
@@ -1125,8 +1125,8 @@ mod tests {
         let mut some_locks = vec!["uid1".to_string(), "uid2".to_string()];
         let result = mutex.release_all(1, &mut some_locks, false).await;
         // This should attempt to release the locks and may succeed or fail
-        // depending on the local locker state
-        assert!(result || !result); // Just ensure it doesn't panic
+        // depending on the local locker state - just ensure it doesn't panic
+        let _ = result; // Suppress unused variable warning
     }
 
     #[test]
diff --git a/crates/config/src/constants/app.rs b/crates/config/src/constants/app.rs
index 40626852..45a0997c 100644
--- a/crates/config/src/constants/app.rs
+++ b/crates/config/src/constants/app.rs
@@ -98,11 +98,9 @@ mod tests {
     fn test_app_basic_constants() {
         // Test application basic constants
         assert_eq!(APP_NAME, "RustFs");
-        assert!(!APP_NAME.is_empty(), "App name should not be empty");
         assert!(!APP_NAME.contains(' '), "App name should not contain spaces");
 
         assert_eq!(VERSION, "0.0.1");
-        assert!(!VERSION.is_empty(), "Version should not be empty");
 
         assert_eq!(SERVICE_VERSION, "0.0.1");
         assert_eq!(VERSION, SERVICE_VERSION, "Version and service version should be consistent");
@@ -117,13 +115,9 @@ mod tests {
             "Log level should be a valid tracing level"
         );
 
-        assert_eq!(USE_STDOUT, false);
-
         assert_eq!(SAMPLE_RATIO, 1.0);
-        assert!(SAMPLE_RATIO >= 0.0 && SAMPLE_RATIO <= 1.0, "Sample ratio should be between 0.0 and 1.0");
 
         assert_eq!(METER_INTERVAL, 30);
-        assert!(METER_INTERVAL > 0, "Meter interval should be positive");
     }
 
     #[test]
@@ -140,23 +134,17 @@ mod tests {
     fn test_connection_constants() {
         // Test connection related constants
         assert_eq!(MAX_CONNECTIONS, 100);
-        assert!(MAX_CONNECTIONS > 0, "Max connections should be positive");
-        assert!(MAX_CONNECTIONS <= 10000, "Max connections should be reasonable");
 
         assert_eq!(DEFAULT_TIMEOUT_MS, 3000);
-        assert!(DEFAULT_TIMEOUT_MS > 0, "Timeout should be positive");
-        assert!(DEFAULT_TIMEOUT_MS >= 1000, "Timeout should be at least 1 second");
     }
 
     #[test]
     fn test_security_constants() {
         // Test security related constants
         assert_eq!(DEFAULT_ACCESS_KEY, "rustfsadmin");
-        assert!(!DEFAULT_ACCESS_KEY.is_empty(), "Access key should not be empty");
         assert!(DEFAULT_ACCESS_KEY.len() >= 8, "Access key should be at least 8 characters");
 
         assert_eq!(DEFAULT_SECRET_KEY, "rustfsadmin");
-        assert!(!DEFAULT_SECRET_KEY.is_empty(), "Secret key should not be empty");
         assert!(DEFAULT_SECRET_KEY.len() >= 8, "Secret key should be at least 8 characters");
 
         // In production environment, access key and secret key should be different
@@ -169,7 +157,6 @@ mod tests {
         // Test file path related constants
         assert_eq!(DEFAULT_OBS_CONFIG, "./deploy/config/obs.toml");
         assert!(DEFAULT_OBS_CONFIG.ends_with(".toml"), "Config file should be TOML format");
-        assert!(!DEFAULT_OBS_CONFIG.is_empty(), "Config path should not be empty");
 
         assert_eq!(RUSTFS_TLS_KEY, "rustfs_key.pem");
         assert!(RUSTFS_TLS_KEY.ends_with(".pem"), "TLS key should be PEM format");
@@ -182,12 +169,8 @@ mod tests {
     fn test_port_constants() {
         // Test port related constants
         assert_eq!(DEFAULT_PORT, 9000);
-        assert!(DEFAULT_PORT > 1024, "Default port should be above reserved range");
-        // u16 type automatically ensures port is in valid range (0-65535)
 
         assert_eq!(DEFAULT_CONSOLE_PORT, 9002);
-        assert!(DEFAULT_CONSOLE_PORT > 1024, "Console port should be above reserved range");
-        // u16 type automatically ensures port is in valid range (0-65535)
 
         assert_ne!(DEFAULT_PORT, DEFAULT_CONSOLE_PORT, "Main port and console port should be different");
     }
@@ -256,12 +239,14 @@ mod tests {
         assert!(SAMPLE_RATIO.is_finite(), "Sample ratio should be finite");
         assert!(!SAMPLE_RATIO.is_nan(), "Sample ratio should not be NaN");
 
-        assert!(METER_INTERVAL < u64::MAX, "Meter interval should be reasonable");
-        assert!(MAX_CONNECTIONS < usize::MAX, "Max connections should be reasonable");
-        assert!(DEFAULT_TIMEOUT_MS < u64::MAX, "Timeout should be reasonable");
+        // All these are const values, so range checks are redundant
+        // assert!(METER_INTERVAL < u64::MAX, "Meter interval should be reasonable");
+        // assert!(MAX_CONNECTIONS < usize::MAX, "Max connections should be reasonable");
+        // assert!(DEFAULT_TIMEOUT_MS < u64::MAX, "Timeout should be reasonable");
 
-        assert!(DEFAULT_PORT != 0, "Default port should not be zero");
-        assert!(DEFAULT_CONSOLE_PORT != 0, "Console port should not be zero");
+        // These are const non-zero values, so zero checks are redundant
+        // assert!(DEFAULT_PORT != 0, "Default port should not be zero");
+        // assert!(DEFAULT_CONSOLE_PORT != 0, "Console port should not be zero");
     }
 
     #[test]
diff --git a/crates/config/src/event/config.rs b/crates/config/src/event/config.rs
index ea67144b..deea5db0 100644
--- a/crates/config/src/event/config.rs
+++ b/crates/config/src/event/config.rs
@@ -317,7 +317,8 @@ mod tests {
     fn test_default_config_file_constant() {
         // Test that the constant is properly defined
         assert_eq!(DEFAULT_CONFIG_FILE, "event");
-        assert!(!DEFAULT_CONFIG_FILE.is_empty(), "Config file name should not be empty");
+        // DEFAULT_CONFIG_FILE is a const, so is_empty() check is redundant
+        // assert!(!DEFAULT_CONFIG_FILE.is_empty(), "Config file name should not be empty");
         assert!(!DEFAULT_CONFIG_FILE.contains('/'), "Config file name should not contain path separators");
         assert!(!DEFAULT_CONFIG_FILE.contains('\\'), "Config file name should not contain Windows path separators");
     }
diff --git a/crates/config/src/observability/config.rs b/crates/config/src/observability/config.rs
index 9ba8888e..d2bd9258 100644
--- a/crates/config/src/observability/config.rs
+++ b/crates/config/src/observability/config.rs
@@ -76,12 +76,13 @@ mod tests {
         let config = ObservabilityConfig::new();
 
         // Test OTEL default values
-        if let Some(use_stdout) = config.otel.use_stdout {
-            assert!(use_stdout == true || use_stdout == false, "use_stdout should be a valid boolean");
+        if let Some(_use_stdout) = config.otel.use_stdout {
+            // Test boolean values - any boolean value is valid
+            // assert!(use_stdout || !use_stdout, "use_stdout should be a valid boolean");
         }
 
         if let Some(sample_ratio) = config.otel.sample_ratio {
-            assert!(sample_ratio >= 0.0 && sample_ratio <= 1.0, "Sample ratio should be between 0.0 and 1.0");
+            assert!((0.0..=1.0).contains(&sample_ratio), "Sample ratio should be between 0.0 and 1.0");
         }
 
         if let Some(meter_interval) = config.otel.meter_interval {
diff --git a/crates/event-notifier/src/error.rs b/crates/event-notifier/src/error.rs
index cd1ead24..e91f036e 100644
--- a/crates/event-notifier/src/error.rs
+++ b/crates/event-notifier/src/error.rs
@@ -343,7 +343,7 @@ mod tests {
     #[test]
     fn test_error_downcast() {
         // 测试错误的向下转型
-        let io_error = io::Error::new(io::ErrorKind::Other, "test error");
+        let io_error = io::Error::other("test error");
         let converted: Error = io_error.into();
 
         // 验证可以获取源错误
@@ -358,7 +358,7 @@ mod tests {
     #[test]
     fn test_error_chain_depth() {
         // 测试错误链的深度
-        let root_cause = io::Error::new(io::ErrorKind::Other, "root cause");
+        let root_cause = io::Error::other("root cause");
         let converted: Error = root_cause.into();
 
         let mut depth = 0;
@@ -411,8 +411,8 @@ mod tests {
 
             // Debug 输出通常包含更多信息，但不是绝对的
             // 这里我们只验证两者都有内容即可
-            assert!(debug_str.len() > 0);
-            assert!(display_str.len() > 0);
+            assert!(!debug_str.is_empty());
+            assert!(!display_str.is_empty());
         }
     }
 }
diff --git a/crates/utils/src/certs.rs b/crates/utils/src/certs.rs
index 0a7bd806..052d1566 100644
--- a/crates/utils/src/certs.rs
+++ b/crates/utils/src/certs.rs
@@ -43,7 +43,7 @@ pub fn load_private_key(filename: &str) -> io::Result<PrivateKeyDer<'static>> {
 
 /// error function
 pub fn certs_error(err: String) -> Error {
-    Error::new(io::ErrorKind::Other, err)
+    Error::other(err)
 }
 
 /// Load all certificates and private keys in the directory
diff --git a/crates/zip/src/lib.rs b/crates/zip/src/lib.rs
index 379a9fe5..76e244fb 100644
--- a/crates/zip/src/lib.rs
+++ b/crates/zip/src/lib.rs
@@ -21,20 +21,15 @@ pub enum CompressionFormat {
     Unknown,
 }
 
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum CompressionLevel {
     Fastest,
     Best,
+    #[default]
     Default,
     Level(u32),
 }
 
-impl Default for CompressionLevel {
-    fn default() -> Self {
-        CompressionLevel::Default
-    }
-}
-
 impl CompressionFormat {
     /// Identify compression format from file extension
     pub fn from_extension(ext: &str) -> Self {
@@ -679,7 +674,7 @@ mod tests {
             async move {
                 if invocation_number == 0 {
                     // First invocation returns an error
-                    Err(io::Error::new(io::ErrorKind::Other, "Simulated callback error"))
+                    Err(io::Error::other("Simulated callback error"))
                 } else {
                     Ok(())
                 }
@@ -765,8 +760,7 @@ mod tests {
             }
         }
 
-        // 如果能执行到这里，说明性能是可接受的
-        assert!(true, "Extension parsing performance test completed");
+        // Extension parsing performance test completed
     }
 
     #[test]
diff --git a/crypto/src/encdec/id.rs b/crypto/src/encdec/id.rs
index 53ca2fef..2475c834 100644
--- a/crypto/src/encdec/id.rs
+++ b/crypto/src/encdec/id.rs
@@ -89,7 +89,7 @@ mod tests {
     fn test_id_clone_and_copy() {
         // Test Clone and Copy traits
         let original = ID::Argon2idAESGCM;
-        let cloned = original.clone();
+        let cloned = original;
         let copied = original;
 
         assert!(matches!(cloned, ID::Argon2idAESGCM));
@@ -106,13 +106,13 @@ mod tests {
         let result = id.get_key(password, salt);
         assert!(result.is_ok());
 
-        let key = result.unwrap();
+        let key = result.expect("PBKDF2 key generation should succeed");
         assert_eq!(key.len(), 32);
 
         // Verify deterministic behavior - same inputs should produce same output
         let result2 = id.get_key(password, salt);
         assert!(result2.is_ok());
-        assert_eq!(key, result2.unwrap());
+        assert_eq!(key, result2.expect("PBKDF2 key generation should succeed"));
     }
 
     #[test]
@@ -125,13 +125,13 @@ mod tests {
         let result = id.get_key(password, salt);
         assert!(result.is_ok());
 
-        let key = result.unwrap();
+        let key = result.expect("Argon2id key generation should succeed");
         assert_eq!(key.len(), 32);
 
         // Verify deterministic behavior
         let result2 = id.get_key(password, salt);
         assert!(result2.is_ok());
-        assert_eq!(key, result2.unwrap());
+        assert_eq!(key, result2.expect("Argon2id key generation should succeed"));
     }
 
     #[test]
@@ -144,7 +144,7 @@ mod tests {
         let result = id.get_key(password, salt);
         assert!(result.is_ok());
 
-        let key = result.unwrap();
+        let key = result.expect("Argon2id ChaCha20Poly1305 key generation should succeed");
         assert_eq!(key.len(), 32);
     }
 
@@ -154,8 +154,8 @@ mod tests {
         let id = ID::Pbkdf2AESGCM;
         let salt = b"same_salt_for_all";
 
-        let key1 = id.get_key(b"password1", salt).unwrap();
-        let key2 = id.get_key(b"password2", salt).unwrap();
+        let key1 = id.get_key(b"password1", salt).expect("Key generation with password1 should succeed");
+        let key2 = id.get_key(b"password2", salt).expect("Key generation with password2 should succeed");
 
         assert_ne!(key1, key2);
     }
@@ -166,8 +166,8 @@ mod tests {
         let id = ID::Pbkdf2AESGCM;
         let password = b"same_password";
 
-        let key1 = id.get_key(password, b"salt1_16_bytes__").unwrap();
-        let key2 = id.get_key(password, b"salt2_16_bytes__").unwrap();
+        let key1 = id.get_key(password, b"salt1_16_bytes__").expect("Key generation with salt1 should succeed");
+        let key2 = id.get_key(password, b"salt2_16_bytes__").expect("Key generation with salt2 should succeed");
 
         assert_ne!(key1, key2);
     }
@@ -199,7 +199,7 @@ mod tests {
             let result = algorithm.get_key(password, salt);
             assert!(result.is_ok(), "Algorithm {:?} should generate valid key", algorithm);
 
-            let key = result.unwrap();
+            let key = result.expect("Key generation should succeed for all algorithms");
             assert_eq!(key.len(), 32, "Key length should be 32 bytes for {:?}", algorithm);
 
             // Verify key is not all zeros (very unlikely with proper implementation)
@@ -214,7 +214,7 @@ mod tests {
 
         for original in &original_ids {
             let as_u8 = *original as u8;
-            let converted_back = ID::try_from(as_u8).unwrap();
+            let converted_back = ID::try_from(as_u8).expect("Round-trip conversion should succeed");
 
             assert!(matches!(
                 (original, converted_back),
@@ -231,9 +231,9 @@ mod tests {
         let password = b"consistent_password";
         let salt = b"consistent_salt_";
 
-        let key_argon2_aes = ID::Argon2idAESGCM.get_key(password, salt).unwrap();
-        let key_argon2_chacha = ID::Argon2idChaCHa20Poly1305.get_key(password, salt).unwrap();
-        let key_pbkdf2 = ID::Pbkdf2AESGCM.get_key(password, salt).unwrap();
+        let key_argon2_aes = ID::Argon2idAESGCM.get_key(password, salt).expect("Argon2id AES key generation should succeed");
+        let key_argon2_chacha = ID::Argon2idChaCHa20Poly1305.get_key(password, salt).expect("Argon2id ChaCha key generation should succeed");
+        let key_pbkdf2 = ID::Pbkdf2AESGCM.get_key(password, salt).expect("PBKDF2 key generation should succeed");
 
         // Different algorithms should produce different keys
         assert_ne!(key_argon2_aes, key_pbkdf2);
diff --git a/crypto/src/encdec/tests.rs b/crypto/src/encdec/tests.rs
index 0d3fd5ef..a20ad019 100644
--- a/crypto/src/encdec/tests.rs
+++ b/crypto/src/encdec/tests.rs
@@ -78,7 +78,7 @@ fn test_encrypt_decrypt_binary_data() -> Result<(), crate::Error> {
         vec![0x00; 100],                    // All zeros
         vec![0xFF; 100],                    // All ones
         (0..=255u8).cycle().take(1000).collect::<Vec<u8>>(), // Sequential pattern
-        vec![0xAA, 0x55].repeat(500),       // Alternating pattern
+        [0xAA, 0x55].repeat(500),       // Alternating pattern
     ];
 
     for pattern in &binary_patterns {
diff --git a/crypto/src/jwt/tests.rs b/crypto/src/jwt/tests.rs
index 04cd0222..7d3c2955 100644
--- a/crypto/src/jwt/tests.rs
+++ b/crypto/src/jwt/tests.rs
@@ -143,10 +143,10 @@ fn test_jwt_with_different_secret_lengths() {
 
     for secret in &secrets {
         let jwt_token = encode(secret, &claims)
-            .expect(&format!("Failed to encode JWT with secret length {}", secret.len()));
+            .unwrap_or_else(|_| panic!("Failed to encode JWT with secret length {}", secret.len()));
 
         let decoded = decode(&jwt_token, secret)
-            .expect(&format!("Failed to decode JWT with secret length {}", secret.len()));
+            .unwrap_or_else(|_| panic!("Failed to decode JWT with secret length {}", secret.len()));
 
         assert_eq!(decoded.claims, claims);
     }
diff --git a/ecstore/src/bucket/metadata.rs b/ecstore/src/bucket/metadata.rs
index a961072e..8ab53b19 100644
--- a/ecstore/src/bucket/metadata.rs
+++ b/ecstore/src/bucket/metadata.rs
@@ -288,7 +288,7 @@ impl BucketMetadata {
     }
 
     pub fn set_created(&mut self, created: Option<OffsetDateTime>) {
-        self.created = { created.unwrap_or_else(|| OffsetDateTime::now_utc()) }
+        self.created = created.unwrap_or_else(OffsetDateTime::now_utc)
     }
 
     pub async fn save(&mut self) -> Result<()> {
diff --git a/ecstore/src/config/com.rs b/ecstore/src/config/com.rs
index 03038066..29fbe2ca 100644
--- a/ecstore/src/config/com.rs
+++ b/ecstore/src/config/com.rs
@@ -1,5 +1,5 @@
 use super::error::{is_err_config_not_found, ConfigError};
-use super::{storageclass, Config, GLOBAL_StorageClass, KVS};
+use super::{storageclass, Config, GLOBAL_StorageClass};
 use crate::disk::RUSTFS_META_BUCKET;
 use crate::store_api::{ObjectInfo, ObjectOptions, PutObjReader, StorageAPI};
 use crate::store_err::is_err_object_not_found;
@@ -191,7 +191,7 @@ async fn apply_dynamic_config_for_sub_sys<S: StorageAPI>(cfg: &mut Config, api:
     if subsys == STORAGE_CLASS_SUB_SYS {
         let kvs = cfg
             .get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_KV_KEY)
-            .unwrap_or_else(|| KVS::new());
+            .unwrap_or_default();
 
         for (i, count) in set_drive_counts.iter().enumerate() {
             match storageclass::lookup_config(&kvs, *count) {
diff --git a/ecstore/src/disk/local.rs b/ecstore/src/disk/local.rs
index 799b987b..601b4dba 100644
--- a/ecstore/src/disk/local.rs
+++ b/ecstore/src/disk/local.rs
@@ -627,7 +627,7 @@ impl LocalDisk {
             };
 
             if let Some(dir) = data_dir {
-                let vid = fi.version_id.unwrap_or(Uuid::nil());
+                let vid = fi.version_id.unwrap_or_default();
                 let _ = fm.data.remove(vec![vid, dir]);
 
                 let dir_path = self.get_object_path(volume, format!("{}/{}", path, dir).as_str())?;
@@ -1194,7 +1194,6 @@ impl DiskAPI for LocalDisk {
         Ok(())
     }
 
-    #[must_use]
     #[tracing::instrument(skip(self))]
     async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
         if volume == RUSTFS_META_BUCKET && path == super::FORMAT_CONFIG_FILE {
@@ -2183,7 +2182,7 @@ impl DiskAPI for LocalDisk {
         let old_dir = meta.delete_version(&fi)?;
 
         if let Some(uuid) = old_dir {
-            let vid = fi.version_id.unwrap_or(Uuid::nil());
+            let vid = fi.version_id.unwrap_or_default();
             let _ = meta.data.remove(vec![vid, uuid])?;
 
             let old_path = file_path.join(Path::new(uuid.to_string().as_str()));
diff --git a/ecstore/src/disk/mod.rs b/ecstore/src/disk/mod.rs
index d07576f5..19eb2baa 100644
--- a/ecstore/src/disk/mod.rs
+++ b/ecstore/src/disk/mod.rs
@@ -601,7 +601,7 @@ impl FileInfoVersions {
             return None;
         }
 
-        let vid = Uuid::parse_str(v).unwrap_or(Uuid::nil());
+        let vid = Uuid::parse_str(v).unwrap_or_default();
 
         self.versions.iter().position(|v| v.version_id == Some(vid))
     }
diff --git a/ecstore/src/file_meta.rs b/ecstore/src/file_meta.rs
index 7d3f8803..e9027219 100644
--- a/ecstore/src/file_meta.rs
+++ b/ecstore/src/file_meta.rs
@@ -446,7 +446,7 @@ impl FileMeta {
         let vid = fi.version_id;
 
         if let Some(ref data) = fi.data {
-            let key = vid.unwrap_or(Uuid::nil()).to_string();
+            let key = vid.unwrap_or_default().to_string();
             self.data.replace(&key, data.clone())?;
         }
 
@@ -574,7 +574,7 @@ impl FileMeta {
                 fi.successor_mod_time = succ_mod_time;
             }
             if read_data {
-                fi.data = self.data.find(fi.version_id.unwrap_or(Uuid::nil()).to_string().as_str())?;
+                fi.data = self.data.find(fi.version_id.unwrap_or_default().to_string().as_str())?;
             }
 
             fi.num_versions = self.versions.len();
@@ -1004,7 +1004,7 @@ impl FileMetaVersionHeader {
         rmp::encode::write_array_len(&mut wr, 7)?;
 
         // version_id
-        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
+        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
         // mod_time
         rmp::encode::write_i64(&mut wr, self.mod_time.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp_nanos() as i64)?;
         // signature
@@ -1430,11 +1430,11 @@ impl MetaObject {
 
         // string "ID"
         rmp::encode::write_str(&mut wr, "ID")?;
-        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
+        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
 
         // string "DDir"
         rmp::encode::write_str(&mut wr, "DDir")?;
-        rmp::encode::write_bin(&mut wr, self.data_dir.unwrap_or(Uuid::nil()).as_bytes())?;
+        rmp::encode::write_bin(&mut wr, self.data_dir.unwrap_or_default().as_bytes())?;
 
         // string "EcAlgo"
         rmp::encode::write_str(&mut wr, "EcAlgo")?;
@@ -1754,7 +1754,7 @@ impl MetaDeleteMarker {
 
         // string "ID"
         rmp::encode::write_str(&mut wr, "ID")?;
-        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
+        rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
 
         // string "MTime"
         rmp::encode::write_str(&mut wr, "MTime")?;
@@ -2174,6 +2174,7 @@ pub async fn read_xl_meta_no_data<R: AsyncRead + Unpin>(reader: &mut R, size: us
     }
 }
 #[cfg(test)]
+#[allow(clippy::field_reassign_with_default)]
 mod test {
     use super::*;
 
@@ -2392,10 +2393,12 @@ mod test {
 
     #[test]
     fn test_file_meta_version_header_methods() {
-        let mut header = FileMetaVersionHeader::default();
-        header.ec_n = 4;
-        header.ec_m = 2;
-        header.flags = XL_FLAG_FREE_VERSION;
+        let mut header = FileMetaVersionHeader {
+            ec_n: 4,
+            ec_m: 2,
+            flags: XL_FLAG_FREE_VERSION,
+            ..Default::default()
+        };
 
         // Test has_ec
         assert!(header.has_ec());
@@ -2413,13 +2416,17 @@ mod test {
 
     #[test]
     fn test_file_meta_version_header_comparison() {
-        let mut header1 = FileMetaVersionHeader::default();
-        header1.mod_time = Some(OffsetDateTime::from_unix_timestamp(1000).unwrap());
-        header1.version_id = Some(Uuid::new_v4());
+        let mut header1 = FileMetaVersionHeader {
+            mod_time: Some(OffsetDateTime::from_unix_timestamp(1000).unwrap()),
+            version_id: Some(Uuid::new_v4()),
+            ..Default::default()
+        };
 
-        let mut header2 = FileMetaVersionHeader::default();
-        header2.mod_time = Some(OffsetDateTime::from_unix_timestamp(2000).unwrap());
-        header2.version_id = Some(Uuid::new_v4());
+        let mut header2 = FileMetaVersionHeader {
+            mod_time: Some(OffsetDateTime::from_unix_timestamp(2000).unwrap()),
+            version_id: Some(Uuid::new_v4()),
+            ..Default::default()
+        };
 
         // Test sorts_before - header2 should sort before header1 (newer mod_time)
         assert!(!header1.sorts_before(&header2));
@@ -2469,9 +2476,11 @@ mod test {
 
     #[test]
     fn test_meta_object_methods() {
-        let mut obj = MetaObject::default();
-        obj.data_dir = Some(Uuid::new_v4());
-        obj.size = 1024;
+        let mut obj = MetaObject {
+            data_dir: Some(Uuid::new_v4()),
+            size: 1024,
+            ..Default::default()
+        };
 
         // Test use_data_dir
         assert!(obj.use_data_dir());
@@ -2667,16 +2676,20 @@ mod test {
     fn test_decode_data_dir_from_meta() {
         // Test with valid metadata containing data_dir
         let data_dir = Some(Uuid::new_v4());
-        let mut obj = MetaObject::default();
-        obj.data_dir = data_dir;
-        obj.mod_time = Some(OffsetDateTime::now_utc());
-        obj.erasure_algorithm = ErasureAlgo::ReedSolomon;
-        obj.bitrot_checksum_algo = ChecksumAlgo::HighwayHash;
+        let obj = MetaObject {
+            data_dir,
+            mod_time: Some(OffsetDateTime::now_utc()),
+            erasure_algorithm: ErasureAlgo::ReedSolomon,
+            bitrot_checksum_algo: ChecksumAlgo::HighwayHash,
+            ..Default::default()
+        };
 
         // Create a valid FileMetaVersion with the object
-        let mut version = FileMetaVersion::default();
-        version.version_type = VersionType::Object;
-        version.object = Some(obj);
+        let version = FileMetaVersion {
+            version_type: VersionType::Object,
+            object: Some(obj),
+            ..Default::default()
+        };
 
         let encoded = version.marshal_msg().unwrap();
         let result = FileMetaVersion::decode_data_dir_from_meta(&encoded);
@@ -2868,8 +2881,10 @@ fn test_file_meta_get_set_idx() {
     assert!(result.is_err());
 
     // Test set_idx
-    let mut new_version = FileMetaVersion::default();
-    new_version.version_type = VersionType::Object;
+    let new_version = FileMetaVersion {
+        version_type: VersionType::Object,
+        ..Default::default()
+    };
     let result = fm.set_idx(0, new_version);
     assert!(result.is_ok());
 
@@ -2983,10 +2998,12 @@ fn test_file_meta_version_header_from_version() {
 
 #[test]
 fn test_meta_object_into_fileinfo() {
-    let mut obj = MetaObject::default();
-    obj.version_id = Some(Uuid::new_v4());
-    obj.size = 1024;
-    obj.mod_time = Some(OffsetDateTime::now_utc());
+    let obj = MetaObject {
+        version_id: Some(Uuid::new_v4()),
+        size: 1024,
+        mod_time: Some(OffsetDateTime::now_utc()),
+        ..Default::default()
+    };
 
     let version_id = obj.version_id;
     let expected_version_id = version_id;
@@ -3014,9 +3031,11 @@ fn test_meta_object_from_fileinfo() {
 
 #[test]
 fn test_meta_delete_marker_into_fileinfo() {
-    let mut marker = MetaDeleteMarker::default();
-    marker.version_id = Some(Uuid::new_v4());
-    marker.mod_time = Some(OffsetDateTime::now_utc());
+    let marker = MetaDeleteMarker {
+        version_id: Some(Uuid::new_v4()),
+        mod_time: Some(OffsetDateTime::now_utc()),
+        ..Default::default()
+    };
 
     let version_id = marker.version_id;
     let expected_version_id = version_id;
@@ -3049,30 +3068,42 @@ fn test_flags_enum() {
 
 #[test]
 fn test_file_meta_version_header_user_data_dir() {
-    let mut header = FileMetaVersionHeader::default();
+    let header = FileMetaVersionHeader {
+        flags: 0,
+        ..Default::default()
+    };
 
     // Test without UsesDataDir flag
-    header.flags = 0;
     assert!(!header.user_data_dir());
 
     // Test with UsesDataDir flag
-    header.flags = Flags::UsesDataDir as u8;
+    let header = FileMetaVersionHeader {
+        flags: Flags::UsesDataDir as u8,
+        ..Default::default()
+    };
     assert!(header.user_data_dir());
 
     // Test with multiple flags including UsesDataDir
-    header.flags = Flags::UsesDataDir as u8 | Flags::FreeVersion as u8;
+    let header = FileMetaVersionHeader {
+        flags: Flags::UsesDataDir as u8 | Flags::FreeVersion as u8,
+        ..Default::default()
+    };
     assert!(header.user_data_dir());
 }
 
 #[test]
 fn test_file_meta_version_header_ordering() {
-    let mut header1 = FileMetaVersionHeader::default();
-    header1.mod_time = Some(OffsetDateTime::from_unix_timestamp(1000).unwrap());
-    header1.version_id = Some(Uuid::new_v4());
+    let header1 = FileMetaVersionHeader {
+        mod_time: Some(OffsetDateTime::from_unix_timestamp(1000).unwrap()),
+        version_id: Some(Uuid::new_v4()),
+        ..Default::default()
+    };
 
-    let mut header2 = FileMetaVersionHeader::default();
-    header2.mod_time = Some(OffsetDateTime::from_unix_timestamp(2000).unwrap());
-    header2.version_id = Some(Uuid::new_v4());
+    let header2 = FileMetaVersionHeader {
+        mod_time: Some(OffsetDateTime::from_unix_timestamp(2000).unwrap()),
+        version_id: Some(Uuid::new_v4()),
+        ..Default::default()
+    };
 
     // Test partial_cmp
     assert!(header1.partial_cmp(&header2).is_some());
@@ -3200,64 +3231,90 @@ async fn test_file_info_from_raw_edge_cases() {
 #[test]
 fn test_file_meta_version_invalid_cases() {
     // Test invalid version
-    let mut version = FileMetaVersion::default();
-    version.version_type = VersionType::Invalid;
+    let version = FileMetaVersion {
+        version_type: VersionType::Invalid,
+        ..Default::default()
+    };
     assert!(!version.valid());
 
     // Test version with neither object nor delete marker
-    version.version_type = VersionType::Object;
-    version.object = None;
-    version.delete_marker = None;
+    let version = FileMetaVersion {
+        version_type: VersionType::Object,
+        object: None,
+        delete_marker: None,
+        ..Default::default()
+    };
     assert!(!version.valid());
 }
 
 #[test]
 fn test_meta_object_edge_cases() {
-    let mut obj = MetaObject::default();
+    let obj = MetaObject {
+        data_dir: None,
+        ..Default::default()
+    };
 
     // Test use_data_dir with None (use_data_dir always returns true)
-    obj.data_dir = None;
     assert!(obj.use_data_dir());
 
     // Test use_inlinedata (always returns false in current implementation)
-    obj.size = 128 * 1024; // 128KB threshold
+    let obj = MetaObject {
+        size: 128 * 1024, // 128KB threshold
+        ..Default::default()
+    };
     assert!(!obj.use_inlinedata()); // Should be false
 
-    obj.size = 128 * 1024 - 1;
+    let obj = MetaObject {
+        size: 128 * 1024 - 1,
+        ..Default::default()
+    };
     assert!(!obj.use_inlinedata()); // Should also be false (always false)
 }
 
 #[test]
 fn test_file_meta_version_header_edge_cases() {
-    let mut header = FileMetaVersionHeader::default();
+    let header = FileMetaVersionHeader {
+        ec_n: 0,
+        ec_m: 0,
+        ..Default::default()
+    };
 
     // Test has_ec with zero values
-    header.ec_n = 0;
-    header.ec_m = 0;
     assert!(!header.has_ec());
 
     // Test matches_not_strict with different signatures but same version_id
-    let mut other = FileMetaVersionHeader::default();
     let version_id = Some(Uuid::new_v4());
-    header.version_id = version_id;
-    other.version_id = version_id;
-    header.version_type = VersionType::Object;
-    other.version_type = VersionType::Object;
-    header.signature = [1, 2, 3, 4];
-    other.signature = [5, 6, 7, 8];
+    let header = FileMetaVersionHeader {
+        version_id,
+        version_type: VersionType::Object,
+        signature: [1, 2, 3, 4],
+        ..Default::default()
+    };
+    let other = FileMetaVersionHeader {
+        version_id,
+        version_type: VersionType::Object,
+        signature: [5, 6, 7, 8],
+        ..Default::default()
+    };
     // Should match because they have same version_id and type
     assert!(header.matches_not_strict(&other));
 
     // Test sorts_before with same mod_time but different version_id
     let time = OffsetDateTime::from_unix_timestamp(1000).unwrap();
-    header.mod_time = Some(time);
-    other.mod_time = Some(time);
-    header.version_id = Some(Uuid::new_v4());
-    other.version_id = Some(Uuid::new_v4());
+    let header_time1 = FileMetaVersionHeader {
+        mod_time: Some(time),
+        version_id: Some(Uuid::new_v4()),
+        ..Default::default()
+    };
+    let header_time2 = FileMetaVersionHeader {
+        mod_time: Some(time),
+        version_id: Some(Uuid::new_v4()),
+        ..Default::default()
+    };
 
     // Should use version_id for comparison when mod_time is same
-    let sorts_before = header.sorts_before(&other);
-    assert!(sorts_before || other.sorts_before(&header)); // One should sort before the other
+    let sorts_before = header_time1.sorts_before(&header_time2);
+    assert!(sorts_before || header_time2.sorts_before(&header_time1)); // One should sort before the other
 }
 
 #[test]
diff --git a/ecstore/src/io.rs b/ecstore/src/io.rs
index 6480f7e3..b85fdaaa 100644
--- a/ecstore/src/io.rs
+++ b/ecstore/src/io.rs
@@ -58,7 +58,7 @@ impl HttpFileWriter {
                 .body(body)
                 .send()
                 .await
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+                .map_err(io::Error::other)
             {
                 error!("HttpFileWriter put file err: {:?}", err);
 
@@ -111,7 +111,7 @@ impl HttpFileReader {
             ))
             .send()
             .await
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            .map_err(io::Error::other)?;
 
         let inner = Box::new(StreamReader::new(resp.bytes_stream().map_err(io::Error::other)));
 
@@ -202,7 +202,8 @@ mod tests {
     #[tokio::test]
     async fn test_constants() {
         assert_eq!(READ_BUFFER_SIZE, 1024 * 1024);
-        assert!(READ_BUFFER_SIZE > 0);
+        // READ_BUFFER_SIZE is a compile-time constant, no need to assert
+        // assert!(READ_BUFFER_SIZE > 0);
     }
 
     #[tokio::test]
@@ -463,7 +464,8 @@ mod tests {
         let _writer: FileWriter = Box::new(writer_rx);
 
         // If this compiles, the types are correctly defined
-        assert!(true);
+        // This is a placeholder test - remove meaningless assertion
+        // assert!(true);
     }
 
     #[tokio::test]
@@ -483,8 +485,9 @@ mod tests {
     #[tokio::test]
     async fn test_read_buffer_size_constant() {
         assert_eq!(READ_BUFFER_SIZE, 1024 * 1024);
-        assert!(READ_BUFFER_SIZE > 0);
-        assert!(READ_BUFFER_SIZE % 1024 == 0, "Buffer size should be a multiple of 1024");
+        // READ_BUFFER_SIZE is a compile-time constant, no need to assert
+        // assert!(READ_BUFFER_SIZE > 0);
+        // assert!(READ_BUFFER_SIZE % 1024 == 0, "Buffer size should be a multiple of 1024");
     }
 
     #[tokio::test]
diff --git a/ecstore/src/rebalance.rs b/ecstore/src/rebalance.rs
index 349c5604..ed95673b 100644
--- a/ecstore/src/rebalance.rs
+++ b/ecstore/src/rebalance.rs
@@ -639,6 +639,7 @@ impl ECStore {
         false
     }
 
+    #[allow(unused_assignments)]
     #[tracing::instrument(skip(self, wk, set))]
     async fn rebalance_entry(
         &self,
diff --git a/ecstore/src/store.rs b/ecstore/src/store.rs
index 5fb6553a..dabdae4d 100644
--- a/ecstore/src/store.rs
+++ b/ecstore/src/store.rs
@@ -40,7 +40,7 @@ use crate::{
         ListObjectsV2Info, MakeBucketOptions, MultipartUploadResult, ObjectInfo, ObjectOptions, ObjectToDelete, PartInfo,
         PutObjReader, StorageAPI,
     },
-    store_init, utils,
+    store_init,
 };
 
 use common::error::{Error, Result};
@@ -2695,17 +2695,17 @@ mod tests {
     // Test validation functions
     #[test]
     fn test_is_valid_object_name() {
-        assert_eq!(is_valid_object_name("valid-object-name"), true);
-        assert_eq!(is_valid_object_name(""), false);
-        assert_eq!(is_valid_object_name("object/with/slashes"), true);
-        assert_eq!(is_valid_object_name("object with spaces"), true);
+        assert!(is_valid_object_name("valid-object-name"));
+        assert!(!is_valid_object_name(""));
+        assert!(is_valid_object_name("object/with/slashes"));
+        assert!(is_valid_object_name("object with spaces"));
     }
 
     #[test]
     fn test_is_valid_object_prefix() {
-        assert_eq!(is_valid_object_prefix("valid-prefix"), true);
-        assert_eq!(is_valid_object_prefix(""), true);
-        assert_eq!(is_valid_object_prefix("prefix/with/slashes"), true);
+        assert!(is_valid_object_prefix("valid-prefix"));
+        assert!(is_valid_object_prefix(""));
+        assert!(is_valid_object_prefix("prefix/with/slashes"));
     }
 
     #[test]
diff --git a/ecstore/src/store_api.rs b/ecstore/src/store_api.rs
index ca84354b..25ae7efa 100644
--- a/ecstore/src/store_api.rs
+++ b/ecstore/src/store_api.rs
@@ -1058,6 +1058,7 @@ pub trait StorageAPI: ObjectIO {
 }
 
 #[cfg(test)]
+#[allow(clippy::field_reassign_with_default)]
 mod tests {
     use super::*;
     use std::collections::HashMap;
@@ -1089,7 +1090,7 @@ mod tests {
         // Test distribution uniqueness
         let mut unique_values = std::collections::HashSet::new();
         for &val in &file_info.erasure.distribution {
-            assert!(val >= 1 && val <= 6, "Distribution value should be between 1 and 6");
+            assert!((1..=6).contains(&val), "Distribution value should be between 1 and 6");
             unique_values.insert(val);
         }
         assert_eq!(unique_values.len(), 6, "All distribution values should be unique");
diff --git a/ecstore/src/utils/os/mod.rs b/ecstore/src/utils/os/mod.rs
index b5691bb4..706ccc70 100644
--- a/ecstore/src/utils/os/mod.rs
+++ b/ecstore/src/utils/os/mod.rs
@@ -86,8 +86,8 @@ mod tests {
         // The actual result depends on the system configuration
         println!("Same disk result for temp dirs: {}", result);
 
-        // Just verify the function executes successfully
-        assert!(result == true || result == false);
+        // The function returns a boolean value as expected
+        let _: bool = result; // Type assertion to verify return type
     }
 
     #[test]
diff --git a/ecstore/src/utils/os/unix.rs b/ecstore/src/utils/os/unix.rs
index d710a770..4418fd76 100644
--- a/ecstore/src/utils/os/unix.rs
+++ b/ecstore/src/utils/os/unix.rs
@@ -2,7 +2,7 @@ use super::IOStats;
 use crate::disk::Info;
 use common::error::Result;
 use nix::sys::{stat::stat, statfs::statfs};
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use std::path::Path;
 
 /// returns total and free bytes available in a directory, e.g. `/`.
@@ -17,10 +17,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
     let reserved = match bfree.checked_sub(bavail) {
         Some(reserved) => reserved,
         None => {
-            return Err(Error::new(
-                ErrorKind::Other,
+            return Err(Error::other(
                 format!(
-                    "detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run 'fsck'",
+                    "detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run fsck",
                     bavail,
                     bfree,
                     p.as_ref().display()
@@ -32,10 +31,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
     let total = match blocks.checked_sub(reserved) {
         Some(total) => total * bsize,
         None => {
-            return Err(Error::new(
-                ErrorKind::Other,
+            return Err(Error::other(
                 format!(
-                    "detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run 'fsck'",
+                    "detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run fsck",
                     reserved,
                     blocks,
                     p.as_ref().display()
@@ -48,10 +46,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
     let used = match total.checked_sub(free) {
         Some(used) => used,
         None => {
-            return Err(Error::new(
-                ErrorKind::Other,
+            return Err(Error::other(
                 format!(
-                    "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
+                    "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run fsck",
                     free,
                     total,
                     p.as_ref().display()
diff --git a/iam/src/manager.rs b/iam/src/manager.rs
index 65cf0c23..61412634 100644
--- a/iam/src/manager.rs
+++ b/iam/src/manager.rs
@@ -1666,10 +1666,9 @@ mod tests {
         // In test environment, it might be None
         let key = get_token_signing_key();
         // Just verify it doesn't panic and returns an Option
-        match key {
-            Some(k) => assert!(!k.is_empty()),
-            None => {} // This is acceptable in test environment
-        }
+        if let Some(k) = key {
+            assert!(!k.is_empty());
+        } // This is acceptable in test environment when None
     }
 
     #[test]
@@ -1907,10 +1906,12 @@ mod tests {
 
     #[test]
     fn test_session_policy_constants() {
-        // Test session policy related constants
-        assert!(!SESSION_POLICY_NAME.is_empty());
-        assert!(!SESSION_POLICY_NAME_EXTRACTED.is_empty());
-        assert!(MAX_SVCSESSION_POLICY_SIZE > 0);
+        // Test session policy related constants - these are compile-time constants
+        // so we just verify they exist and have expected values
+        assert_eq!(SESSION_POLICY_NAME, "sessionPolicy");
+        assert_eq!(SESSION_POLICY_NAME_EXTRACTED, "sessionPolicy-extracted");
+        // MAX_SVCSESSION_POLICY_SIZE is a positive constant defined at compile time
+        assert_eq!(MAX_SVCSESSION_POLICY_SIZE, 4096); // Verify the actual expected value
     }
 
     #[test]
diff --git a/madmin/src/user.rs b/madmin/src/user.rs
index b8100295..ada67958 100644
--- a/madmin/src/user.rs
+++ b/madmin/src/user.rs
@@ -225,7 +225,7 @@ impl UpdateServiceAccountReq {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct AccountInfo {
     pub account_name: String,
     pub server: BackendInfo,
@@ -233,7 +233,7 @@ pub struct AccountInfo {
     pub buckets: Vec<BucketAccessInfo>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct BucketAccessInfo {
     pub name: String,
     pub size: u64,
@@ -247,7 +247,7 @@ pub struct BucketAccessInfo {
     pub access: AccountAccess,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct BucketDetails {
     pub versioning: bool,
     pub versioning_suspended: bool,
@@ -256,7 +256,7 @@ pub struct BucketDetails {
     // pub tagging: Option<Tagging>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct AccountAccess {
     pub read: bool,
     pub write: bool,
diff --git a/rustfs/src/admin/rpc.rs b/rustfs/src/admin/rpc.rs
index 5fc85da8..f1c140c9 100644
--- a/rustfs/src/admin/rpc.rs
+++ b/rustfs/src/admin/rpc.rs
@@ -120,7 +120,7 @@ impl Operation for PutFile {
         let mut body = StreamReader::new(
             req.input
                 .into_stream()
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e)),
+                .map_err(std::io::Error::other),
         );
 
         tokio::io::copy(&mut body, &mut file)
diff --git a/rustfs/src/console.rs b/rustfs/src/console.rs
index 8d939523..4be5c5d8 100644
--- a/rustfs/src/console.rs
+++ b/rustfs/src/console.rs
@@ -281,7 +281,7 @@ async fn start_server(server_addr: SocketAddr, tls_path: Option<String>, app: Ro
                     .handle(handle.clone())
                     .serve(app.into_make_service())
                     .await
-                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                    .map_err(io::Error::other)?;
 
                 info!("HTTPS server running on https://{}", server_addr);
 
@@ -323,7 +323,7 @@ async fn start_http_server(addr: SocketAddr, app: Router, handle: axum_server::H
         .handle(handle)
         .serve(app.into_make_service())
         .await
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        .map_err(io::Error::other)
 }
 
 async fn shutdown_signal() {
diff --git a/rustfs/src/grpc.rs b/rustfs/src/grpc.rs
index 1c912880..1c0ab803 100644
--- a/rustfs/src/grpc.rs
+++ b/rustfs/src/grpc.rs
@@ -2420,6 +2420,7 @@ impl Node for NodeService {
 }
 
 #[cfg(test)]
+#[allow(unused_imports)]
 mod tests {
     use super::*;
     use protos::proto_gen::node_service::{
diff --git a/rustfs/src/main.rs b/rustfs/src/main.rs
index 97f74536..e4df1e5f 100644
--- a/rustfs/src/main.rs
+++ b/rustfs/src/main.rs
@@ -71,6 +71,7 @@ const MI_B: usize = 1024 * 1024;
 #[global_allocator]
 static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
+#[allow(clippy::result_large_err)]
 fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {
     let token: MetadataValue<_> = "rustfs rpc".parse().unwrap();
 
@@ -79,6 +80,7 @@ fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {
         _ => Err(Status::unauthenticated("No valid auth token")),
     }
 }
+
 #[instrument]
 fn print_server_info() {
     let cfg = CONSOLE_CONFIG.get().unwrap();
diff --git a/rustfs/src/storage/ecfs.rs b/rustfs/src/storage/ecfs.rs
index 8d68f958..dcb069af 100644
--- a/rustfs/src/storage/ecfs.rs
+++ b/rustfs/src/storage/ecfs.rs
@@ -119,7 +119,7 @@ impl FS {
 
         let Some(body) = body else { return Err(s3_error!(IncompleteBody)) };
 
-        let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))));
+        let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))));
 
         // let etag_stream = EtagReader::new(body);
 
@@ -961,7 +961,7 @@ impl S3 for FS {
         };
 
         let body = Box::new(StreamReader::new(
-            body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))),
+            body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))),
         ));
 
         let mut reader = PutObjReader::new(body, content_length as usize);
@@ -1077,7 +1077,7 @@ impl S3 for FS {
         };
 
         let body = Box::new(StreamReader::new(
-            body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))),
+            body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))),
         ));
 
         // mc cp step 4
diff --git a/s3select/api/src/lib.rs b/s3select/api/src/lib.rs
index acaead72..52c923f9 100644
--- a/s3select/api/src/lib.rs
+++ b/s3select/api/src/lib.rs
@@ -12,8 +12,9 @@ pub type QueryResult<T> = Result<T, QueryError>;
 #[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
 pub enum QueryError {
+    #[snafu(display("DataFusion error: {}", source))]
     Datafusion {
-        source: DataFusionError,
+        source: Box<DataFusionError>,
         location: Location,
         backtrace: Backtrace,
     },
@@ -49,7 +50,7 @@ impl From<DataFusionError> for QueryError {
             DataFusionError::External(e) if e.downcast_ref::<QueryError>().is_some() => *e.downcast::<QueryError>().unwrap(),
 
             v => Self::Datafusion {
-                source: v,
+                source: Box::new(v),
                 location: Default::default(),
                 backtrace: Backtrace::capture(),
             },
diff --git a/s3select/query/src/sql/dialect.rs b/s3select/query/src/sql/dialect.rs
index c92cce17..1f027c84 100644
--- a/s3select/query/src/sql/dialect.rs
+++ b/s3select/query/src/sql/dialect.rs
@@ -23,7 +23,7 @@ mod tests {
 
     #[test]
     fn test_rustfs_dialect_creation() {
-        let dialect = RustFsDialect::default();
+        let _dialect = RustFsDialect;
 
         // Test that dialect can be created successfully
         assert!(std::mem::size_of::<RustFsDialect>() == 0, "Dialect should be zero-sized");
@@ -31,7 +31,7 @@ mod tests {
 
     #[test]
     fn test_rustfs_dialect_debug() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         let debug_str = format!("{:?}", dialect);
         assert!(!debug_str.is_empty(), "Debug output should not be empty");
@@ -40,7 +40,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_start_alphabetic() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test alphabetic characters
         assert!(dialect.is_identifier_start('a'), "Lowercase letter should be valid identifier start");
@@ -56,7 +56,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_start_special_chars() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test special characters that are allowed
         assert!(dialect.is_identifier_start('_'), "Underscore should be valid identifier start");
@@ -66,7 +66,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_start_invalid_chars() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test characters that should not be valid identifier starts
         assert!(!dialect.is_identifier_start('0'), "Digit should not be valid identifier start");
@@ -105,7 +105,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_part_alphabetic() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test alphabetic characters
         assert!(dialect.is_identifier_part('a'), "Lowercase letter should be valid identifier part");
@@ -121,7 +121,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_part_digits() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test ASCII digits
         assert!(dialect.is_identifier_part('0'), "Digit 0 should be valid identifier part");
@@ -132,7 +132,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_part_special_chars() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test special characters that are allowed
         assert!(dialect.is_identifier_part('_'), "Underscore should be valid identifier part");
@@ -143,7 +143,7 @@ mod tests {
 
     #[test]
     fn test_is_identifier_part_invalid_chars() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test characters that should not be valid identifier parts
         assert!(!dialect.is_identifier_part(' '), "Space should not be valid identifier part");
@@ -179,14 +179,14 @@ mod tests {
 
     #[test]
     fn test_supports_group_by_expr() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         assert!(dialect.supports_group_by_expr(), "RustFsDialect should support GROUP BY expressions");
     }
 
     #[test]
     fn test_identifier_validation_comprehensive() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test valid identifier patterns
         let valid_starts = ['a', 'A', 'z', 'Z', '_', '#', '@', 'α', '中'];
@@ -205,7 +205,7 @@ mod tests {
 
     #[test]
     fn test_identifier_edge_cases() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test edge cases with control characters
         assert!(!dialect.is_identifier_start('\0'), "Null character should not be valid identifier start");
@@ -220,7 +220,7 @@ mod tests {
 
     #[test]
     fn test_identifier_unicode_support() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test various Unicode categories
         let unicode_letters = ['α', 'β', 'γ', 'Α', 'Β', 'Γ', '中', '文', '日', '本', 'ñ', 'ü', 'ç'];
@@ -235,7 +235,7 @@ mod tests {
 
     #[test]
     fn test_identifier_ascii_digits() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test all ASCII digits
         for digit in '0'..='9' {
@@ -248,7 +248,7 @@ mod tests {
 
     #[test]
     fn test_dialect_consistency() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test that all valid identifier starts are also valid identifier parts
         let test_chars = [
@@ -266,7 +266,7 @@ mod tests {
 
     #[test]
     fn test_dialect_memory_efficiency() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test that dialect doesn't use excessive memory
         let dialect_size = std::mem::size_of_val(&dialect);
@@ -275,7 +275,7 @@ mod tests {
 
     #[test]
     fn test_dialect_trait_implementation() {
-        let dialect = RustFsDialect::default();
+        let dialect = RustFsDialect;
 
         // Test that dialect properly implements the Dialect trait
         let dialect_ref: &dyn Dialect = &dialect;
@@ -290,8 +290,8 @@ mod tests {
 
     #[test]
     fn test_dialect_clone_and_default() {
-        let dialect1 = RustFsDialect::default();
-        let dialect2 = RustFsDialect::default();
+        let dialect1 = RustFsDialect;
+        let dialect2 = RustFsDialect;
 
         // Test that multiple instances behave the same
         let test_chars = ['a', 'A', '0', '_', '#', '@', '$', ' ', '.'];
diff --git a/s3select/query/src/sql/optimizer.rs b/s3select/query/src/sql/optimizer.rs
index 10b9f197..3c573158 100644
--- a/s3select/query/src/sql/optimizer.rs
+++ b/s3select/query/src/sql/optimizer.rs
@@ -87,7 +87,7 @@ mod tests {
 
     #[test]
     fn test_cascade_optimizer_builder_default() {
-        let builder = CascadeOptimizerBuilder::default();
+        let _builder = CascadeOptimizerBuilder::default();
 
         // Test that builder can be created successfully
         assert!(std::mem::size_of::<CascadeOptimizerBuilder>() > 0, "Builder should be created successfully");
@@ -95,17 +95,17 @@ mod tests {
 
     #[test]
     fn test_cascade_optimizer_builder_build_with_defaults() {
-        let builder = CascadeOptimizerBuilder::default();
-        let optimizer = builder.build();
+        let _builder = CascadeOptimizerBuilder::default();
+        let optimizer = _builder.build();
 
         // Test that optimizer can be built with default components
         assert!(std::mem::size_of_val(&optimizer) > 0, "Optimizer should be built successfully");
     }
 
-        #[test]
+    #[test]
     fn test_cascade_optimizer_builder_basic_functionality() {
         // Test that builder methods can be called and return self
-        let builder = CascadeOptimizerBuilder::default();
+        let _builder = CascadeOptimizerBuilder::default();
 
         // Test that we can call builder methods (even if we don't have mock implementations)
         // This tests the builder pattern itself
@@ -114,23 +114,23 @@ mod tests {
 
     #[test]
     fn test_cascade_optimizer_builder_memory_efficiency() {
-        let builder = CascadeOptimizerBuilder::default();
+        let _builder = CascadeOptimizerBuilder::default();
 
         // Test that builder doesn't use excessive memory
-        let builder_size = std::mem::size_of_val(&builder);
+        let builder_size = std::mem::size_of_val(&_builder);
         assert!(builder_size < 1000, "Builder should not use excessive memory");
 
-        let optimizer = builder.build();
+        let optimizer = _builder.build();
         let optimizer_size = std::mem::size_of_val(&optimizer);
         assert!(optimizer_size < 1000, "Optimizer should not use excessive memory");
     }
 
-        #[test]
+    #[test]
     fn test_cascade_optimizer_builder_multiple_builds() {
-        let builder = CascadeOptimizerBuilder::default();
+        let _builder = CascadeOptimizerBuilder::default();
 
         // Test that we can build multiple optimizers from the same configuration
-        let optimizer1 = builder.build();
+        let optimizer1 = _builder.build();
         assert!(std::mem::size_of_val(&optimizer1) > 0, "First optimizer should be built successfully");
 
         // Note: builder is consumed by build(), so we can't build again from the same instance
@@ -139,16 +139,14 @@ mod tests {
 
     #[test]
     fn test_cascade_optimizer_builder_default_fallbacks() {
-        let builder = CascadeOptimizerBuilder::default();
-        let optimizer = builder.build();
+        let _builder = CascadeOptimizerBuilder::default();
+        let optimizer = _builder.build();
 
         // Test that default components are used when none are specified
         // We can't directly access the internal components, but we can verify the optimizer was built
         assert!(std::mem::size_of_val(&optimizer) > 0, "Optimizer should use default components");
     }
 
-
-
     #[test]
     fn test_cascade_optimizer_component_types() {
         let optimizer = CascadeOptimizerBuilder::default().build();
@@ -161,7 +159,7 @@ mod tests {
         // This is a basic structural test
     }
 
-        #[test]
+    #[test]
     fn test_cascade_optimizer_builder_consistency() {
         // Test that multiple builders with the same configuration produce equivalent optimizers
         let optimizer1 = CascadeOptimizerBuilder::default().build();
diff --git a/s3select/query/src/sql/parser.rs b/s3select/query/src/sql/parser.rs
index c561d43e..3412a50c 100644
--- a/s3select/query/src/sql/parser.rs
+++ b/s3select/query/src/sql/parser.rs
@@ -98,7 +98,7 @@ mod tests {
 
     #[test]
     fn test_default_parser_creation() {
-        let parser = DefaultParser::default();
+        let _parser = DefaultParser::default();
 
         // Test that parser can be created successfully
         assert!(std::mem::size_of::<DefaultParser>() == 0, "Parser should be zero-sized");
@@ -230,7 +230,7 @@ mod tests {
     #[test]
     fn test_ext_parser_parse_sql_with_dialect() {
         let sql = "SELECT * FROM S3Object";
-        let dialect = &RustFsDialect::default();
+        let dialect = &RustFsDialect;
 
         let result = ExtParser::parse_sql_with_dialect(sql, dialect);
         assert!(result.is_ok(), "ExtParser::parse_sql_with_dialect should work");
@@ -242,7 +242,7 @@ mod tests {
     #[test]
     fn test_ext_parser_new_with_dialect() {
         let sql = "SELECT * FROM S3Object";
-        let dialect = &RustFsDialect::default();
+        let dialect = &RustFsDialect;
 
         let result = ExtParser::new_with_dialect(sql, dialect);
         assert!(result.is_ok(), "ExtParser::new_with_dialect should work");
@@ -418,7 +418,7 @@ mod tests {
     #[test]
     fn test_ext_parser_expected_method() {
         let sql = "SELECT * FROM S3Object";
-        let dialect = &RustFsDialect::default();
+        let dialect = &RustFsDialect;
         let parser = ExtParser::new_with_dialect(sql, dialect).unwrap();
 
         let result: Result<()> = parser.expected("test token", "found token");