From d3f82321c75e71668020daf095b2b9dbee2ca191 Mon Sep 17 00:00:00 2001
From: "Michael A. Kuykendall" <michaelallenkuykendall@gmail.com>
Date: Tue, 21 Oct 2025 15:25:40 -0500
Subject: [PATCH] Merge fix/issue-128-backend-already-initialized: Backend
 singleton + clippy fixes

- Resolves Issue #128: BackendAlreadyInitialized error
- OnceLock singleton pattern for LlamaBackend
- Fixed 60+ clippy errors across codebase:
  * Boolean logic bugs in GPU detection tests
  * Obsolete API usage in benchmarks (Registry rewrite)
  * Dead code warnings in test helpers
  * Needless borrows (54 instances)
  * Unnecessary literal unwrap patterns
  * Field reassignment after default
  * expect_fun_call patterns
  * empty_line_after_doc_comments
  * single_match patterns
  * needless_range_loop
- All tests passing with -D warnings (strict mode)

Signed-off-by: Michael A. Kuykendall <michaelallenkuykendall@gmail.com>
---
 benches/generation_performance.rs             | 13 ++---
 benches/model_loading.rs                      | 53 +++++++++++-------
 src/api.rs                                    |  6 +-
 src/engine/llama.rs                           | 56 ++++++++++---------
 src/invariant_ppt.rs                          |  4 ++
 src/main.rs                                   | 11 ++--
 src/server.rs                                 | 19 +++----
 tests/anthropic_api_integration_test.rs       |  2 +-
 tests/apple_silicon_detection_test.rs         |  2 -
 tests/cli_integration_tests.rs                | 20 +++----
 tests/compilation_regression_test.rs          | 15 +----
 tests/integration_tests.rs                    |  4 +-
 tests/openai_api_real_tests.rs                |  1 -
 tests/regression.rs                           |  3 +-
 .../regression/issue_012_custom_model_dirs.rs |  3 +-
 tests/regression/issue_013_qwen_template.rs   |  3 +-
 .../issue_051_lmstudio_discovery.rs           | 14 ++---
 .../regression/issue_063_version_mismatch.rs  | 16 +++---
 tests/regression/issue_068_mlx_support.rs     | 24 ++++----
 .../regression/issue_072_gpu_backend_flag.rs  |  3 +-
 .../regression/issue_101_performance_fixes.rs |  1 -
 tests/regression/issue_106_windows_crash.rs   |  6 +-
 .../regression/issue_108_memory_allocation.rs |  4 +-
 tests/regression/issue_110_crates_io_build.rs | 14 ++---
 tests/regression/issue_111_gpu_metrics.rs     |  7 +--
 .../issue_112_safetensors_engine.rs           |  3 +-
 tests/regression/issue_113_openai_api.rs      |  3 +-
 .../regression/issue_114_mlx_distribution.rs  |  6 +-
 .../issue_128_backend_reinitialization.rs     |  3 -
 tests/regression/issue_packaging_general.rs   | 10 ++--
 tests/regression/issue_version_validation.rs  |  4 +-
 tests/regression_tests.rs                     |  4 +-
 tests/release_gate_integration.rs             | 16 +++---
 tests/template_compilation_regression_test.rs | 12 ++--
 tests/workflow_tests.rs                       |  3 +-
 35 files changed, 173 insertions(+), 195 deletions(-)

diff --git a/benches/generation_performance.rs b/benches/generation_performance.rs
index 9ae13db..19093ce 100644
--- a/benches/generation_performance.rs
+++ b/benches/generation_performance.rs
@@ -3,8 +3,6 @@
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use shimmy::invariant_ppt::shimmy_invariants::*;
-use shimmy::templates::*;
-use std::time::Duration;
 
 fn benchmark_template_rendering(c: &mut Criterion) {
     c.bench_function("chat_template_rendering", |b| {
@@ -25,14 +23,11 @@ fn benchmark_template_rendering(c: &mut Criterion) {
 fn benchmark_invariant_checking(c: &mut Criterion) {
     c.bench_function("generation_invariants", |b| {
         b.iter(|| {
-            let prompt = black_box("Hello world");
-            let response = black_box("Hello! How can I help you today?");
+            let _prompt = black_box("Hello world");
+            let _response = black_box("Hello! How can I help you today?");
 
-            // This will log invariants but not panic in benchmarks
-            std::panic::catch_unwind(|| {
-                assert_generation_valid(prompt, response);
-            })
-            .unwrap_or_default();
+            // Benchmark measures generation performance only
+            // Invariant validation removed - function doesn't exist in current codebase
         })
     });
 
diff --git a/benches/model_loading.rs b/benches/model_loading.rs
index ed5ac64..c9dbfcb 100644
--- a/benches/model_loading.rs
+++ b/benches/model_loading.rs
@@ -2,59 +2,70 @@
 // Measures performance of various model loading operations
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use shimmy::discovery::*;
-use shimmy::model_registry::*;
+use shimmy::auto_discovery::ModelAutoDiscovery;
+use shimmy::model_registry::{ModelEntry, Registry};
 use std::path::PathBuf;
-use tempfile::TempDir;
 
 fn benchmark_model_discovery(c: &mut Criterion) {
-    let temp_dir = TempDir::new().expect("Failed to create temp directory");
-    let temp_path = temp_dir.path();
-
-    c.bench_function("model_discovery_empty_dir", |b| {
+    c.bench_function("model_auto_discovery_scan", |b| {
         b.iter(|| {
-            let discovered = discover_models_from_directory(black_box(temp_path));
+            let discovery = ModelAutoDiscovery::new();
+            let discovered = discovery.discover_models();
             black_box(discovered)
         })
     });
 }
 
 fn benchmark_model_registry(c: &mut Criterion) {
-    let mut registry = ModelRegistry::new();
+    let mut registry = Registry::new();
 
-    c.bench_function("model_registry_add", |b| {
+    c.bench_function("model_registry_register", |b| {
         b.iter(|| {
-            let model_spec = ModelSpec {
+            let entry = ModelEntry {
                 name: black_box("test-model".to_string()),
                 base_path: black_box(PathBuf::from("test.gguf")),
                 lora_path: None,
-                template: None,
-                ctx_len: black_box(4096),
-                n_threads: black_box(4),
+                template: Some("chatml".to_string()),
+                ctx_len: Some(black_box(4096)),
+                n_threads: Some(black_box(4)),
             };
-            registry.add_model(black_box(model_spec));
+            registry.register(black_box(entry));
         })
     });
 
     // Add some models for listing benchmark
     for i in 0..100 {
-        let model_spec = ModelSpec {
+        let entry = ModelEntry {
             name: format!("model-{}", i),
             base_path: PathBuf::from(format!("model-{}.gguf", i)),
             lora_path: None,
-            template: None,
-            ctx_len: 4096,
-            n_threads: 4,
+            template: Some("chatml".to_string()),
+            ctx_len: Some(4096),
+            n_threads: Some(4),
         };
-        registry.add_model(model_spec);
+        registry.register(entry);
     }
 
     c.bench_function("model_registry_list_100", |b| {
         b.iter(|| {
-            let models = registry.list_models();
+            let models = registry.list();
             black_box(models)
         })
     });
+
+    c.bench_function("model_registry_get", |b| {
+        b.iter(|| {
+            let model = registry.get(black_box("model-50"));
+            black_box(model)
+        })
+    });
+
+    c.bench_function("model_registry_infer_template", |b| {
+        b.iter(|| {
+            let template = registry.infer_template(black_box("llama-3-8b"));
+            black_box(template)
+        })
+    });
 }
 
 fn benchmark_safetensors_detection(c: &mut Criterion) {
diff --git a/src/api.rs b/src/api.rs
index 5b18e56..0481797 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -940,13 +940,11 @@ mod tests {
         }
 
         // Test with direct prompt (line 44)
-        let direct_prompt = Some("Direct prompt text".to_string());
-        let prompt = direct_prompt.unwrap_or_default();
+        let prompt = "Direct prompt text".to_string();
         assert_eq!(prompt, "Direct prompt text");
 
         // Test default case (line 44)
-        let no_prompt: Option<String> = None;
-        let prompt = no_prompt.unwrap_or_default();
+        let prompt = String::default();
         assert_eq!(prompt, "");
     }
 
diff --git a/src/engine/llama.rs b/src/engine/llama.rs
index d5cd2e8..7e73244 100644
--- a/src/engine/llama.rs
+++ b/src/engine/llama.rs
@@ -299,47 +299,49 @@ impl InferenceEngine for LlamaEngine {
             }
 
             // Attempt to load the model with better error handling
-            let model =
-                match llama::model::LlamaModel::load_from_file(&be, &spec.base_path, &model_params)
-                {
-                    Ok(model) => model,
-                    Err(e) => {
-                        // Check if this looks like a memory allocation failure
-                        let error_msg = format!("{}", e);
-                        if error_msg.contains("failed to allocate")
-                            || error_msg.contains("CPU_REPACK buffer")
-                        {
-                            let file_size = std::fs::metadata(&spec.base_path)
-                                .map(|m| m.len())
-                                .unwrap_or(0);
-                            let size_gb = file_size as f64 / 1_024_000_000.0;
+            let model = match llama::model::LlamaModel::load_from_file(
+                be,
+                &spec.base_path,
+                &model_params,
+            ) {
+                Ok(model) => model,
+                Err(e) => {
+                    // Check if this looks like a memory allocation failure
+                    let error_msg = format!("{}", e);
+                    if error_msg.contains("failed to allocate")
+                        || error_msg.contains("CPU_REPACK buffer")
+                    {
+                        let file_size = std::fs::metadata(&spec.base_path)
+                            .map(|m| m.len())
+                            .unwrap_or(0);
+                        let size_gb = file_size as f64 / 1_024_000_000.0;
 
-                            return Err(anyhow!(
-                                "Memory allocation failed for model {} ({:.1}GB). \n\
+                        return Err(anyhow!(
+                            "Memory allocation failed for model {} ({:.1}GB). \n\
                             💡 Possible solutions:\n\
                             • Use a smaller model (7B instead of 14B parameters)\n\
                             • Add more system RAM (model needs ~{}GB)\n\
                             • Enable model quantization (Q4_K_M, Q5_K_M)\n\
                             • MoE CPU offloading is temporarily disabled (Issue #108)\n\
                             Original error: {}",
-                                spec.base_path.display(),
-                                size_gb,
-                                (size_gb * 1.5) as u32, // Rough estimate of RAM needed
-                                e
-                            ));
-                        }
-
-                        // Re-throw other errors as-is
-                        return Err(e.into());
+                            spec.base_path.display(),
+                            size_gb,
+                            (size_gb * 1.5) as u32, // Rough estimate of RAM needed
+                            e
+                        ));
                     }
-                };
+
+                    // Re-throw other errors as-is
+                    return Err(e.into());
+                }
+            };
             let ctx_params = llama::context::params::LlamaContextParams::default()
                 .with_n_ctx(NonZeroU32::new(spec.ctx_len as u32))
                 .with_n_batch(2048)
                 .with_n_ubatch(512)
                 .with_n_threads(spec.n_threads.unwrap_or_else(get_optimal_thread_count))
                 .with_n_threads_batch(spec.n_threads.unwrap_or_else(get_optimal_thread_count));
-            let ctx_tmp = model.new_context(&be, ctx_params)?;
+            let ctx_tmp = model.new_context(be, ctx_params)?;
             if let Some(ref lora) = spec.lora_path {
                 // Check if it's a SafeTensors file and convert if needed
                 let lora_path = if lora.extension().and_then(|s| s.to_str()) == Some("safetensors")
diff --git a/src/invariant_ppt.rs b/src/invariant_ppt.rs
index 40c4b72..a3b8df8 100644
--- a/src/invariant_ppt.rs
+++ b/src/invariant_ppt.rs
@@ -84,6 +84,7 @@ pub fn contract_test(name: &str, required_invariants: &[&str]) {
 
 /// Exploration test helper - for temporary tests during development
 #[cfg(test)]
+#[allow(dead_code)]
 pub fn explore_test<F>(name: &str, test_fn: F)
 where
     F: Fn() -> bool,
@@ -127,6 +128,7 @@ pub fn checked_invariants() -> Vec<String> {
 
 /// Get all failed invariants
 #[cfg(test)]
+#[allow(dead_code)]
 pub fn failed_invariants() -> Vec<String> {
     match FAILED_INVARIANTS.lock() {
         Ok(failed) => failed.clone(),
@@ -140,6 +142,7 @@ pub mod shimmy_invariants {
 
     /// Model loading invariants
     #[cfg(test)]
+    #[allow(dead_code)]
     pub fn assert_model_loaded(model_name: &str, success: bool) {
         assert_invariant(
             !model_name.is_empty(),
@@ -158,6 +161,7 @@ pub mod shimmy_invariants {
 
     /// Generation invariants
     #[cfg(test)]
+    #[allow(dead_code)]
     pub fn assert_generation_valid(prompt: &str, response: &str) {
         assert_invariant(
             !prompt.is_empty(),
diff --git a/src/main.rs b/src/main.rs
index 5f27552..b39ff91 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1398,9 +1398,11 @@ mod tests {
         assert!(output.contains("max_tokens:"));
 
         // Test with different options
-        let mut opts = crate::engine::GenOptions::default();
-        opts.max_tokens = 150;
-        opts.temperature = 0.8;
+        let opts = crate::engine::GenOptions {
+            max_tokens: 150,
+            temperature: 0.8,
+            ..Default::default()
+        };
 
         let output = loaded.generate("Another test", opts, None).await.unwrap();
         assert!(output.contains("Another test"));
@@ -1677,7 +1679,8 @@ mod tests {
         // Verify test values are set
         for var in &test_vars {
             assert_eq!(
-                env::var(var).expect(&format!("Environment variable {} should be set", var)),
+                env::var(var)
+                    .unwrap_or_else(|_| panic!("Environment variable {} should be set", var)),
                 "/test/path"
             );
         }
diff --git a/src/server.rs b/src/server.rs
index c3a0dda..9ab210a 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -401,32 +401,31 @@ mod tests {
     #[test]
     fn test_gpu_detection_functions() {
         // Test that GPU detection functions return boolean values
-        let gpu_detected = detect_gpu();
-        assert!(gpu_detected == true || gpu_detected == false);
+        let _gpu_detected = detect_gpu();
+        // GPU detection either succeeds or fails - both are valid
 
         let vendor = get_gpu_vendor();
-        if vendor.is_some() {
-            let vendor_str = vendor.unwrap();
+        if let Some(vendor_str) = vendor {
             assert!(vendor_str == "nvidia" || vendor_str == "amd" || vendor_str == "intel");
         }
     }
 
     #[test]
     fn test_nvidia_detection() {
-        let result = detect_nvidia();
-        assert!(result == true || result == false);
+        let _result = detect_nvidia();
+        // NVIDIA detection either succeeds or fails - both are valid
     }
 
     #[test]
     fn test_amd_detection() {
-        let result = detect_amd();
-        assert!(result == true || result == false);
+        let _result = detect_amd();
+        // AMD detection either succeeds or fails - both are valid
     }
 
     #[test]
     fn test_intel_detection() {
-        let result = detect_intel();
-        assert!(result == true || result == false);
+        let _result = detect_intel();
+        // Intel detection either succeeds or fails - both are valid
     }
 
     #[tokio::test]
diff --git a/tests/anthropic_api_integration_test.rs b/tests/anthropic_api_integration_test.rs
index 0c95e10..574b460 100644
--- a/tests/anthropic_api_integration_test.rs
+++ b/tests/anthropic_api_integration_test.rs
@@ -11,7 +11,7 @@ fn test_anthropic_api_endpoint_exists() {
 
     // Build shimmy to ensure anthropic_compat module compiles
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--no-default-features",
             "--features",
diff --git a/tests/apple_silicon_detection_test.rs b/tests/apple_silicon_detection_test.rs
index 0fee3d1..fcf2fda 100644
--- a/tests/apple_silicon_detection_test.rs
+++ b/tests/apple_silicon_detection_test.rs
@@ -6,7 +6,6 @@
 /// Issue: User with Apple M3 Pro received "MLX Backend: Not available (requires Apple Silicon)"
 /// Root cause: check_mlx_availability() was checking for MLX Python packages instead of just hardware
 /// Solution: Separate hardware detection from software installation checks
-
 #[cfg(test)]
 mod apple_silicon_tests {
     #[cfg(feature = "mlx")]
@@ -113,6 +112,5 @@ mod apple_silicon_tests {
         println!("MLX Python packages detected: {}", python_available);
 
         // Test should pass whether MLX is installed or not
-        assert!(true, "Python detection should complete without panic");
     }
 }
diff --git a/tests/cli_integration_tests.rs b/tests/cli_integration_tests.rs
index 0a283c0..d693da1 100644
--- a/tests/cli_integration_tests.rs
+++ b/tests/cli_integration_tests.rs
@@ -26,7 +26,7 @@ fn test_llm_only_filtering() {
     // Test without filtering - should show all models
     let mut cmd_all = Command::cargo_bin("shimmy").unwrap();
     let output_all = cmd_all
-        .args(&["discover", &model_dirs_arg])
+        .args(["discover", &model_dirs_arg])
         .assert()
         .success();
 
@@ -35,7 +35,7 @@ fn test_llm_only_filtering() {
     // Test with LLM filtering - should filter out non-LLM models
     let mut cmd_filtered = Command::cargo_bin("shimmy").unwrap();
     let output_filtered = cmd_filtered
-        .args(&["discover", &model_dirs_arg, "--llm-only"])
+        .args(["discover", &model_dirs_arg, "--llm-only"])
         .assert()
         .success();
 
@@ -86,18 +86,18 @@ fn test_llm_only_filtering() {
 fn test_moe_cpu_offloading_flags() {
     // Test that MoE CPU flags are accepted without errors
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
-    cmd.args(&["--cpu-moe", "list"]).assert().success();
+    cmd.args(["--cpu-moe", "list"]).assert().success();
 
     // Test n-cpu-moe flag
     let mut cmd2 = Command::cargo_bin("shimmy").unwrap();
-    cmd2.args(&["--n-cpu-moe", "4", "list"]).assert().success();
+    cmd2.args(["--n-cpu-moe", "4", "list"]).assert().success();
 }
 
 #[test]
 fn test_moe_cpu_flags_conflict() {
     // Test that --cpu-moe and --n-cpu-moe conflict
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
-    cmd.args(&["--cpu-moe", "--n-cpu-moe", "4", "list"])
+    cmd.args(["--cpu-moe", "--n-cpu-moe", "4", "list"])
         .assert()
         .failure()
         .stderr(predicate::str::contains("cannot be used with"));
@@ -106,7 +106,7 @@ fn test_moe_cpu_flags_conflict() {
 #[test]
 fn test_discover_help_shows_llm_only() {
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
-    cmd.args(&["discover", "--help"])
+    cmd.args(["discover", "--help"])
         .assert()
         .success()
         .stdout(predicate::str::contains("--llm-only"))
@@ -118,7 +118,7 @@ fn test_threading_optimization_performance() {
     // Test that threading optimization is properly implemented
     // This is a regression test for Issue #101
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
-    cmd.args(&["--help"]).assert().success();
+    cmd.args(["--help"]).assert().success();
     // The fact that this doesn't hang or consume excessive CPU is the test
     // If threading was broken, this would cause issues
 }
@@ -128,7 +128,7 @@ fn test_streaming_functionality() {
     // Test that streaming functionality is available
     // This is a regression test for Issue #101
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
-    cmd.args(&["serve", "--help"])
+    cmd.args(["serve", "--help"])
         .assert()
         .success()
         .stdout(predicate::str::contains("HTTP server")); // Verify server can start
@@ -145,7 +145,7 @@ fn test_ollama_models_environment_variable() {
 
     let mut cmd = Command::cargo_bin("shimmy").unwrap();
     cmd.env("OLLAMA_MODELS", &test_path)
-        .args(&["list"])
+        .args(["list"])
         .assert()
         .success(); // Should not crash when OLLAMA_MODELS is set
 }
@@ -160,7 +160,7 @@ fn test_windows_server_stability_issue_106() {
 
     // Test that server can start without crashing on Windows
     // Instead of spawning and killing, just test that server help works
-    cmd.args(&["serve", "--help"])
+    cmd.args(["serve", "--help"])
         .assert()
         .success()
         .stdout(predicate::str::contains("HTTP server")); // Verify server command exists
diff --git a/tests/compilation_regression_test.rs b/tests/compilation_regression_test.rs
index 1d4906c..3d4f37a 100644
--- a/tests/compilation_regression_test.rs
+++ b/tests/compilation_regression_test.rs
@@ -4,8 +4,7 @@
 /// - Issue #59: CUDA compilation errors (cudart_static not found)
 /// - Issue #58: GPU capabilities in prebuilt binaries
 /// - General compilation robustness
-/// - Feature flag combinations
-
+// - Feature flag combinations
 #[test]
 fn test_feature_compilation_compatibility() {
     // Test that different feature combinations can be compiled
@@ -17,31 +16,26 @@ fn test_feature_compilation_compatibility() {
         // If we can create an adapter, the feature is working
         use shimmy::engine::adapter::InferenceEngineAdapter;
         let _adapter = InferenceEngineAdapter::new();
-        assert!(true, "LLAMA feature should compile successfully");
     }
 
     #[cfg(feature = "huggingface")]
     {
         // Test that huggingface feature compiles without issues
-        assert!(true, "HuggingFace feature should compile successfully");
     }
 
     #[cfg(feature = "llama-cuda")]
     {
         // Test that CUDA feature compiles (may not be available at runtime)
-        assert!(true, "CUDA feature should compile successfully");
     }
 
     #[cfg(feature = "llama-vulkan")]
     {
         // Test that Vulkan feature compiles
-        assert!(true, "Vulkan feature should compile successfully");
     }
 
     #[cfg(feature = "llama-opencl")]
     {
         // Test that OpenCL feature compiles
-        assert!(true, "OpenCL feature should compile successfully");
     }
 }
 
@@ -87,7 +81,6 @@ fn test_inference_engine_adapter_creation() {
 
     // Basic checks that the adapter is functional
     // We can't test actual inference without models, but we can test creation
-    assert!(true, "InferenceEngineAdapter should create successfully");
 
     // Test that we can call basic methods without panicking
     drop(adapter); // Ensure cleanup works
@@ -131,7 +124,6 @@ fn test_library_dependencies_available() {
     let _router: Router = Router::new();
 
     // Test that basic operations work
-    assert!(true, "Core dependencies should be functional");
 }
 
 #[test]
@@ -190,7 +182,7 @@ fn test_cargo_build_environment_compatibility() {
     assert_eq!(name, "shimmy", "Package name should be correct");
 
     // These should be available during build
-    assert!(version.len() > 0, "Version string should not be empty");
+    assert!(!version.is_empty(), "Version string should not be empty");
 }
 
 #[test]
@@ -216,7 +208,6 @@ fn test_memory_usage_basic_operations() {
     }
 
     // If we get here without running out of memory, basic memory management is working
-    assert!(true, "Basic memory management should work correctly");
 }
 
 #[test]
@@ -254,13 +245,11 @@ mod conditional_tests {
         let adapter = InferenceEngineAdapter::new();
         // If this compiles and runs, llama integration is working
         drop(adapter);
-        assert!(true, "Llama feature should work correctly");
     }
 
     #[cfg(feature = "huggingface")]
     #[test]
     fn test_huggingface_specific_functionality() {
         // Test huggingface-specific code paths
-        assert!(true, "HuggingFace feature should work correctly");
     }
 }
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
index e8406ce..4919907 100644
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -55,7 +55,7 @@ async fn test_http_api_health_check() {
         .unwrap();
 
     let response = client
-        .get(&format!("{}/health", base_url))
+        .get(format!("{}/health", base_url))
         .send()
         .await
         .unwrap();
@@ -181,7 +181,7 @@ async fn test_concurrent_requests() {
         let base_url = base_url.clone();
         let handle = tokio::spawn(async move {
             let response = client
-                .get(&format!("{}/health", base_url))
+                .get(format!("{}/health", base_url))
                 .send()
                 .await
                 .unwrap();
diff --git a/tests/openai_api_real_tests.rs b/tests/openai_api_real_tests.rs
index cdd2c66..8697a8e 100644
--- a/tests/openai_api_real_tests.rs
+++ b/tests/openai_api_real_tests.rs
@@ -11,7 +11,6 @@ use std::sync::Arc;
 
 /// Real functional tests for Open WebUI and AnythingLLM compatibility
 /// These tests actually call the API functions and verify responses
-
 fn setup_test_state_with_models() -> Arc<AppState> {
     let mut registry = Registry::default();
 
diff --git a/tests/regression.rs b/tests/regression.rs
index d188f5f..7286402 100644
--- a/tests/regression.rs
+++ b/tests/regression.rs
@@ -3,8 +3,7 @@
 /// This module includes all individual regression test files from tests/regression/
 /// Each file tests a specific user-reported issue to prevent regressions.
 ///
-/// Auto-discovered by CI/CD - just add new issue_NNN_*.rs files to tests/regression/
-
+// Auto-discovered by CI/CD - just add new issue_NNN_*.rs files to tests/regression/
 // Include all individual regression test modules (only files that exist)
 #[path = "regression/issue_012_custom_model_dirs.rs"]
 mod issue_012_custom_model_dirs;
diff --git a/tests/regression/issue_012_custom_model_dirs.rs b/tests/regression/issue_012_custom_model_dirs.rs
index 459c4cf..fa796a0 100644
--- a/tests/regression/issue_012_custom_model_dirs.rs
+++ b/tests/regression/issue_012_custom_model_dirs.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: Custom model directory environment variables not being detected
 /// **Fix**: Added proper environment variable parsing and directory validation
-/// **This test**: Verifies custom directory detection via env vars
-
+// **This test**: Verifies custom directory detection via env vars
 #[cfg(test)]
 mod issue_012_tests {
     use shimmy::discovery::discover_models_from_directory;
diff --git a/tests/regression/issue_013_qwen_template.rs b/tests/regression/issue_013_qwen_template.rs
index 9049e67..4973808 100644
--- a/tests/regression/issue_013_qwen_template.rs
+++ b/tests/regression/issue_013_qwen_template.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: Qwen/Qwen2.5-Coder models weren't being detected and assigned proper templates
 /// **Fix**: Added Qwen family detection in template inference logic
-/// **This test**: Verifies Qwen models get correct ChatML-based templates
-
+// **This test**: Verifies Qwen models get correct ChatML-based templates
 #[cfg(test)]
 mod issue_013_tests {
     use shimmy::model_registry::Registry;
diff --git a/tests/regression/issue_051_lmstudio_discovery.rs b/tests/regression/issue_051_lmstudio_discovery.rs
index a1f9712..c8f0080 100644
--- a/tests/regression/issue_051_lmstudio_discovery.rs
+++ b/tests/regression/issue_051_lmstudio_discovery.rs
@@ -224,23 +224,23 @@ fn test_model_discovery_error_handling() {
     let result = discover_models_from_directory(&non_existent);
 
     // Should handle gracefully (either return empty list or error, but not panic)
-    match result {
-        Ok(models) => assert!(
+    if let Ok(models) = result {
+        assert!(
             models.is_empty(),
             "Non-existent directory should return empty list"
-        ),
-        Err(_) => (), // Error is also acceptable
+        );
     }
+    // Error is also acceptable
 
     // Test with file instead of directory
     let temp_file = tempfile::NamedTempFile::new().unwrap();
     let result = discover_models_from_directory(temp_file.path());
 
     // Should handle gracefully
-    match result {
-        Ok(models) => assert!(models.is_empty(), "File path should return empty list"),
-        Err(_) => (), // Error is also acceptable
+    if let Ok(models) = result {
+        assert!(models.is_empty(), "File path should return empty list");
     }
+    // Error is also acceptable
 }
 
 #[test]
diff --git a/tests/regression/issue_063_version_mismatch.rs b/tests/regression/issue_063_version_mismatch.rs
index 1b8d834..1599d0d 100644
--- a/tests/regression/issue_063_version_mismatch.rs
+++ b/tests/regression/issue_063_version_mismatch.rs
@@ -30,7 +30,7 @@ fn test_binary_version_matches_cargo_toml() {
     // Each part should be a valid number
     for part in &parts[0..3] {
         part.parse::<u32>()
-            .expect(&format!("Version part '{}' should be a valid number", part));
+            .unwrap_or_else(|_| panic!("Version part '{}' should be a valid number", part));
     }
 }
 
@@ -81,7 +81,6 @@ fn test_version_flag_functionality() {
 
     // The important thing is that the CLI is configured to handle version flags
     // If this test runs without panicking, the version infrastructure is working
-    assert!(true, "Version flag infrastructure should be available");
 }
 
 #[test]
@@ -90,7 +89,7 @@ fn test_cargo_pkg_version_environment_variable() {
     let version = env!("CARGO_PKG_VERSION");
 
     // Should match the pattern of a real version
-    assert!(version.len() > 0, "CARGO_PKG_VERSION should not be empty");
+    assert!(!version.is_empty(), "CARGO_PKG_VERSION should not be empty");
 
     // Should not contain any build artifacts that could cause issues
     assert!(
@@ -205,9 +204,12 @@ fn test_version_consistency_across_codebase() {
     );
 
     // First two parts should be numeric
-    for i in 0..2.min(version_parts.len()) {
-        version_parts[i]
-            .parse::<u32>()
-            .expect(&format!("Version component {} should be numeric", i));
+    for (i, part) in version_parts
+        .iter()
+        .enumerate()
+        .take(2.min(version_parts.len()))
+    {
+        part.parse::<u32>()
+            .unwrap_or_else(|_| panic!("Version component {} should be numeric", i));
     }
 }
diff --git a/tests/regression/issue_068_mlx_support.rs b/tests/regression/issue_068_mlx_support.rs
index b827072..3cdc8e8 100644
--- a/tests/regression/issue_068_mlx_support.rs
+++ b/tests/regression/issue_068_mlx_support.rs
@@ -8,7 +8,7 @@ use std::process::Command;
 fn test_mlx_feature_compilation() {
     // Test that MLX feature can be compiled
     let output = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "mlx"])
+        .args(["check", "--no-default-features", "--features", "mlx"])
         .output()
         .expect("Failed to run cargo check with mlx feature");
 
@@ -32,7 +32,7 @@ fn test_apple_feature_set_compilation() {
     }
 
     let output = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "apple"])
+        .args(["check", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to run cargo check with apple feature set");
 
@@ -55,7 +55,7 @@ fn test_gpu_info_with_mlx_compiled() {
 
     // Build with apple features and test gpu-info output (debug build for speed)
     let build_output = Command::new("cargo")
-        .args(&["build", "--no-default-features", "--features", "apple"])
+        .args(["build", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to build with apple features");
 
@@ -128,7 +128,7 @@ fn test_regression_issue_68_scenarios() {
     // Scenario 1: cargo install with MLX should work (template compilation)
     // We test compilation rather than full install for speed
     let mlx_compile_test = Command::new("cargo")
-        .args(&["check", "--features", "mlx"])
+        .args(["check", "--features", "mlx"])
         .output()
         .expect("Failed to check MLX compilation");
 
@@ -140,7 +140,7 @@ fn test_regression_issue_68_scenarios() {
     // Scenario 2: macOS binaries should include MLX support
     // Test that apple feature set includes MLX
     let apple_features_test = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "apple"])
+        .args(["check", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to check apple features");
 
@@ -158,7 +158,7 @@ fn test_ci_build_matrix_features() {
 
     // Test Linux features
     let linux_test = Command::new("cargo")
-        .args(&[
+        .args([
             "check",
             "--no-default-features",
             "--features",
@@ -174,7 +174,7 @@ fn test_ci_build_matrix_features() {
 
     // Test macOS features (the fix for Issue #68)
     let macos_test = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "apple"])
+        .args(["check", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to check macOS features");
 
@@ -192,7 +192,7 @@ fn test_mlx_status_messages_comprehensive() {
 
     // Test apple feature set includes MLX
     let apple_test = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "apple"])
+        .args(["check", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to check apple features");
 
@@ -203,7 +203,7 @@ fn test_mlx_status_messages_comprehensive() {
 
     // Test that mlx feature alone works
     let mlx_only_test = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "mlx"])
+        .args(["check", "--no-default-features", "--features", "mlx"])
         .output()
         .expect("Failed to check mlx feature alone");
 
@@ -225,7 +225,7 @@ fn test_mlx_binary_status_messages() {
 
     // Build binary with apple features (includes MLX) - debug build for speed
     let build_output = Command::new("cargo")
-        .args(&["build", "--no-default-features", "--features", "apple"])
+        .args(["build", "--no-default-features", "--features", "apple"])
         .output()
         .expect("Failed to build with apple features");
 
@@ -306,7 +306,7 @@ fn test_mlx_regression_prevention() {
 
     // 3. Test that MLX feature compiles without errors
     let mlx_check = Command::new("cargo")
-        .args(&["check", "--features", "mlx"])
+        .args(["check", "--features", "mlx"])
         .output()
         .expect("Failed to run cargo check with mlx");
 
@@ -333,7 +333,7 @@ mod integration_tests {
 
         // Full integration test: build and run with apple features (debug for speed)
         let build_result = Command::new("cargo")
-            .args(&["build", "--no-default-features", "--features", "apple"])
+            .args(["build", "--no-default-features", "--features", "apple"])
             .output()
             .expect("Failed to build with apple features");
 
diff --git a/tests/regression/issue_072_gpu_backend_flag.rs b/tests/regression/issue_072_gpu_backend_flag.rs
index a119534..5e6fd5e 100644
--- a/tests/regression/issue_072_gpu_backend_flag.rs
+++ b/tests/regression/issue_072_gpu_backend_flag.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: --gpu-backend flag was parsed but not actually wired into model loading
 /// **Fix**: Properly pass GPU backend selection through to llama.cpp initialization
-/// **This test**: Verifies GPU backend flag is respected in model loading path
-
+// **This test**: Verifies GPU backend flag is respected in model loading path
 #[cfg(test)]
 mod issue_072_tests {
     use shimmy::engine::ModelSpec;
diff --git a/tests/regression/issue_101_performance_fixes.rs b/tests/regression/issue_101_performance_fixes.rs
index c2eabe8..620e91a 100644
--- a/tests/regression/issue_101_performance_fixes.rs
+++ b/tests/regression/issue_101_performance_fixes.rs
@@ -9,7 +9,6 @@
 ///
 /// **Fixes**: Smart threading, fixed SSE streaming, added OLLAMA_MODELS support
 /// **This test**: Verifies all three fixes remain working
-
 #[cfg(test)]
 mod issue_101_tests {
     use std::env;
diff --git a/tests/regression/issue_106_windows_crash.rs b/tests/regression/issue_106_windows_crash.rs
index 8850c84..8b84650 100644
--- a/tests/regression/issue_106_windows_crash.rs
+++ b/tests/regression/issue_106_windows_crash.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: Server crashes on Windows when handling certain requests
 /// **Fix**: Added proper error handling and Windows-specific compatibility
-/// **This test**: Verifies Windows server stability
-
+// **This test**: Verifies Windows server stability
 #[cfg(test)]
 mod issue_106_tests {
     #[test]
@@ -16,14 +15,12 @@ mod issue_106_tests {
         #[cfg(target_os = "windows")]
         {
             // Windows-specific test
-            assert!(true, "Windows server initialization should not crash");
             println!("✅ Issue #106: Windows server stability verified");
         }
 
         #[cfg(not(target_os = "windows"))]
         {
             // Test still passes on other platforms
-            assert!(true, "Cross-platform compatibility maintained");
             println!("✅ Issue #106: Cross-platform test passed (not Windows)");
         }
     }
@@ -34,7 +31,6 @@ mod issue_106_tests {
         // Issue #106 was caused by uncaught panics
 
         // Verify panic handling infrastructure exists
-        assert!(true, "Error handling should prevent crashes");
         println!("✅ Issue #106: Server error handling present");
     }
 }
diff --git a/tests/regression/issue_108_memory_allocation.rs b/tests/regression/issue_108_memory_allocation.rs
index b678467..62b94a8 100644
--- a/tests/regression/issue_108_memory_allocation.rs
+++ b/tests/regression/issue_108_memory_allocation.rs
@@ -36,7 +36,7 @@ fn test_moe_disabled_warning_compilation() {
 
     // This test ensures the warning system compiles correctly
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--no-default-features",
             "--features",
@@ -85,7 +85,7 @@ fn test_issue_108_cli_flags_still_work() {
     // Regression test: Ensure --cpu-moe and --n-cpu-moe flags still exist and parse
 
     let help_output = Command::new("cargo")
-        .args(&[
+        .args([
             "run",
             "--bin",
             "shimmy",
diff --git a/tests/regression/issue_110_crates_io_build.rs b/tests/regression/issue_110_crates_io_build.rs
index 054fc27..d99e1c6 100644
--- a/tests/regression/issue_110_crates_io_build.rs
+++ b/tests/regression/issue_110_crates_io_build.rs
@@ -10,7 +10,7 @@ use std::process::Command;
 fn test_template_files_included_in_package() {
     // Regression test for Issue #110 - Missing template files
     let output = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package --list");
 
@@ -53,7 +53,7 @@ fn test_llama_cpp_dependency_compatibility() {
     // This test verifies that our usage of llama-cpp-2 APIs is compatible
     // by compiling the llama engine module specifically
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--no-default-features",
             "--features",
@@ -95,7 +95,7 @@ fn test_crates_io_package_builds_successfully() {
 
     // First test: Package creation succeeds
     let package_output = Command::new("cargo")
-        .args(&["package", "--allow-dirty"])
+        .args(["package", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package");
 
@@ -108,7 +108,7 @@ fn test_crates_io_package_builds_successfully() {
     // Second test: Package verification builds successfully
     // (This runs the same verification that crates.io would run)
     let verify_output = Command::new("cargo")
-        .args(&["package", "--allow-dirty", "--no-verify"])
+        .args(["package", "--allow-dirty", "--no-verify"])
         .output()
         .expect("Failed to run cargo package verification");
 
@@ -127,7 +127,7 @@ fn test_no_missing_include_str_files() {
 
     // Build with the exact features that would be used by cargo install
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--release",
             "--no-default-features",
@@ -175,7 +175,7 @@ fn test_issue_110_user_experience_simulation() {
 
     // Step 1: Verify package can be listed (simulates crates.io publishing check)
     let package_result = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to simulate package validation");
 
@@ -188,7 +188,7 @@ fn test_issue_110_user_experience_simulation() {
     // Step 2: Verify all template files are accessible
     // (simulates the include_str! calls during compilation)
     let build_result = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--quiet",
             "--no-default-features",
diff --git a/tests/regression/issue_111_gpu_metrics.rs b/tests/regression/issue_111_gpu_metrics.rs
index 7bae01b..afea194 100644
--- a/tests/regression/issue_111_gpu_metrics.rs
+++ b/tests/regression/issue_111_gpu_metrics.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: GPU metrics (gpu_detected, gpu_vendor) missing from /metrics endpoint
 /// **Fix**: Added GPU detection and metrics to /metrics response
-/// **This test**: Verifies GPU metrics are included in metrics endpoint
-
+// **This test**: Verifies GPU metrics are included in metrics endpoint
 #[cfg(test)]
 mod issue_111_tests {
     use shimmy::engine::adapter::InferenceEngineAdapter;
@@ -20,7 +19,6 @@ mod issue_111_tests {
         let _state = Arc::new(shimmy::AppState::new(engine, registry));
 
         // This should not panic and should include GPU detection capability
-        assert!(true, "GPU detection functions should not crash");
 
         println!("✅ Issue #111: GPU metrics infrastructure present");
     }
@@ -33,7 +31,6 @@ mod issue_111_tests {
         // - gpu_vendor: string | null
 
         // This test verifies the infrastructure exists
-        assert!(true, "GPU detection should return valid types");
 
         println!("✅ Issue #111: GPU detection returns valid values");
     }
@@ -48,8 +45,6 @@ mod issue_111_tests {
         // - gpu_vendor: string or null
         // - Fields are properly typed (not strings when should be boolean)
 
-        assert!(true, "Metrics endpoint should have GPU field support");
-
         println!("✅ Issue #111: Metrics endpoint GPU fields verified");
     }
 }
diff --git a/tests/regression/issue_112_safetensors_engine.rs b/tests/regression/issue_112_safetensors_engine.rs
index 6a563f2..9cc5e4c 100644
--- a/tests/regression/issue_112_safetensors_engine.rs
+++ b/tests/regression/issue_112_safetensors_engine.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: SafeTensors files (.safetensors) were routed to wrong engine (HuggingFace instead of SafeTensors)
 /// **Fix**: Added proper file extension detection to route .safetensors to SafeTensors engine
-/// **This test**: Verifies SafeTensors files use correct engine
-
+// **This test**: Verifies SafeTensors files use correct engine
 #[cfg(test)]
 mod issue_112_tests {
     use shimmy::engine::adapter::InferenceEngineAdapter;
diff --git a/tests/regression/issue_113_openai_api.rs b/tests/regression/issue_113_openai_api.rs
index e4d51e2..1223b16 100644
--- a/tests/regression/issue_113_openai_api.rs
+++ b/tests/regression/issue_113_openai_api.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: OpenAI API responses missing fields required by frontend frameworks
 /// **Fix**: Enhanced Model structure with permission, root, parent fields
-/// **This test**: Verifies OpenAI API response structure matches spec
-
+// **This test**: Verifies OpenAI API response structure matches spec
 #[cfg(test)]
 mod issue_113_tests {
     use shimmy::openai_compat::{Model, ModelsResponse};
diff --git a/tests/regression/issue_114_mlx_distribution.rs b/tests/regression/issue_114_mlx_distribution.rs
index 803e3d7..4052b3f 100644
--- a/tests/regression/issue_114_mlx_distribution.rs
+++ b/tests/regression/issue_114_mlx_distribution.rs
@@ -4,8 +4,7 @@
 ///
 /// **Bug**: MLX feature not properly defined in distribution builds
 /// **Fix**: Added mlx feature flag and apple convenience feature
-/// **This test**: Verifies MLX feature is properly configured
-
+// **This test**: Verifies MLX feature is properly configured
 #[cfg(test)]
 mod issue_114_tests {
     #[test]
@@ -13,13 +12,11 @@ mod issue_114_tests {
         // Test that MLX feature compiles when enabled
         #[cfg(feature = "mlx")]
         {
-            assert!(true, "MLX feature should be available when enabled");
             println!("✅ Issue #114: MLX feature enabled and working");
         }
 
         #[cfg(not(feature = "mlx"))]
         {
-            assert!(true, "MLX feature correctly disabled when not specified");
             println!("✅ Issue #114: MLX feature correctly optional");
         }
     }
@@ -58,7 +55,6 @@ mod issue_114_tests {
         #[cfg(feature = "mlx")]
         {
             // MLX code should compile cleanly
-            assert!(true, "MLX distribution build should succeed");
         }
 
         // Test passes regardless of feature flag state
diff --git a/tests/regression/issue_128_backend_reinitialization.rs b/tests/regression/issue_128_backend_reinitialization.rs
index 4a59798..c819812 100644
--- a/tests/regression/issue_128_backend_reinitialization.rs
+++ b/tests/regression/issue_128_backend_reinitialization.rs
@@ -6,7 +6,6 @@
 /// **Root Cause**: llama.cpp backend was initialized on every model load
 /// **Fix**: Use global OnceLock singleton to initialize backend once per process
 /// **This test**: Verifies the backend singleton pattern is implemented correctly
-
 #[cfg(feature = "llama")]
 #[test]
 fn test_issue_128_backend_singleton_exists() {
@@ -20,8 +19,6 @@ fn test_issue_128_backend_singleton_exists() {
     // - OnceLock<Result<LlamaBackend, String>> is defined
     // - get_or_init_backend() uses get_or_init() not get_or_try_init()
     // - Multiple calls to load() won't re-initialize the backend
-
-    assert!(true, "Backend singleton pattern is implemented");
 }
 
 #[cfg(not(feature = "llama"))]
diff --git a/tests/regression/issue_packaging_general.rs b/tests/regression/issue_packaging_general.rs
index b4eb44c..58a8ac4 100644
--- a/tests/regression/issue_packaging_general.rs
+++ b/tests/regression/issue_packaging_general.rs
@@ -15,7 +15,7 @@ use std::str;
 fn test_crates_io_package_includes_all_required_files() {
     // Run cargo package --list to get the exact file list that would be uploaded to crates.io
     let output = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package --list");
 
@@ -148,7 +148,7 @@ fn test_cargo_install_simulation() {
 
     // This test ensures that a fresh cargo install would succeed
     let output = Command::new("cargo")
-        .args(&["check", "--quiet"])
+        .args(["check", "--quiet"])
         .output()
         .expect("Failed to run cargo check");
 
@@ -184,7 +184,7 @@ fn test_cargo_install_simulation() {
 fn test_package_size_sanity() {
     // Ensure the package isn't suspiciously small (which would indicate missing files)
     let output = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package --list");
 
@@ -215,7 +215,7 @@ fn test_shimmy_llama_cpp_fork_packages_available() {
 
     // Check if we can build with our published shimmy packages
     let output = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "llama"])
+        .args(["check", "--no-default-features", "--features", "llama"])
         .output()
         .expect("Failed to run cargo check with llama feature");
 
@@ -249,7 +249,7 @@ fn test_template_packaging_gate_protection() {
     // to ensure our packaging follows the gate requirements
 
     let output = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package --list");
 
diff --git a/tests/regression/issue_version_validation.rs b/tests/regression/issue_version_validation.rs
index 5fa8fff..308a5f0 100644
--- a/tests/regression/issue_version_validation.rs
+++ b/tests/regression/issue_version_validation.rs
@@ -38,7 +38,7 @@ fn test_cargo_toml_version_format() {
     // Each part should be numeric (for the first 3 parts)
     for (i, part) in parts.iter().take(3).enumerate() {
         part.parse::<u32>()
-            .expect(&format!("Version part {} should be numeric: {}", i, part));
+            .unwrap_or_else(|_| panic!("Version part {} should be numeric: {}", i, part));
     }
 
     println!("✅ Cargo.toml version format is valid: {}", version);
@@ -110,7 +110,7 @@ fn test_version_validation_script_simulation() {
 fn test_binary_version_output() {
     // Build and test the binary version output
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--release",
             "--no-default-features",
diff --git a/tests/regression_tests.rs b/tests/regression_tests.rs
index a7ffea9..5a39018 100644
--- a/tests/regression_tests.rs
+++ b/tests/regression_tests.rs
@@ -272,7 +272,7 @@ mod regression_tests {
         // But we can test that the GPU detection functions work
 
         // Test that GPU detection functions return valid boolean values
-        assert!(true); // GPU detection should not crash
+        // GPU detection functions executed without panicking (test passes if we reach here)
 
         // In a real test environment, we would test:
         // 1. GET /metrics returns JSON with gpu_detected field
@@ -368,13 +368,11 @@ mod regression_tests {
         #[cfg(feature = "mlx")]
         {
             // MLX feature is enabled - test that MLX-related code compiles
-            assert!(true, "MLX feature should be available when enabled");
         }
 
         #[cfg(not(feature = "mlx"))]
         {
             // MLX feature is disabled - that's also valid
-            assert!(true, "MLX feature correctly disabled when not specified");
         }
 
         // Test that Cargo.toml includes MLX feature definition
diff --git a/tests/release_gate_integration.rs b/tests/release_gate_integration.rs
index f60993c..c34abc0 100644
--- a/tests/release_gate_integration.rs
+++ b/tests/release_gate_integration.rs
@@ -67,7 +67,7 @@ fn test_conditional_execution_logic() {
 fn test_gate_1_core_build_validation() {
     // Test that core build (huggingface features) works
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--release",
             "--no-default-features",
@@ -88,7 +88,7 @@ fn test_gate_1_core_build_validation() {
 fn test_gate_3_template_packaging_protection() {
     // Test that templates are properly included (Issue #60 protection)
     let output = Command::new("cargo")
-        .args(&["package", "--list", "--allow-dirty"])
+        .args(["package", "--list", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo package --list");
 
@@ -115,7 +115,7 @@ fn test_gate_3_template_packaging_protection() {
 fn test_gate_4_binary_size_constitutional_limit() {
     // First ensure we have a binary to test (debug build for speed)
     let build_output = Command::new("cargo")
-        .args(&[
+        .args([
             "build",
             "--no-default-features",
             "--features",
@@ -156,7 +156,7 @@ fn test_gate_5_test_suite_validation() {
     // Validate that test suite can be compiled and basic tests pass
     // Note: We run a more limited test to avoid circular dependency issues
     let output = Command::new("cargo")
-        .args(&["test", "--no-run", "--lib"])
+        .args(["test", "--no-run", "--lib"])
         .output()
         .expect("Failed to compile test suite");
 
@@ -168,7 +168,7 @@ fn test_gate_5_test_suite_validation() {
 
     // Additional validation: Ensure we can run a simple test
     let simple_test = Command::new("cargo")
-        .args(&["test", "--lib", "test_model_spec_validation"])
+        .args(["test", "--lib", "test_model_spec_validation"])
         .output()
         .expect("Failed to run simple test");
 
@@ -185,7 +185,7 @@ fn test_gate_5_test_suite_validation() {
 fn test_gate_6_documentation_validation() {
     // Test that documentation builds successfully
     let output = Command::new("cargo")
-        .args(&[
+        .args([
             "doc",
             "--no-deps",
             "--no-default-features",
@@ -222,7 +222,7 @@ fn test_gate_2_cuda_timeout_detection() {
     let start = Instant::now();
 
     let output = Command::new("cargo")
-        .args(&["check", "--no-default-features", "--features", "llama"])
+        .args(["check", "--no-default-features", "--features", "llama"])
         .output();
 
     let duration = start.elapsed();
@@ -267,7 +267,7 @@ fn test_gate_2_cuda_timeout_detection() {
 fn test_gate_7_cratesio_validation() {
     // Test that crates.io dry-run validation works
     let output = Command::new("cargo")
-        .args(&["publish", "--dry-run", "--allow-dirty"])
+        .args(["publish", "--dry-run", "--allow-dirty"])
         .output()
         .expect("Failed to run cargo publish --dry-run");
 
diff --git a/tests/template_compilation_regression_test.rs b/tests/template_compilation_regression_test.rs
index c757101..4ad53b7 100644
--- a/tests/template_compilation_regression_test.rs
+++ b/tests/template_compilation_regression_test.rs
@@ -78,7 +78,8 @@ fn test_docker_template_contains_required_files() {
         );
 
         // Verify file is not empty (template content was included)
-        let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
+        let content =
+            fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
         assert!(
             !content.trim().is_empty(),
             "{} should contain template content, not be empty",
@@ -111,7 +112,8 @@ fn test_kubernetes_template_contains_required_files() {
         );
 
         // Verify file contains YAML content
-        let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
+        let content =
+            fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
         assert!(
             content.contains("apiVersion") || content.contains("kind"),
             "{} should contain valid Kubernetes YAML content",
@@ -141,7 +143,8 @@ fn test_fastapi_template_contains_required_files() {
         );
 
         // Verify file contains expected content
-        let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
+        let content =
+            fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
 
         if file == "main.py" {
             assert!(
@@ -178,7 +181,8 @@ fn test_express_template_contains_required_files() {
         );
 
         // Verify file contains expected content
-        let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
+        let content =
+            fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
 
         if file == "app.js" {
             assert!(
diff --git a/tests/workflow_tests.rs b/tests/workflow_tests.rs
index 42635f1..24d161e 100644
--- a/tests/workflow_tests.rs
+++ b/tests/workflow_tests.rs
@@ -27,8 +27,7 @@ mod tests {
         let rt = tokio::runtime::Runtime::new().unwrap();
         let result = rt.block_on(engine.execute_workflow(request));
         // Empty workflow might succeed but requesting output from non-existent step should fail
-        if result.is_ok() {
-            let workflow_result = result.unwrap();
+        if let Ok(workflow_result) = result {
             assert!(
                 !workflow_result.success,
                 "Workflow should fail with non-existent output step"