Add some tests for finding associated executables

The tests are not limited to finding `sh`, but this may still not
be ready for use in finding other commands, for the commented
reasons. These tests are a step toward that, but they are mainly
to make sure the search works as expected both when the looked-for
command is and is not found in one of the searched `bin` dirs.

This is to say that, in the tests, the commands that can be found
but in `usr/bin` rather than the first choice of `bin` are to an
extent a stand-in for `sh` when searched for in an environment that
doesn't have `(git root)/bin` (like the Git for Windows SDK), and
the commands that cannot bve found are to an extent a standi-in for
`sh` on systems where it cannot be found (such as due to `git` not
being installed or installed from MinGit or some other minimal or
nonstandard Git installation, or `GIT_EXEC_PATH` being defined and
having a value that cannot be used or that can be used but points
to a directory structure that does not have a usable `sh`).

Author: EliahKagan

gix-path/src/env/auxiliary.rs

@@ -70,9 +70,9 @@ const BIN_DIR_FRAGMENTS: &[&str] = &["bin", "usr/bin"];
 /// The resulting path uses only `/` separators so long as the path obtained from `git --exec-path`
 /// does, which is the case unless it is overridden by setting `GIT_EXEC_PATH` to an unusual value.
 ///
-/// This is currently only used (and only exercised in tests) for finding `sh.exe`. It may be used
-/// to find other executables in the future, but may require adjustment. In particular, depending
-/// on the desired semantics, it should possibly also check inside a `cmd` directory; directories
+/// This is currently only used (and only heavily exercised in tests) for finding `sh.exe`. It may
+/// be used to find other executables in the future, but may need adjustment. In particular,
+/// depending on desired semantics, it should possibly also check a `cmd` directory; directories
 /// like `<platform>/bin`, for any applicable variants (such as `mingw64`); and `super::core_dir()`
 /// itself, which it could safely check even if its value is not safe for inferring other paths.
 fn find_git_associated_windows_executable(stem: &str) -> Option<OsString> {
@@ -101,3 +101,63 @@ pub(super) fn find_git_associated_windows_executable_with_fallback(stem: &str) -
         raw_path
     })
 }
+
+#[cfg(all(windows, test))]
+mod tests {
+    use std::path::Path;
+
+    /// Some commands with `.exe` files in `bin` and `usr/bin` that should be found.
+    ///
+    /// Tests are expected to run with a full Git for Windows installation (not MinGit).
+    const SHOULD_FIND: &[&str] = &[
+        "sh", "bash", "dash", "diff", "tar", "less", "sed", "awk", "perl", "cygpath",
+    ];
+
+    /// Shouldn't find anything nonexistent, or only in PATH or in `bin`s we don't mean to search.
+    ///
+    /// If dirs like `mingsw64/bin` are added, `git-credential-manager` should be moved to `SHOULD_FIND`.
+    /// Likewise, if `super::core_dir()` is added, `git-daemon` should be moved to `SHOULD_FIND`.
+    const SHOULD_NOT_FIND: &[&str] = &[
+        "nonexistent-command",
+        "cmd",
+        "powershell",
+        "explorer",
+        "git-credential-manager",
+        "git-daemon",
+    ];
+
+    #[test]
+    fn find_git_associated_windows_executable() {
+        for stem in SHOULD_FIND {
+            let path = super::find_git_associated_windows_executable(stem);
+            assert!(path.is_some(), "should find {stem:?}");
+        }
+    }
+
+    #[test]
+    fn find_git_associated_windows_executable_no_extra() {
+        for stem in SHOULD_NOT_FIND {
+            let path = super::find_git_associated_windows_executable(stem);
+            assert_eq!(path, None, "should not find {stem:?}");
+        }
+    }
+
+    #[test]
+    fn find_git_associated_windows_executable_with_fallback() {
+        for stem in SHOULD_FIND {
+            let path = super::find_git_associated_windows_executable_with_fallback(stem);
+            assert!(Path::new(&path).is_absolute(), "should find {stem:?}");
+        }
+    }
+
+    #[test]
+    fn find_git_associated_windows_executable_with_fallback_falls_back() {
+        for stem in SHOULD_NOT_FIND {
+            let path = super::find_git_associated_windows_executable_with_fallback(stem)
+                .to_str()
+                .expect("valid Unicode")
+                .to_owned();
+            assert_eq!(path, format!("{stem}.exe"), "should fall back for {stem:?}");
+        }
+    }
+}