From 8ab20c4673dec1bc54bd8bc9a20177f6fffde16a Mon Sep 17 00:00:00 2001
From: Sylvestre Ledru <sylvestre@debian.org>
Date: Wed, 8 Nov 2023 23:31:41 +0100
Subject: [PATCH] fuzz: adjust the fuzzers with the new arg

---
 fuzz/fuzz_targets/fuzz_expr.rs | 33 ++++++++++++++++++++++++---------
 fuzz/fuzz_targets/fuzz_test.rs | 29 +++++++++++++++++++++--------
 2 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/fuzz/fuzz_targets/fuzz_expr.rs b/fuzz/fuzz_targets/fuzz_expr.rs
index c2217c48a..ee65745bf 100644
--- a/fuzz/fuzz_targets/fuzz_expr.rs
+++ b/fuzz/fuzz_targets/fuzz_expr.rs
@@ -84,7 +84,7 @@ fuzz_target!(|_data: &[u8]| {
     let mut args = vec![OsString::from("expr")];
     args.extend(expr.split_whitespace().map(OsString::from));
 
-    let (rust_output, uumain_exit_code) = generate_and_run_uumain(&args, uumain);
+    let (rust_stdout, rust_stderr, uumain_exit_code) = generate_and_run_uumain(&args, uumain);
 
     // Use C locale to avoid false positives, like in https://github.com/uutils/coreutils/issues/5378,
     // because uutils expr doesn't support localization yet
@@ -93,28 +93,43 @@ fuzz_target!(|_data: &[u8]| {
 
     // Run GNU expr with the provided arguments and compare the output
     match run_gnu_cmd(CMD_PATH, &args[1..], true) {
-        Ok((gnu_output, gnu_exit_code)) => {
-            let gnu_output = gnu_output.trim().to_owned();
+        Ok((gnu_stdout, gnu_stderr, gnu_exit_code)) => {
+            let gnu_stdout = gnu_stdout.trim().to_owned();
             if uumain_exit_code != gnu_exit_code {
                 println!("Expression: {}", expr);
+
+                println!("GNU stderr: {}", gnu_stderr);
+                println!("Rust stderr: {}", rust_stderr);
+
                 println!("Rust code: {}", uumain_exit_code);
                 println!("GNU code: {}", gnu_exit_code);
                 panic!("Different error codes");
             }
-            if rust_output == gnu_output {
+            if rust_stdout == gnu_stdout {
                 println!(
                     "Outputs matched for expression: {} => Result: {}",
-                    expr, rust_output
+                    expr, rust_stdout
                 );
             } else {
                 println!("Expression: {}", expr);
-                println!("Rust output: {}", rust_output);
-                println!("GNU output: {}", gnu_output);
+                println!("Rust output: {}", rust_stdout);
+                println!("GNU output: {}", gnu_stdout);
                 panic!("Different output between Rust & GNU");
             }
         }
-        Err(_) => {
-            println!("GNU expr execution failed for expression: {}", expr);
+
+        Err((_gnu_stdout, gnu_stderr, _gnu_exit_code)) => {
+            if rust_stderr == gnu_stderr {
+                println!(
+                    "GNU execution failed for input: {} stderr: {}",
+                    expr, rust_stderr
+                );
+            } else {
+                println!("Input: {}", expr);
+                println!("Rust stderr: {}", rust_stderr);
+                println!("GNU stderr: {}", gnu_stderr);
+                panic!("Different stderr between Rust & GNU");
+            }
         }
     }
 });
diff --git a/fuzz/fuzz_targets/fuzz_test.rs b/fuzz/fuzz_targets/fuzz_test.rs
index 4805a41af..4c4834bdb 100644
--- a/fuzz/fuzz_targets/fuzz_test.rs
+++ b/fuzz/fuzz_targets/fuzz_test.rs
@@ -204,19 +204,22 @@ fuzz_target!(|_data: &[u8]| {
         args.push(OsString::from(generate_test_arg()));
     }
 
-    let (rust_output, uumain_exit_status) = generate_and_run_uumain(&args, uumain);
+    let (rust_stdout, rust_stderr, uumain_exit_status) = generate_and_run_uumain(&args, uumain);
 
     // Run GNU test with the provided arguments and compare the output
     match run_gnu_cmd(CMD_PATH, &args[1..], false) {
-        Ok((gnu_output, gnu_exit_status)) => {
-            let gnu_output = gnu_output.trim().to_owned();
+        Ok((gnu_stdout, gnu_stderr, gnu_exit_status)) => {
+            let gnu_stdout = gnu_stdout.trim().to_owned();
             println!("gnu_exit_status {}", gnu_exit_status);
             println!("uumain_exit_status {}", uumain_exit_status);
-            if rust_output != gnu_output || uumain_exit_status != gnu_exit_status {
+            if rust_stdout != gnu_stdout || uumain_exit_status != gnu_exit_status {
                 println!("Discrepancy detected!");
                 println!("Test: {:?}", &args[1..]);
-                println!("My output: {}", rust_output);
-                println!("GNU output: {}", gnu_output);
+                println!("Rust output: {}", rust_stdout);
+                println!("GNU output: {}", gnu_stdout);
+
+                println!("Rust stderr: {}", rust_stderr);
+                println!("GNU stderr: {}", gnu_stderr);
                 println!("My exit status: {}", uumain_exit_status);
                 println!("GNU exit status: {}", gnu_exit_status);
                 panic!();
@@ -227,8 +230,18 @@ fuzz_target!(|_data: &[u8]| {
                 );
             }
         }
-        Err(_) => {
-            println!("GNU test execution failed for expression {:?}", &args[1..]);
+        Err((_gnu_stdout, gnu_stderr, _gnu_exit_code)) => {
+            if rust_stderr == gnu_stderr {
+                println!(
+                    "GNU execution failed for input: {:?} stderr: {}",
+                    args, rust_stderr
+                );
+            } else {
+                println!("Input: {:?}", args);
+                println!("Rust stderr: {}", rust_stderr);
+                println!("GNU stderr: {}", gnu_stderr);
+                panic!("Different stderr between Rust & GNU");
+            }
         }
     }
 });