Add 32-bit expectations for remaining == size assertions

Most `assert_eq!` data structure size assertions that had failed on
32-bit targets were to safeguard against the size increasing, so
using a `==` comparison on 64-bit targets and a `<=` comparison to
the same value on 32-bit targets was a suitable fix, which allowed
18 tests to go from failing to passing in the 32-bit container.

However, four remaining tests that assert sizes of buffers or
streamed data are not just for flagging increases, but are instead
cases where a change in either direction, on any platform, should
probably draw attention. The most important of these to keep `==`,
even on 32-bit platforms, may be two tests that assert the same
value for complementary operations:

- gix::gix repository::worktree::archive
- gix::gix repository::worktree::stream

But I think it's useful to do this in the two others, too:

- gix-archive::archive from_tree::basic_usage_internal
- gix-worktree-stream::stream from_tree::will_provide_all_information_and_respect_export_ignore

This commit adds constants with different 64-bit and 32-bit values
for the three buffer lengths asserted in those four tests (the
two `gix::gix repository::worktree::*` assert the same length).

This change should make the four remaining tests that had been
failing on the 32-bit container, and 32-bit GNU/Linux targets in
general, pass on them.

In specifying the expected 32-bit buffer lengths, I have treated
these as approval tests, rather than inferring that the exact
length and no other length must be correct. The asserted lengths:

- Appeared as the value when the tests were run in the 32-bit
  container.

- Are verified to appear repeatedly across different runs in the
  container as well as in runs on a non-containerized 32-bit Debian
  12 system.

- Are equal to the values in assertion messages for the same failed
  tests run on a 32-bit Windows 10 system. This is significant
  because some values differ between different 32-bit targets, even
  targets for the same 32-bit architecture, and two such targets
  where I've observed differences are `i686-unknown-linux-gnu` and
  `i686-pc-windows-msvc`.

- Are, of course, less than the 64-bit sizes, not greater.

- Make sense on inspection. (But please note that this is not the
  same as an analysis that proves they are the only possible
  correct values.)

Author: EliahKagan

gix-archive/tests/archive.rs

@@ -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-worktree-stream/tests/stream.rs

@@ -58,6 +58,11 @@ mod from_tree {
         Ok(())
     }
 
+    #[cfg(target_pointer_width = "64")]
+    const EXPECTED_BUFFER_LENGTH: usize = 320302;
+    #[cfg(target_pointer_width = "32")]
+    const EXPECTED_BUFFER_LENGTH: usize = 320198;
+
     #[test]
     fn will_provide_all_information_and_respect_export_ignore() -> gix_testtools::Result {
         let (dir, head_tree, odb, mut cache) = basic()?;
@@ -186,7 +191,7 @@ mod from_tree {
         );
         assert_eq!(
             copy.lock().len(),
-            320302,
+            EXPECTED_BUFFER_LENGTH,
             "keep track of file size changes of the streaming format"
         );
 

gix/tests/gix/repository/worktree.rs

@@ -1,13 +1,18 @@
 use gix_ref::bstr;
 
+#[cfg(target_pointer_width = "64")]
+const EXPECTED_BUFFER_LENGTH: usize = 102;
+#[cfg(target_pointer_width = "32")]
+const EXPECTED_BUFFER_LENGTH: usize = 86;
+
 #[test]
 #[cfg(feature = "worktree-stream")]
 fn stream() -> crate::Result {
     let repo = crate::named_repo("make_packed_and_loose.sh")?;
     let mut stream = repo.worktree_stream(repo.head_commit()?.tree_id()?)?.0.into_read();
     assert_eq!(
         std::io::copy(&mut stream, &mut std::io::sink())?,
-        102,
+        EXPECTED_BUFFER_LENGTH as u64,
         "there is some content in the stream, it works"
     );
     Ok(())
@@ -27,7 +32,7 @@ fn archive() -> crate::Result {
         &std::sync::atomic::AtomicBool::default(),
         Default::default(),
     )?;
-    assert_eq!(buf.len(), 102, "default format is internal");
+    assert_eq!(buf.len(), EXPECTED_BUFFER_LENGTH, "default format is internal");
     Ok(())
 }