Use <= on 32-bit for some size assertions

Some of the assertions comparing the sizes of data structures to
expected values have been using `==` (unconditionally). Of those,
most but not all are mainly to safeguard against data structures
growing larger. For those, this loosens the assertions on 32-bit
targets to use `<=`, while still having them use `==` on 64-bit
targets.

The new `gix_testtools::size_ok` function is used to help with
this. See the `size_ok` documentation comment for a rationale as to
why it is done this way (and why this approach is not taken with
assertions that seem intended to do more than keep the size from
growing too large or without being noticed).

This is to allow the following 18 tests to pass in the container
(and hopefully on 32-bit systems in general):

- gix-attributes::attributes search::size_of_outcome
- gix-index extension::tree::tests::size_of_tree
- gix-index size_of_entry
- gix-index-tests::integrate index::size_of_entry
- gix-negotiate::negotiate size_of_entry
- gix-pack cache::delta::tests::size_of_pack_tree_item
- gix-pack cache::delta::tests::size_of_pack_verify_data_structure
- gix-pack cache::delta::tree::tests::size_of_pack_tree_item
- gix-pack cache::delta::tree::tests::size_of_pack_verify_data_structure
- gix-pack data::file::decode::entry::tests::size_of_decode_entry_outcome
- gix-pack-tests::pack pack::data::output::size_of_count
- gix-pack-tests::pack pack::data::output::size_of_entry
- gix-pack-tests::pack pack::iter::size_of_entry
- gix-ref raw::tests::size_of_reference
- gix-revwalk::revwalk graph::commit::size_of_commit
- gix::gix object::object_ref_size_in_memory
- gix::gix object::oid_size_in_memory
- gix::gix status::index_worktree::iter::item_size

This splits a couple of test cases into two, where the added code
would otherwise make them less readable.

The duplicated tests described in GitoxideLabs#1685 are among those modified
here, so this exacerbates that duplication, in that there is more
duplicated code, but the duplicated test cases are still easy to
resolve, once it is clear which modules they should be in. This
adds "FIXME" comments to identify the duplication.

Author: EliahKagan

Cargo.lock

@@ -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

@@ -238,11 +238,35 @@ pub(crate) mod util {
     }
 }
 
-#[test]
-fn size_of_entry() {
-    assert_eq!(std::mem::size_of::<crate::Entry>(), 80);
+// FIXME: Probably remove these in favor of the equivalent tests in `gix-index/tests/index/mod.rs`.
+#[cfg(test)]
+mod tests {
+    use gix_testtools::size_ok;
 
-    // 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);
+    #[test]
+    fn size_of_entry() {
+        let actual = std::mem::size_of::<crate::Entry>();
+        let expected = 80;
+        assert!(
+            size_ok(actual, expected),
+            "the size of this structure should not change unexpectedly: {actual} <~ {expected}"
+        );
+    }
+
+    #[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::<crate::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}"
+        );
+    }
 }

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

@@ -23,18 +23,24 @@ mod tree;
 
 pub use tree::{Item, Tree};
 
+// FIXME: Probably remove this pair of tests or the equivalent pair in `gix-pack/src/cache/delta/tree.rs`.
 #[cfg(test)]
 mod tests {
+    use super::Item;
+    use gix_testtools::size_ok;
 
     #[test]
     fn size_of_pack_tree_item() {
-        use super::Item;
-        assert_eq!(std::mem::size_of::<[Item<()>; 7_500_000]>(), 300_000_000);
+        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}"
+        );
     }
 
     #[test]
     fn size_of_pack_verify_data_structure() {
-        use super::Item;
         pub struct EntryWithDefault {
             _index_entry: crate::index::Entry,
             _kind: gix_object::Kind,
@@ -45,6 +51,11 @@ mod tests {
             _level: u16,
         }
 
-        assert_eq!(std::mem::size_of::<[Item<EntryWithDefault>; 7_500_000]>(), 840_000_000);
+        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/mod.rs

@@ -226,25 +226,39 @@ 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);
-    }
+    // FIXME: Probably remove this pair of tests or the equivalent pair in `gix-pack/src/cache/delta/mod.rs`.
+    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}"
     );
 }
 

gix-pack/tests/pack/data/output/mod.rs

@@ -1,11 +1,13 @@
 use gix_odb::pack;
+use gix_testtools::size_ok;
 
 #[test]
 fn size_of_entry() {
-    assert_eq!(
-        std::mem::size_of::<pack::data::input::Entry>(),
-        104,
-        "let's keep the size in check as we have many of them"
+    let actual = std::mem::size_of::<pack::data::input::Entry>();
+    let expected = 104;
+    assert!(
+        size_ok(actual, expected),
+        "let's keep the size in check as we have many of them: {actual} <~ {expected}"
     );
 }
 

gix-pack/tests/pack/iter.rs

@@ -94,13 +94,15 @@ mod access {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use gix_testtools::size_ok;
 
     #[test]
     fn size_of_reference() {
-        assert_eq!(
-            std::mem::size_of::<Reference>(),
-            80,
-            "let's not let it change size undetected"
+        let actual = std::mem::size_of::<Reference>();
+        let expected = 80;
+        assert!(
+            size_ok(actual, expected),
+            "let's not let it change size undetected: {actual} <~ {expected}"
         );
     }
 }

gix-ref/src/raw.rs

@@ -23,3 +23,6 @@ gix-commitgraph = { version = "^0.25.0", path = "../gix-commitgraph" }
 
 thiserror = "2.0.0"
 smallvec = "1.10.0"
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools" }

gix-revwalk/Cargo.toml

@@ -1,11 +1,14 @@
 mod graph {
     mod commit {
+        use gix_testtools::size_ok;
+
         #[test]
         fn size_of_commit() {
-            assert_eq!(
-                std::mem::size_of::<gix_revwalk::graph::Commit<()>>(),
-                48,
-                "We might see quite a lot of these, so they shouldn't grow unexpectedly"
+            let actual = std::mem::size_of::<gix_revwalk::graph::Commit<()>>();
+            let expected = 48;
+            assert!(
+                size_ok(actual, expected),
+                "We might see quite a lot of these, so they shouldn't grow unexpectedly: {actual} <~ {expected}"
             );
         }
     }