Merge pull request #1687 from EliahKagan/run-ci/32bit

Fix 32-bit test failures and test workspace on a 32-bit target on CI

Author: Byron

.github/workflows/ci.yml

@@ -198,6 +198,42 @@ jobs:
   test-32bit:
     runs-on: ubuntu-latest
 
+    container: i386/debian:stable-slim
+
+    steps:
+      - name: Prerequisites
+        run: |
+          prerequisites=(
+            build-essential
+            ca-certificates
+            cmake
+            curl
+            git
+            jq
+            libssl-dev
+            libstdc++6:amd64  # To support external 64-bit Node.js for actions.
+            pkgconf
+          )
+          dpkg --add-architecture amd64
+          apt-get update
+          apt-get install --no-install-recommends -y -- "${prerequisites[@]}"
+        shell: bash
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable-i686-unknown-linux-gnu  # Otherwise it may misdetect based on the amd64 kernel.
+      - uses: Swatinem/rust-cache@v2
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: nextest
+      - name: Make `system` scope nonempty for "GitInstallation" tests
+        run: git config --system gitoxide.imaginary.arbitraryVariable arbitraryValue
+      - name: Test (nextest)
+        run: cargo nextest run --workspace --no-fail-fast
+
+  test-32bit-cross:
+    runs-on: ubuntu-latest
+
     strategy:
       matrix:
         target: [ armv7-linux-androideabi ]
@@ -211,15 +247,17 @@ jobs:
         with:
           toolchain: stable
           targets: ${{ matrix.target }}
-      - uses: taiki-e/install-action@v2
+      - name: Install cross
+        uses: taiki-e/install-action@v2
         with:
           tool: cross
       - name: check
         run: cross check -p gix --target ${{ matrix.target }}
       - name: Test (unit)
-        # run high-level unit tests that exercise a lot of code while being pure Rust to ease building test binaries.
-        # TODO: figure out why `git` doesn't pick up environment configuration so build scripts fail when using `-p gix`.
-        run: cross test -p gix-hashtable --target ${{ matrix.target }}
+        run: |
+          # Run some high-level unit tests that exercise various pure Rust code to ease building test binaries.
+          # We would prefer `-p gix`. But with `cross`, fixture scripts try to run amd64 `git` as an armv7 binary.
+          cross test -p gix-hashtable --target ${{ matrix.target }}
 
   lint:
     runs-on: ubuntu-latest
@@ -396,6 +434,7 @@ jobs:
       - test-journey
       - test-fast
       - test-32bit
+      - test-32bit-cross
       - lint
       - cargo-deny
       - check-packetline

Cargo.lock

@@ -14,10 +14,15 @@ mod from_tree {
 
     use crate::hex_to_id;
 
+    #[cfg(target_pointer_width = "64")]
+    const EXPECTED_BUFFER_LENGTH: usize = 551;
+    #[cfg(target_pointer_width = "32")]
+    const EXPECTED_BUFFER_LENGTH: usize = 479;
+
     #[test]
     fn basic_usage_internal() -> gix_testtools::Result {
         basic_usage(gix_archive::Format::InternalTransientNonPersistable, |buf| {
-            assert_eq!(buf.len(), 551);
+            assert_eq!(buf.len(), EXPECTED_BUFFER_LENGTH);
 
             let mut stream = gix_worktree_stream::Stream::from_read(std::io::Cursor::new(buf));
             let mut paths_and_modes = Vec::new();

gix-archive/tests/archive.rs

@@ -6,6 +6,7 @@ use gix_attributes::{
     AssignmentRef, NameRef, StateRef,
 };
 use gix_glob::pattern::Case;
+use gix_testtools::size_ok;
 
 mod specials {
     use std::path::Path;
@@ -268,10 +269,11 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
 
 #[test]
 fn size_of_outcome() {
-    assert_eq!(
-        std::mem::size_of::<Outcome>(),
-        840,
-        "it's quite big, shouldn't change without us noticing"
+    let actual = std::mem::size_of::<Outcome>();
+    let expected = 840;
+    assert!(
+        size_ok(actual, expected),
+        "it's quite big, shouldn't change without us noticing: {actual} <~ {expected}"
     );
 }
 

gix-attributes/tests/search/mod.rs

@@ -58,5 +58,8 @@ rustix = { version = "0.38.20", default-features = false, features = [
 ] }
 libc = { version = "0.2.149" }
 
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools" }
+
 [package.metadata.docs.rs]
 features = ["document-features", "serde"]

gix-index/Cargo.toml

@@ -13,9 +13,15 @@ mod write;
 
 #[cfg(test)]
 mod tests {
+    use gix_testtools::size_ok;
 
     #[test]
     fn size_of_tree() {
-        assert_eq!(std::mem::size_of::<crate::extension::Tree>(), 88);
+        let actual = std::mem::size_of::<crate::extension::Tree>();
+        let expected = 88;
+        assert!(
+            size_ok(actual, expected),
+            "the size of this structure should not change unexpectedly: {actual} <~ {expected}"
+        );
     }
 }

gix-index/src/extension/tree/mod.rs

@@ -237,12 +237,3 @@ pub(crate) mod util {
         data.split_at(pos).into()
     }
 }
-
-#[test]
-fn size_of_entry() {
-    assert_eq!(std::mem::size_of::<crate::Entry>(), 80);
-
-    // the reason we have our own time is half the size.
-    assert_eq!(std::mem::size_of::<crate::entry::stat::Time>(), 8);
-    assert_eq!(std::mem::size_of::<filetime::FileTime>(), 16);
-}

gix-index/src/lib.rs

@@ -1,13 +1,14 @@
-use std::path::{Path, PathBuf};
-
-use gix_hash::ObjectId;
-
 mod access;
 mod entry;
 mod file;
 mod fs;
 mod init;
 
+use std::path::{Path, PathBuf};
+
+use gix_hash::ObjectId;
+use gix_testtools::size_ok;
+
 pub fn hex_to_id(hex: &str) -> ObjectId {
     ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")
 }
@@ -25,11 +26,29 @@ pub fn loose_file_path(name: &str) -> PathBuf {
 
 #[test]
 fn size_of_entry() {
-    assert_eq!(std::mem::size_of::<gix_index::Entry>(), 80);
+    let actual = std::mem::size_of::<gix_index::Entry>();
+    let expected = 80;
+    assert!(
+        size_ok(actual, expected),
+        "the size of this structure should not change unexpectedly: {actual} <~ {expected}"
+    );
+}
 
-    // the reason we have our own time is half the size.
-    assert_eq!(std::mem::size_of::<gix_index::entry::stat::Time>(), 8);
-    assert_eq!(std::mem::size_of::<filetime::FileTime>(), 16);
+#[test]
+fn size_of_entry_time() {
+    // The reason we have our own time is that it is half the size.
+    let ent_actual = std::mem::size_of::<gix_index::entry::stat::Time>();
+    let ent_expected = 8;
+    assert!(
+        size_ok(ent_actual, ent_expected),
+        "the size of this structure should not change unexpectedly: {ent_actual} <~ {ent_expected}"
+    );
+    let ft_actual = std::mem::size_of::<filetime::FileTime>();
+    let ft_expected = 16;
+    assert!(
+        size_ok(ft_actual, ft_expected),
+        "we will want to know if the size of this structure changes: {ft_actual} <~ {ft_expected}"
+    );
 }
 
 enum Fixture {

gix-index/tests/index/mod.rs

@@ -1,4 +1,4 @@
-use gix_testtools::Result;
+use gix_testtools::{size_ok, Result};
 
 mod window_size {
     use gix_negotiate::window_size;
@@ -38,9 +38,10 @@ mod baseline;
 
 #[test]
 fn size_of_entry() {
-    assert_eq!(
-        std::mem::size_of::<gix_revwalk::graph::Commit<gix_negotiate::Metadata>>(),
-        56,
-        "we may keep a lot of these, so let's not let them grow unnoticed"
+    let actual = std::mem::size_of::<gix_revwalk::graph::Commit<gix_negotiate::Metadata>>();
+    let expected = 56;
+    assert!(
+        size_ok(actual, expected),
+        "we may keep a lot of these, so let's not let them grow unnoticed: {actual} <~ {expected}"
     );
 }

gix-negotiate/tests/negotiate.rs

@@ -22,29 +22,3 @@ pub mod from_offsets;
 mod tree;
 
 pub use tree::{Item, Tree};
-
-#[cfg(test)]
-mod tests {
-
-    #[test]
-    fn size_of_pack_tree_item() {
-        use super::Item;
-        assert_eq!(std::mem::size_of::<[Item<()>; 7_500_000]>(), 300_000_000);
-    }
-
-    #[test]
-    fn size_of_pack_verify_data_structure() {
-        use super::Item;
-        pub struct EntryWithDefault {
-            _index_entry: crate::index::Entry,
-            _kind: gix_object::Kind,
-            _object_size: u64,
-            _decompressed_size: u64,
-            _compressed_size: u64,
-            _header_size: u16,
-            _level: u16,
-        }
-
-        assert_eq!(std::mem::size_of::<[Item<EntryWithDefault>; 7_500_000]>(), 840_000_000);
-    }
-}

gix-pack/src/cache/delta/mod.rs

@@ -226,25 +226,38 @@ mod tests {
         }
     }
 
-    #[test]
-    fn size_of_pack_tree_item() {
-        use super::Item;
-        assert_eq!(std::mem::size_of::<[Item<()>; 7_500_000]>(), 300_000_000);
-    }
+    mod size {
+        use super::super::Item;
+        use gix_testtools::size_ok;
 
-    #[test]
-    fn size_of_pack_verify_data_structure() {
-        use super::Item;
-        pub struct EntryWithDefault {
-            _index_entry: crate::index::Entry,
-            _kind: gix_object::Kind,
-            _object_size: u64,
-            _decompressed_size: u64,
-            _compressed_size: u64,
-            _header_size: u16,
-            _level: u16,
+        #[test]
+        fn size_of_pack_tree_item() {
+            let actual = std::mem::size_of::<[Item<()>; 7_500_000]>();
+            let expected = 300_000_000;
+            assert!(
+                size_ok(actual, expected),
+                "we don't want these to grow unnoticed: {actual} <~ {expected}"
+            );
         }
 
-        assert_eq!(std::mem::size_of::<[Item<EntryWithDefault>; 7_500_000]>(), 840_000_000);
+        #[test]
+        fn size_of_pack_verify_data_structure() {
+            pub struct EntryWithDefault {
+                _index_entry: crate::index::Entry,
+                _kind: gix_object::Kind,
+                _object_size: u64,
+                _decompressed_size: u64,
+                _compressed_size: u64,
+                _header_size: u16,
+                _level: u16,
+            }
+
+            let actual = std::mem::size_of::<[Item<EntryWithDefault>; 7_500_000]>();
+            let expected = 840_000_000;
+            assert!(
+                size_ok(actual, expected),
+                "we don't want these to grow unnoticed: {actual} <~ {expected}"
+            );
+        }
     }
 }

gix-pack/src/cache/delta/tree.rs

@@ -420,13 +420,15 @@ impl File {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use gix_testtools::size_ok;
 
     #[test]
     fn size_of_decode_entry_outcome() {
-        assert_eq!(
-            std::mem::size_of::<Outcome>(),
-            32,
-            "this shouldn't change without use noticing as it's returned a lot"
+        let actual = std::mem::size_of::<Outcome>();
+        let expected = 32;
+        assert!(
+            size_ok(actual, expected),
+            "this shouldn't change without use noticing as it's returned a lot: {actual} <~ {expected}"
         );
     }
 }

gix-pack/src/data/file/decode/entry.rs

@@ -1,22 +1,25 @@
 use std::{path::PathBuf, sync::Arc};
 
 use gix_pack::data::output;
+use gix_testtools::size_ok;
 
 #[test]
 fn size_of_entry() {
-    assert_eq!(
-        std::mem::size_of::<output::Entry>(),
-        80,
-        "The size of the structure shouldn't change unexpectedly"
+    let actual = std::mem::size_of::<output::Entry>();
+    let expected = 80;
+    assert!(
+        size_ok(actual, expected),
+        "The size of the structure shouldn't change unexpectedly: {actual} <~ {expected}"
     );
 }
 
 #[test]
 fn size_of_count() {
-    assert_eq!(
-        std::mem::size_of::<output::Count>(),
-        56,
-        "The size of the structure shouldn't change unexpectedly"
+    let actual = std::mem::size_of::<output::Count>();
+    let expected = 56;
+    assert!(
+        size_ok(actual, expected),
+        "The size of the structure shouldn't change unexpectedly: {actual} <~ {expected}"
     );
 }