style: format assert!() macros to single line

src/tests.rs

@@ -83,12 +83,7 @@ mod tests {
             // Create a command that pipes input to keep with the specified environment
             let cmd = format!("echo {} | {} {}", input, env, tag);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
         });
     }
 
@@ -102,78 +97,43 @@ mod tests {
 
             let cmd = format!("{} --get 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} -g 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} --get", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
 
             let cmd = format!("{} --get tag_a", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} --get tag_b", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
 
             let cmd = format!("{} --get tag", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
         });
@@ -190,30 +150,15 @@ mod tests {
 
             let cmd = format!("{} --list", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} -l", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} --list tag_a", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
         });
     }
 
@@ -228,39 +173,19 @@ mod tests {
 
             let cmd = format!("{} --delete tag", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
-                !output.status.success(),
-                "Command succeeded when it should have failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} --delete 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} -d 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} --delete 9999", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             //assert!(!output.status.success(), "Command succeded when it should have failed: {}  {}", cmd, output.status);
         });
     }
@@ -276,12 +201,7 @@ mod tests {
 
             let cmd = format!("{} --diff 1 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
@@ -289,30 +209,15 @@ mod tests {
 
             let cmd = format!("{} --diff tag_a tag_b", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
-                !output.status.success(),
-                "Command succeeded when it should have failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} --diff tag_a 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
-                !output.status.success(),
-                "Command succeeded when it should have failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             let cmd = format!("{} --diff 9999 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
-                !output.status.success(),
-                "Command succeeded when it should have failed: {}  {}",
-                cmd,
-                output.status
-            );
 
             // Output should be empty for non-existent item
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
@@ -336,12 +241,7 @@ mod tests {
             let cmd = format!("{} --get none", env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(
+            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
-                output.status.success(),
-                "Command failed: {}  {}",
-                cmd,
-                output.status
-            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);