Update alternative locations integration tests for ARM64

This updates the integration-style tests for Windows-specific `git`
executable alternative locations to include `clangarm64/bin`
directories when looking under the 64-bit program files directory.
(These tests are "integration-style" in the sense that they check
the actual value of `ALTERNATIVE_LOCATIONS` against expectations
computed from details of the build target and runtime environment.)

The tests will now fail until `ALTERNATIVE_LOCATIONS` is fixed for
ARM64 Windows. (Because the currently intended approach is to check
for both ARM64 and x86_64 installations of Git for Windows on all
64-bit systems where the 64-bit "Program Files" directory location
is available -- regardless of whether the system is an x86_64 or
ARM64 installation of Windows -- these integration-style tests
should currently fail on both x86_64 and ARM64 Windows systems.)

Author: EliahKagan

gix-path/src/env/git/tests.rs

@@ -292,27 +292,32 @@ mod locations {
     #[derive(Clone, Debug)]
     struct RelativeGitBinPaths<'a> {
         x86: &'a Path,
-        maybe_64bit: Option<&'a Path>,
+        maybe_x64: Option<&'a Path>,
+        maybe_arm64: Option<&'a Path>,
     }
 
     impl<'a> RelativeGitBinPaths<'a> {
         /// Assert that `locations` has the given path prefixes, and extract the suffixes.
         fn assert_from(pf: &'a ProgramFilesPaths, locations: &'static [PathBuf]) -> Self {
             match locations {
-                [primary, secondary] => {
+                [primary, secondary, tertiary] => {
                     let prefix_64bit = pf
                         .maybe_64bit
                         .as_ref()
                         .expect("It gives two paths only if one can be 64-bit");
-                    let suffix_64bit = primary
+                    let suffix_arm64 = primary
                         .strip_prefix(prefix_64bit)
-                        .expect("It gives the 64-bit path and lists it first");
-                    let suffix_x86 = secondary
+                        .expect("It gives the 64-bit ARM64 path and lists it first");
+                    let suffix_x64 = secondary
+                        .strip_prefix(prefix_64bit)
+                        .expect("It gives the 64-bit x86 path and lists it second");
+                    let suffix_x86 = tertiary
                         .strip_prefix(pf.x86.as_path())
-                        .expect("It gives the 32-bit path and lists it second");
+                        .expect("It gives the 32-bit path and lists it third");
                     Self {
                         x86: suffix_x86,
-                        maybe_64bit: Some(suffix_64bit),
+                        maybe_x64: Some(suffix_x64),
+                        maybe_arm64: Some(suffix_arm64),
                     }
                 }
                 [only] => {
@@ -322,23 +327,23 @@ mod locations {
                         .expect("The one path it gives is the 32-bit path");
                     Self {
                         x86: suffix_x86,
-                        maybe_64bit: None,
+                        maybe_x64: None,
+                        maybe_arm64: None,
                     }
                 }
-                other => panic!("{:?} has length {}, expected 1 or 2.", other, other.len()),
+                other => panic!("{:?} has length {}, expected 1 or 3.", other, other.len()),
             }
         }
 
         /// Assert that the suffixes (relative subdirectories) are the common per-architecture Git install locations.
         fn assert_architectures(&self) {
             assert_eq!(self.x86, Path::new("Git/mingw32/bin"));
 
-            if let Some(suffix_64bit) = self.maybe_64bit {
-                // When Git for Windows releases ARM64 builds, there will be another 64-bit suffix,
-                // likely clangarm64. In that case, this and other assertions will need updating,
-                // as there will be two separate paths to check under the same 64-bit program files
-                // directory. (See the definition of ProgramFilesPaths::maybe_64bit for details.)
-                assert_eq!(suffix_64bit, Path::new("Git/mingw64/bin"));
+            if let Some(suffix_x64) = self.maybe_x64 {
+                assert_eq!(suffix_x64, Path::new("Git/mingw64/bin"));
+            }
+            if let Some(suffix_arm64) = self.maybe_arm64 {
+                assert_eq!(suffix_arm64, Path::new("Git/clangarm64/bin"));
             }
         }
     }