--version should just print the command name, not the path

This will fix the parsing for old autoconf
Closes: uutils#8880

Author: sylvestre

fuzz/fuzz_targets/fuzz_date.rs

@@ -1,14 +1,189 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
 #![no_main]
 use libfuzzer_sys::fuzz_target;
-
-use std::ffi::OsString;
 use uu_date::uumain;
 
-fuzz_target!(|data: &[u8]| {
-    let delim: u8 = 0; // Null byte
-    let args = data
-        .split(|b| *b == delim)
-        .filter_map(|e| std::str::from_utf8(e).ok())
-        .map(OsString::from);
-    uumain(args);
+use rand::prelude::IndexedRandom;
+use rand::Rng;
+use std::{env, ffi::OsString};
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd_with_env};
+
+// Use absolute path to GNU date to avoid picking up other versions
+static CMD_PATH: &str = "/usr/bin/date";
+
+fn generate_date_args(rng: &mut impl Rng) -> Vec<OsString> {
+    let mut args = vec![OsString::from("date")];
+
+    // Choose random strategy
+    match rng.random_range(0..=5) {
+        0 => {
+            // Test pure numeric -d inputs (new GNU compatibility feature)
+            args.push(OsString::from("-d"));
+
+            // Generate numeric strings of different lengths (1-4 digits)
+            let len = rng.random_range(1..=4);
+            let mut numeric_str = String::new();
+
+            for _ in 0..len {
+                numeric_str.push_str(&rng.random_range(0..=9).to_string());
+            }
+
+            args.push(OsString::from(numeric_str));
+
+            // Sometimes add a format string
+            if rng.random_bool(0.5) {
+                args.push(OsString::from("+%F %T %Z"));
+            }
+        }
+        1 => {
+            // Test edge cases for pure numeric inputs
+            args.push(OsString::from("-d"));
+
+            // Generate 4-digit numbers that might be invalid times
+            let val = rng.random_range(0..=9999);
+            args.push(OsString::from(format!("{:04}", val)));
+
+            // Add format string
+            args.push(OsString::from("+%F %T %Z"));
+        }
+        2 => {
+            // Test with human-readable dates
+            args.push(OsString::from("-d"));
+
+            // Use only absolute date formats to avoid timing issues
+            let dates = [
+                "2025-10-15",
+                "2025-01-01",
+                "2024-12-31",
+                "1970-01-01",
+                "2000-01-01 12:00:00",
+                "2025-06-15 15:30:45",
+            ];
+
+            let date = dates.choose(rng).unwrap();
+            args.push(OsString::from(*date));
+        }
+        3 => {
+            // Test with single letter military timezones (including J which should fail)
+            args.push(OsString::from("-d"));
+
+            let letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+            let letter = letters.chars().nth(rng.random_range(0..26)).unwrap();
+            args.push(OsString::from(letter.to_string()));
+
+            // Add format string to see timezone
+            args.push(OsString::from("+%F %T %Z"));
+        }
+        4 => {
+            // Test with ISO-like date strings
+            args.push(OsString::from("-d"));
+
+            // Generate a random date string
+            let year = rng.random_range(1970..=2100);
+            let month = rng.random_range(1..=12);
+            let day = rng.random_range(1..=31);
+            let hour = rng.random_range(0..=23);
+            let minute = rng.random_range(0..=59);
+
+            let date_str = if rng.random_bool(0.5) {
+                format!("{:04}-{:02}-{:02}", year, month, day)
+            } else {
+                format!(
+                    "{:04}-{:02}-{:02} {:02}:{:02}",
+                    year, month, day, hour, minute
+                )
+            };
+
+            args.push(OsString::from(date_str));
+        }
+        _ => {
+            // Test with random/malformed inputs
+            args.push(OsString::from("-d"));
+
+            // Generate random string that might or might not be valid
+            let random_str = generate_random_string(rng.random_range(1..=20));
+            args.push(OsString::from(random_str));
+        }
+    }
+
+    // Sometimes add UTC flag
+    if rng.random_bool(0.3) {
+        args.insert(1, OsString::from("-u"));
+    }
+
+    args
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let mut rng = rand::rng();
+
+    // Use simple offset-based timezones to avoid database dependencies
+    let tz = match rng.random_range(0..=3) {
+        0 => "UTC0",
+        1 => "UTC-5", // Like EST
+        2 => "UTC+9", // Like JST
+        _ => "UTC+1", // Like CET
+    };
+
+    unsafe {
+        env::set_var("TZ", tz);
+    }
+
+    let args = generate_date_args(&mut rng);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd_with_env(CMD_PATH, &args[1..], false, None, &[("TZ", tz)]) {
+        Ok(result) => result,
+        Err(error_result) => CommandResult {
+            stdout: String::new(),
+            stderr: error_result.stderr,
+            exit_code: error_result.exit_code,
+        },
+    };
+
+    // Include TZ in the command description for debugging
+    let cmd_str = format!(
+        "TZ={} date {}",
+        tz,
+        args[1..]
+            .iter()
+            .map(|s| s.to_string_lossy().to_string())
+            .collect::<Vec<_>>()
+            .join(" ")
+    );
+
+    // For stderr-only differences, don't panic but log them
+    // This handles cases where our error messages differ from GNU
+    let stderr_differs = rust_result.stderr.trim() != gnu_result.stderr.trim();
+    let stdout_differs = rust_result.stdout.trim() != gnu_result.stdout.trim();
+    let exit_code_differs = rust_result.exit_code != gnu_result.exit_code;
+
+    // Skip if only stderr differs (common for error messages)
+    if stderr_differs && !stdout_differs && !exit_code_differs {
+        // Just log this case, don't compare
+        return;
+    }
+
+    // Known issue: -u flag with non-UTC timezone has bugs
+    // TODO: Fix this in the date implementation
+    if args.contains(&OsString::from("-u")) && tz != "UTC0" {
+        // Skip this known bug for now
+        return;
+    }
+
+    compare_result(
+        "",
+        &cmd_str,
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Don't fail on stderr differences
+    );
 });

fuzz/uufuzz/src/lib.rs

@@ -221,6 +221,16 @@ pub fn run_gnu_cmd(
     args: &[OsString],
     check_gnu: bool,
     pipe_input: Option<&str>,
+) -> Result<CommandResult, CommandResult> {
+    run_gnu_cmd_with_env(cmd_path, args, check_gnu, pipe_input, &[])
+}
+
+pub fn run_gnu_cmd_with_env(
+    cmd_path: &str,
+    args: &[OsString],
+    check_gnu: bool,
+    pipe_input: Option<&str>,
+    env_vars: &[(&str, &str)],
 ) -> Result<CommandResult, CommandResult> {
     if check_gnu {
         match is_gnu_cmd(cmd_path) {
@@ -245,6 +255,11 @@ pub fn run_gnu_cmd(
     // uutils' coreutils is not locale-aware, and aims to mirror/be compatible with GNU Core Utilities's LC_ALL=C behavior
     command.env("LC_ALL", "C");
 
+    // Apply additional environment variables
+    for (key, value) in env_vars {
+        command.env(key, value);
+    }
+
     let output = if let Some(input_str) = pipe_input {
         // We have an pipe input
         command

src/uucore/src/lib/lib.rs

@@ -328,7 +328,14 @@ static UTIL_NAME: LazyLock<String> = LazyLock::new(|| {
     let is_man = usize::from(ARGV[base_index].eq("manpage"));
     let argv_index = base_index + is_man;
 
-    ARGV[argv_index].to_string_lossy().into_owned()
+    // Strip directory path to show only utility name
+    // (e.g., "mkdir" instead of "./target/debug/mkdir")
+    // in version output, error messages, and other user-facing output
+    std::path::Path::new(&ARGV[argv_index])
+        .file_name()
+        .unwrap_or(&ARGV[argv_index])
+        .to_string_lossy()
+        .into_owned()
 });
 
 /// Derive the utility name.

tests/by-util/test_date.rs

@@ -835,3 +835,90 @@ fn test_date_numeric_d_invalid_numbers() {
         .fails()
         .stderr_contains("invalid date");
 }
+
+// Fuzzer-discovered failures - these tests document known issues
+// All tests marked with #[ignore] are bugs that need to be fixed
+
+#[test]
+#[ignore]
+fn test_date_fuzz_military_timezones() {
+    // Military timezones: A-Z (except J) represent UTC offsets
+    // A=+1, B=+2, ..., I=+9, K=+10, L=+11, M=+12, N=-1, ..., Y=-12, Z=UTC
+    // J is reserved for local time
+    let test_cases = vec![
+        ("UTC0", "A", "23:00:00"),  // A = UTC+1
+        ("UTC0", "U", "08:00:00"),  // U = UTC+8
+        ("UTC+1", "M", "11:00:00"), // M = UTC+12
+        ("UTC0", "N", "01:00:00"),  // N = UTC-1
+        ("UTC+9", "W", "01:00:00"), // W = UTC+10
+        ("UTC+1", "F", "17:00:00"), // F = UTC+6
+        ("UTC+1", "K", "13:00:00"), // K = UTC+10
+        ("UTC+1", "J", "00:00:00"), // J is not defined, GNU uses midnight
+    ];
+
+    for (tz, letter, expected_time) in test_cases {
+        new_ucmd!()
+            .env("TZ", tz)
+            .arg("-d")
+            .arg(letter)
+            .arg("+%F %T %Z")
+            .succeeds()
+            .stdout_contains(expected_time);
+    }
+}
+
+#[test]
+#[ignore]
+fn test_date_fuzz_numeric_with_offset_tz() {
+    // Pure numeric dates should work correctly with offset timezones
+    let test_cases = vec![
+        ("UTC+1", "2", "02:00:00"),
+        ("UTC+1", "6", "06:00:00"),
+    ];
+
+    for (tz, num, expected_time) in test_cases {
+        new_ucmd!()
+            .env("TZ", tz)
+            .arg("-d")
+            .arg(num)
+            .succeeds()
+            .stdout_contains(expected_time);
+    }
+}
+
+#[test]
+#[ignore]
+fn test_date_fuzz_empty_string() {
+    // Empty string should be treated as midnight today
+    new_ucmd!()
+        .env("TZ", "UTC+1")
+        .arg("-d")
+        .arg("")
+        .succeeds()
+        .stdout_contains("00:00:00");
+}
+
+#[test]
+#[ignore]
+fn test_date_fuzz_date_with_offset_tz() {
+    // Date parsing should work correctly with offset timezones
+    new_ucmd!()
+        .env("TZ", "UTC+1")
+        .arg("-d")
+        .arg("2025-10-15")
+        .succeeds()
+        .stdout_contains("Oct 15")
+        .stdout_contains("00:00:00");
+}
+
+#[test]
+#[ignore]
+fn test_date_fuzz_relative_m9() {
+    // Relative date string "m9" should be parsed correctly
+    new_ucmd!()
+        .env("TZ", "UTC+9")
+        .arg("-d")
+        .arg("m9")
+        .succeeds()
+        .stdout_contains("12:00:00");
+}

tests/by-util/test_mkdir.rs

@@ -24,6 +24,47 @@ fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
+#[test]
+fn test_version_no_path() {
+    use std::process::Command;
+    use uutests::get_tests_binary;
+
+    // This test verifies that when an individual utility binary is invoked with its full path,
+    // the version output shows just "mkdir", not the full path like "/path/to/mkdir".
+    //
+    // Note: The multicall binary (coreutils) doesn't have this issue because it reads
+    // the utility name from ARGV[1], not ARGV[0]. This bug only affects individual binaries.
+
+    let tests_binary = get_tests_binary!();
+    let mkdir_binary_path = std::path::Path::new(tests_binary)
+        .parent()
+        .unwrap()
+        .join("mkdir");
+
+    // If the individual mkdir binary exists, test it
+    if mkdir_binary_path.exists() {
+        // Invoke the individual mkdir binary with its full path
+        let output = Command::new(&mkdir_binary_path)
+            .arg("--version")
+            .output()
+            .expect("Failed to execute mkdir binary");
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let first_line = stdout.lines().next().unwrap_or("");
+
+        assert!(stdout.starts_with("mkdir (uutils coreutils)"));
+    } else {
+        // If only multicall binary exists, test that (it should already pass)
+        let output = Command::new(tests_binary)
+            .args(["mkdir", "--version"])
+            .output()
+            .expect("Failed to execute mkdir via multicall binary");
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(stdout.starts_with("mkdir (uutils coreutils)"));
+    }
+}
+
 #[test]
 fn test_no_arg() {
     new_ucmd!()