cargo fmt

Author: andrewgazelka

cargo-nextest/src/dispatch.rs

@@ -54,7 +54,7 @@ use std::{
     env::VarError,
     fmt,
     io::{Cursor, Write},
-    sync::{Arc, OnceLock, Mutex},
+    sync::{Arc, Mutex, OnceLock},
 };
 use swrite::{SWrite, swrite};
 use tracing::{Level, debug, info, warn};
@@ -660,7 +660,12 @@ impl TestBuildFilter {
         .map_err(|err| ExpectedError::CreateTestListError { err })
     }
 
-    fn make_test_filter_builder(&self, filter_exprs: Vec<Filterset>, profile_name: &str, profile: &EarlyProfile<'_>) -> Result<TestFilterBuilder> {
+    fn make_test_filter_builder(
+        &self,
+        filter_exprs: Vec<Filterset>,
+        profile_name: &str,
+        profile: &EarlyProfile<'_>,
+    ) -> Result<TestFilterBuilder> {
         // Merge the test binary args into the patterns.
         let mut run_ignored = self.run_ignored.map(Into::into);
         let mut patterns = TestFilterPatterns::new(self.pre_double_dash_filters.clone());
@@ -669,22 +674,30 @@ impl TestBuildFilter {
         // Handle --last-failed and --failed-last options
         if self.last_failed || self.failed_last {
             use nextest_runner::reporter::last_failed::FailedTestStore;
-            
+
             let store = FailedTestStore::new(profile.store_dir(), profile_name);
             match store.load() {
                 Ok(Some(snapshot)) => {
                     if snapshot.failed_tests.is_empty() {
-                        eprintln!("No failed tests found from previous run for profile '{}'", profile_name);
+                        eprintln!(
+                            "No failed tests found from previous run for profile '{}'",
+                            profile_name
+                        );
                         if self.last_failed {
                             // For --last-failed with no failed tests, we should run no tests
                             // Create a pattern that matches nothing
                             patterns = TestFilterPatterns::default();
-                            patterns.add_exact_pattern("__nextest_internal_no_tests_to_run__".to_string());
+                            patterns.add_exact_pattern(
+                                "__nextest_internal_no_tests_to_run__".to_string(),
+                            );
                         }
                         // For --failed-last, we continue with the normal filtering
                     } else {
-                        eprintln!("Found {} failed test(s) from previous run", snapshot.failed_tests.len());
-                        
+                        eprintln!(
+                            "Found {} failed test(s) from previous run",
+                            snapshot.failed_tests.len()
+                        );
+
                         if self.last_failed {
                             // Only run failed tests - replace all patterns
                             patterns = TestFilterPatterns::default();
@@ -705,7 +718,8 @@ impl TestBuildFilter {
                     if self.last_failed {
                         // For --last-failed with no history, run no tests
                         patterns = TestFilterPatterns::default();
-                        patterns.add_exact_pattern("__nextest_internal_no_tests_to_run__".to_string());
+                        patterns
+                            .add_exact_pattern("__nextest_internal_no_tests_to_run__".to_string());
                     }
                 }
                 Err(err) => {
@@ -1718,7 +1732,9 @@ impl App {
             }
         });
         let filter_exprs = self.build_filtering_expressions(&pcx)?;
-        let test_filter_builder = self.build_filter.make_test_filter_builder(filter_exprs, profile_name, &profile)?;
+        let test_filter_builder =
+            self.build_filter
+                .make_test_filter_builder(filter_exprs, profile_name, &profile)?;
 
         let binary_list = self.base.build_binary_list()?;
 
@@ -1796,7 +1812,9 @@ impl App {
         let settings = ShowTestGroupSettings { mode, show_default };
 
         let filter_exprs = self.build_filtering_expressions(&pcx)?;
-        let test_filter_builder = self.build_filter.make_test_filter_builder(filter_exprs, profile_name, &profile)?;
+        let test_filter_builder =
+            self.build_filter
+                .make_test_filter_builder(filter_exprs, profile_name, &profile)?;
 
         let binary_list = self.base.build_binary_list()?;
         let build_platforms = binary_list.rust_build_meta.build_platforms.clone();
@@ -1913,7 +1931,9 @@ impl App {
         reporter_builder.set_verbose(self.base.output.verbose);
 
         let filter_exprs = self.build_filtering_expressions(&pcx)?;
-        let test_filter_builder = self.build_filter.make_test_filter_builder(filter_exprs, profile_name, &profile)?;
+        let test_filter_builder =
+            self.build_filter
+                .make_test_filter_builder(filter_exprs, profile_name, &profile)?;
 
         let binary_list = self.base.build_binary_list()?;
         let build_platforms = &binary_list.rust_build_meta.build_platforms.clone();
@@ -1965,44 +1985,51 @@ impl App {
         );
 
         configure_handle_inheritance(no_capture)?;
-        
+
         // Track failed tests during the run
-        use nextest_runner::reporter::last_failed::{FailedTest, FailedTestStore, FailedTestsSnapshot};
+        use nextest_runner::reporter::last_failed::{
+            FailedTest, FailedTestStore, FailedTestsSnapshot,
+        };
         let failed_tests = Arc::new(Mutex::new(Vec::<FailedTest>::new()));
         let failed_tests_for_callback = Arc::clone(&failed_tests);
-        
+
         let run_stats = runner.try_execute(|event| {
             // Track failed tests for persistence
-            if let TestEventKind::TestFinished { test_instance, run_statuses, .. } = &event.kind {
+            if let TestEventKind::TestFinished {
+                test_instance,
+                run_statuses,
+                ..
+            } = &event.kind
+            {
                 if !run_statuses.last_status().result.is_success() {
                     let mut failed = failed_tests_for_callback.lock().unwrap();
                     failed.push(FailedTest::from_test_instance_id(test_instance.id()));
                 }
             }
-            
+
             // Write and flush the event.
             reporter.report_event(event)
         })?;
         reporter.finish();
-        
+
         // After the run completes, persist failed tests if we're not in no-run mode
         if !runner_opts.no_run {
             let store = FailedTestStore::new(profile.store_dir(), profile_name);
-            
+
             let failed = failed_tests.lock().unwrap();
             let snapshot = FailedTestsSnapshot {
                 version: 1,
                 created_at: chrono::Utc::now(),
                 profile_name: profile_name.to_owned(),
                 failed_tests: failed.iter().cloned().collect(),
             };
-            
+
             if let Err(err) = store.save(&snapshot) {
                 eprintln!("Warning: Failed to save failed test history: {}", err);
                 // Don't fail the entire test run if we can't save the history
             }
         }
-        
+
         self.base
             .check_version_config_final(version_only_config.nextest_version())?;
 
@@ -2864,9 +2891,11 @@ mod tests {
                 .unwrap_or_else(|_| panic!("{cmd} should have successfully parsed"));
             // For tests, skip the failed test loading functionality
             let mut run_ignored = app.build_filter.run_ignored.map(Into::into);
-            let mut patterns = TestFilterPatterns::new(app.build_filter.pre_double_dash_filters.clone());
-            app.build_filter.merge_test_binary_args(&mut run_ignored, &mut patterns)?;
-            
+            let mut patterns =
+                TestFilterPatterns::new(app.build_filter.pre_double_dash_filters.clone());
+            app.build_filter
+                .merge_test_binary_args(&mut run_ignored, &mut patterns)?;
+
             Ok(TestFilterBuilder::new(
                 run_ignored.unwrap_or_default(),
                 app.build_filter.partition.clone(),

nextest-runner/src/reporter/last_failed.rs

@@ -16,13 +16,13 @@ use std::fs;
 pub struct FailedTestsSnapshot {
     /// Version of the snapshot format.
     pub version: u32,
-    
+
     /// When this snapshot was created.
     pub created_at: DateTime<Utc>,
-    
+
     /// The profile that was used for this test run.
     pub profile_name: String,
-    
+
     /// Set of failed tests.
     pub failed_tests: BTreeSet<FailedTest>,
 }
@@ -32,7 +32,7 @@ pub struct FailedTestsSnapshot {
 pub struct FailedTest {
     /// The binary ID.
     pub binary_id: RustBinaryId,
-    
+
     /// The test name.
     pub test_name: String,
 }
@@ -56,31 +56,31 @@ pub struct FailedTestStore {
 impl FailedTestStore {
     /// Current version of the snapshot format.
     const CURRENT_VERSION: u32 = 1;
-    
+
     /// Creates a new failed test store with the given path.
     pub fn new(store_dir: &Utf8Path, profile_name: &str) -> Self {
         let path = store_dir.join(format!("{profile_name}-last-failed.json"));
         Self { path }
     }
-    
+
     /// Loads the failed test snapshot from disk.
     pub fn load(&self) -> Result<Option<FailedTestsSnapshot>, LoadError> {
         match fs::read_to_string(&self.path) {
             Ok(contents) => {
-                let snapshot: FailedTestsSnapshot = serde_json::from_str(&contents)
-                    .map_err(|err| LoadError::DeserializeError {
+                let snapshot: FailedTestsSnapshot =
+                    serde_json::from_str(&contents).map_err(|err| LoadError::DeserializeError {
                         path: self.path.clone(),
                         error: err,
                     })?;
-                
+
                 if snapshot.version != Self::CURRENT_VERSION {
                     return Err(LoadError::VersionMismatch {
                         path: self.path.clone(),
                         expected: Self::CURRENT_VERSION,
                         actual: snapshot.version,
                     });
                 }
-                
+
                 Ok(Some(snapshot))
             }
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
@@ -90,7 +90,7 @@ impl FailedTestStore {
             }),
         }
     }
-    
+
     /// Saves the failed test snapshot to disk.
     pub fn save(&self, snapshot: &FailedTestsSnapshot) -> Result<(), SaveError> {
         // Ensure the parent directory exists
@@ -100,18 +100,18 @@ impl FailedTestStore {
                 error: err,
             })?;
         }
-        
+
         let contents = serde_json::to_string_pretty(snapshot)
             .map_err(|err| SaveError::SerializeError { error: err })?;
-        
+
         fs::write(&self.path, contents).map_err(|err| SaveError::WriteError {
             path: self.path.clone(),
             error: err,
         })?;
-        
+
         Ok(())
     }
-    
+
     /// Clears the failed test snapshot by removing the file.
     pub fn clear(&self) -> Result<(), ClearError> {
         match fs::remove_file(&self.path) {
@@ -137,7 +137,7 @@ pub enum LoadError {
         #[source]
         error: std::io::Error,
     },
-    
+
     /// Error deserializing the snapshot.
     #[error("failed to deserialize snapshot at {path}")]
     DeserializeError {
@@ -147,7 +147,7 @@ pub enum LoadError {
         #[source]
         error: serde_json::Error,
     },
-    
+
     /// Version mismatch in the snapshot file.
     #[error("snapshot version mismatch at {path}: expected {expected}, got {actual}")]
     VersionMismatch {
@@ -172,15 +172,15 @@ pub enum SaveError {
         #[source]
         error: std::io::Error,
     },
-    
+
     /// Error serializing the snapshot.
     #[error("failed to serialize snapshot")]
     SerializeError {
         /// The underlying serialization error.
         #[source]
         error: serde_json::Error,
     },
-    
+
     /// Error writing the snapshot to disk.
     #[error("failed to write snapshot to {path}")]
     WriteError {
@@ -206,20 +206,19 @@ pub enum ClearError {
     },
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use camino_tempfile::Utf8TempDir;
-    
+
     #[test]
     fn test_store_lifecycle() {
         let temp_dir = Utf8TempDir::new().unwrap();
         let store = FailedTestStore::new(temp_dir.path(), "default");
-        
+
         // Initially, there should be no snapshot
         assert!(store.load().unwrap().is_none());
-        
+
         // Create and save a snapshot
         let snapshot = FailedTestsSnapshot {
             version: FailedTestStore::CURRENT_VERSION,
@@ -236,17 +235,17 @@ mod tests {
                 },
             ]),
         };
-        
+
         store.save(&snapshot).unwrap();
-        
+
         // Load and verify
         let loaded = store.load().unwrap().unwrap();
         assert_eq!(loaded.version, snapshot.version);
         assert_eq!(loaded.profile_name, snapshot.profile_name);
         assert_eq!(loaded.failed_tests, snapshot.failed_tests);
-        
+
         // Clear and verify
         store.clear().unwrap();
         assert!(store.load().unwrap().is_none());
     }
-} 
+}