Rustfmt

Author: LegNeato

tests/difftests/bin/src/runner.rs

@@ -839,77 +839,80 @@ mod tests {
     #[test]
     fn test_outputs_match_no_epsilon() {
         let runner = Runner::new(PathBuf::from("dummy_base"));
-        
+
         // Exact match should work
         assert!(runner.outputs_match(b"hello", b"hello", None, OutputType::Raw));
-        
+
         // Different content should not match
         assert!(!runner.outputs_match(b"hello", b"world", None, OutputType::Raw));
     }
 
     #[test]
     fn test_outputs_match_with_epsilon_f32() {
         let runner = Runner::new(PathBuf::from("dummy_base"));
-        
+
         // Prepare test data - two floats with small difference
         let val1: f32 = 1.0;
         let val2: f32 = 1.00001;
         let arr1 = [val1];
         let arr2 = [val2];
         let bytes1 = bytemuck::cast_slice(&arr1);
         let bytes2 = bytemuck::cast_slice(&arr2);
-        
+
         // Should not match without epsilon
         assert!(!runner.outputs_match(bytes1, bytes2, None, OutputType::F32));
-        
+
         // Should match with sufficient epsilon
         assert!(runner.outputs_match(bytes1, bytes2, Some(0.0001), OutputType::F32));
-        
+
         // Should not match with too small epsilon
         assert!(!runner.outputs_match(bytes1, bytes2, Some(0.000001), OutputType::F32));
     }
 
     #[test]
     fn test_outputs_match_with_epsilon_f64() {
         let runner = Runner::new(PathBuf::from("dummy_base"));
-        
+
         // Prepare test data - two doubles with small difference
         let val1: f64 = 1.0;
         let val2: f64 = 1.00001;
         let arr1 = [val1];
         let arr2 = [val2];
         let bytes1 = bytemuck::cast_slice(&arr1);
         let bytes2 = bytemuck::cast_slice(&arr2);
-        
+
         // Should not match without epsilon
         assert!(!runner.outputs_match(bytes1, bytes2, None, OutputType::F64));
-        
+
         // Should match with sufficient epsilon
         assert!(runner.outputs_match(bytes1, bytes2, Some(0.0001), OutputType::F64));
-        
+
         // Should not match with too small epsilon
         assert!(!runner.outputs_match(bytes1, bytes2, Some(0.000001), OutputType::F64));
     }
 
     #[test]
     fn test_group_outputs_with_epsilon() {
         let runner = Runner::new(PathBuf::from("dummy_base"));
-        
+
         // Create float outputs with small differences
         let val1: f32 = 1.0;
         let val2: f32 = 1.00001;
         let val3: f32 = 2.0;
-        
-        let pkg1 = dummy_package_output("foo", "/path/to/foo", bytemuck::cast_slice(&[val1]), "tmp1");
-        let pkg2 = dummy_package_output("bar", "/path/to/bar", bytemuck::cast_slice(&[val2]), "tmp2");
-        let pkg3 = dummy_package_output("baz", "/path/to/baz", bytemuck::cast_slice(&[val3]), "tmp3");
-        
+
+        let pkg1 =
+            dummy_package_output("foo", "/path/to/foo", bytemuck::cast_slice(&[val1]), "tmp1");
+        let pkg2 =
+            dummy_package_output("bar", "/path/to/bar", bytemuck::cast_slice(&[val2]), "tmp2");
+        let pkg3 =
+            dummy_package_output("baz", "/path/to/baz", bytemuck::cast_slice(&[val3]), "tmp3");
+
         let outputs = vec![pkg1, pkg2, pkg3];
-        
+
         // Without epsilon, val1 and val2 should be in different groups
         let groups = runner.group_outputs(&outputs, None, OutputType::F32);
         assert_eq!(groups.len(), 3);
-        
+
         // With epsilon, val1 and val2 should be in the same group
         let groups_with_epsilon = runner.group_outputs(&outputs, Some(0.0001), OutputType::F32);
         assert_eq!(groups_with_epsilon.len(), 2);
@@ -919,7 +922,8 @@ mod tests {
     fn test_invalid_metadata_json() {
         // Test that invalid JSON in metadata file causes proper error
         let metadata_content = "{ invalid json }";
-        let result: Result<difftest::config::TestMetadata, _> = serde_json::from_str(metadata_content);
+        let result: Result<difftest::config::TestMetadata, _> =
+            serde_json::from_str(metadata_content);
         assert!(result.is_err());
         // Just check that it's an error, don't check the specific message
     }
@@ -929,18 +933,20 @@ mod tests {
         // This test verifies that when packages have different output types,
         // the runner returns an error. This tests the code at line 340-347
         // where we check: if output_type != Some(metadata.output_type)
-        
+
         // We can't easily test the full run_test_case flow without real binaries,
         // but we can at least verify the error is constructed properly
-        
+
         // Test that the error message is properly formatted
         let error = RunnerError::Config {
             msg: format!(
                 "Package '{}' has output type {:?}, but previous packages have {:?}",
-                "test_pkg", OutputType::F32, Some(OutputType::F64)
+                "test_pkg",
+                OutputType::F32,
+                Some(OutputType::F64)
             ),
         };
-        
+
         match error {
             RunnerError::Config { msg } => {
                 assert!(msg.contains("test_pkg"));
@@ -954,14 +960,14 @@ mod tests {
     #[test]
     fn test_metadata_parsing_error_message() {
         // Test that metadata parsing errors are formatted correctly
-        
+
         let error = RunnerError::Config {
             msg: format!(
                 "Failed to parse metadata for package '{}': {}",
                 "test_pkg", "invalid JSON"
             ),
         };
-        
+
         match error {
             RunnerError::Config { msg } => {
                 assert!(msg.contains("Failed to parse metadata"));
@@ -971,5 +977,4 @@ mod tests {
             _ => panic!("Wrong error type"),
         }
     }
-
 }

tests/difftests/lib/src/lib.rs

@@ -28,7 +28,8 @@ mod tests {
     #[test]
     fn test_config_from_path() {
         let mut tmp = NamedTempFile::new().unwrap();
-        let config_json = r#"{ "output_path": "/tmp/output.txt", "metadata_path": "/tmp/metadata.json" }"#;
+        let config_json =
+            r#"{ "output_path": "/tmp/output.txt", "metadata_path": "/tmp/metadata.json" }"#;
         write!(tmp, "{}", config_json).unwrap();
         let config = Config::from_path(tmp.path()).unwrap();
         assert_eq!(config.output_path.to_str().unwrap(), "/tmp/output.txt");