Drop redundant LE normalization, add cross-platform hash stability test

- Remove to_le() calls from StableHasher — foldhash-portable's portable
  feature handles endianness internally. The double-conversion was causing
  wrong results on big-endian platforms.
- Keep usize/isize → u64/i64 widening (foldhash can't know pointer width).
- Add test_hash_stability: serialized filters with hardcoded expected bytes,
  verified on both x86_64 (64-bit LE) and PowerPC (32-bit BE) via cross.
- Add cross-platform CI job testing on powerpc, i686, and aarch64.
- Remove RandomBuildHasher (users pass foldhash types directly).
- Make StableBuildHasher pub(crate).

Author: arthurprs

.github/workflows/ci.yml

@@ -36,6 +36,21 @@ jobs:
       - run: cargo test --no-default-features
       - run: cargo test --all-features
 
+  cross-platform-test:
+    name: Cross-platform tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - powerpc-unknown-linux-gnu    # 32-bit big-endian
+          - i686-unknown-linux-gnu       # 32-bit little-endian
+          - aarch64-unknown-linux-gnu    # 64-bit little-endian (ARM)
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo install cross
+      - run: cross test --features serde --target ${{ matrix.target }} --lib
+
   fuzz-tests:
     name: Fuzz tests
     runs-on: ubuntu-latest

src/lib.rs

@@ -3423,4 +3423,39 @@ mod tests {
         let fps2: Vec<u64> = f2.fingerprints().collect();
         assert_eq!(fps1, fps2);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_hash_stability() {
+        // Build filters with known inputs and verify serialized bytes match
+        // hardcoded values. This catches any change in the hash algorithm or
+        // StableHasher normalization, and ensures cross-platform compatibility
+        // (the same bytes must be produced on 32-bit BE and 64-bit LE).
+
+        fn build_filter(items: &[usize], capacity: u64, fp_rate: f64) -> Vec<u8> {
+            let mut f = Filter::new(capacity, fp_rate).unwrap();
+            for &i in items {
+                f.insert(i).unwrap();
+            }
+            serde_cbor::to_vec(&f).unwrap()
+        }
+
+        // Small filter with a few usize items (exercises write_usize → write_u64 normalization)
+        let small = build_filter(&[1, 2, 3, 42, 100], 100, 0.01);
+        // Larger filter with sequential usize items
+        let seq = build_filter(&(0..50).collect::<Vec<_>>(), 100, 0.01);
+        // Filter with string items
+        let mut f = Filter::new(100, 0.01).unwrap();
+        for s in ["hello", "world", "foo", "bar"] {
+            f.insert(s).unwrap();
+        }
+        let strings = serde_cbor::to_vec(&f).unwrap();
+
+        // Hardcoded expected bytes — if these change, the hash algorithm or
+        // StableHasher normalization changed, breaking cross-platform compatibility.
+        // usize items exercise write_usize → write_u64 normalization (32-bit vs 64-bit).
+        assert_eq!(small, [165, 97, 98, 88, 154, 0, 0, 17, 0, 136, 0, 0, 0, 0, 0, 17, 0, 136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 0, 0, 160, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 14, 0, 0, 158, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 108, 5, 97, 113, 7, 97, 114, 7, 97, 109, 246]);
+        assert_eq!(seq, [165, 97, 98, 88, 154, 0, 6, 249, 12, 228, 11, 2, 36, 134, 6, 121, 13, 228, 11, 2, 68, 134, 0, 203, 30, 0, 0, 0, 0, 93, 0, 32, 162, 45, 167, 48, 91, 0, 189, 11, 0, 0, 0, 0, 192, 5, 0, 184, 14, 159, 164, 22, 224, 2, 0, 0, 0, 128, 35, 0, 0, 0, 0, 0, 0, 128, 0, 0, 184, 113, 1, 0, 11, 22, 0, 0, 0, 226, 0, 14, 74, 209, 193, 40, 72, 117, 144, 14, 74, 145, 195, 40, 72, 117, 144, 128, 110, 44, 15, 0, 0, 0, 0, 40, 224, 7, 0, 132, 1, 32, 0, 0, 0, 6, 220, 242, 126, 42, 0, 0, 0, 140, 1, 0, 0, 160, 11, 120, 1, 0, 0, 0, 0, 2, 0, 4, 1, 59, 128, 21, 224, 137, 121, 0, 0, 0, 0, 80, 6, 0, 120, 0, 0, 0, 0, 0, 0, 0, 0, 97, 108, 24, 50, 97, 113, 7, 97, 114, 7, 97, 109, 246]);
+        assert_eq!(strings, [165, 97, 98, 88, 154, 0, 32, 0, 0, 0, 0, 8, 0, 32, 32, 0, 0, 0, 0, 8, 0, 32, 0, 0, 0, 0, 72, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 160, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 108, 4, 97, 113, 7, 97, 114, 7, 97, 109, 246]);
+    }
 }

src/stable_hasher.rs

@@ -1,11 +1,10 @@
 use std::hash::{BuildHasher, Hasher};
 
-/// Wrapper over a hasher that provides stable output across platforms
-/// Based on https://github.com/rust-lang/rust/blob/c0955a34bcb17f0b31d7b86522a520ebe7fa93ac/src/librustc_data_structures/stable_hasher.rs#L78-L166
+/// Wrapper over a hasher that provides stable output across platforms.
 ///
-/// To that end we always convert integers to little-endian format before
-/// hashing and the architecture dependent `isize` and `usize` types are
-/// extended to 64 bits if needed.
+/// The architecture dependent `isize` and `usize` types are extended to
+/// 64 bits if needed. The `portable` feature of foldhash-portable handles
+/// endianness normalization internally.
 pub struct StableHasher {
     state: foldhash_portable::quality::FoldHasher<'static>,
 }
@@ -17,7 +16,6 @@ impl StableHasher {
             state: foldhash_portable::quality::FixedState::with_seed(0).build_hasher(),
         }
     }
-
 }
 
 impl Hasher for StableHasher {
@@ -38,30 +36,29 @@ impl Hasher for StableHasher {
 
     #[inline]
     fn write_u16(&mut self, i: u16) {
-        self.state.write_u16(i.to_le());
+        self.state.write_u16(i);
     }
 
     #[inline]
     fn write_u32(&mut self, i: u32) {
-        self.state.write_u32(i.to_le());
+        self.state.write_u32(i);
     }
 
     #[inline]
     fn write_u64(&mut self, i: u64) {
-        self.state.write_u64(i.to_le());
+        self.state.write_u64(i);
     }
 
     #[inline]
     fn write_u128(&mut self, i: u128) {
-        self.state.write_u128(i.to_le());
+        self.state.write_u128(i);
     }
 
     #[inline]
     fn write_usize(&mut self, i: usize) {
         // Always treat usize as u64 so we get the same results on 32 and 64 bit
-        // platforms. This is important for symbol hashes when cross compiling,
-        // for example.
-        self.state.write_u64((i as u64).to_le());
+        // platforms.
+        self.state.write_u64(i as u64);
     }
 
     #[inline]
@@ -71,30 +68,29 @@ impl Hasher for StableHasher {
 
     #[inline]
     fn write_i16(&mut self, i: i16) {
-        self.state.write_i16(i.to_le());
+        self.state.write_i16(i);
     }
 
     #[inline]
     fn write_i32(&mut self, i: i32) {
-        self.state.write_i32(i.to_le());
+        self.state.write_i32(i);
     }
 
     #[inline]
     fn write_i64(&mut self, i: i64) {
-        self.state.write_i64(i.to_le());
+        self.state.write_i64(i);
     }
 
     #[inline]
     fn write_i128(&mut self, i: i128) {
-        self.state.write_i128(i.to_le());
+        self.state.write_i128(i);
     }
 
     #[inline]
     fn write_isize(&mut self, i: isize) {
         // Always treat isize as i64 so we get the same results on 32 and 64 bit
-        // platforms. This is important for symbol hashes when cross compiling,
-        // for example.
-        self.state.write_i64((i as i64).to_le());
+        // platforms.
+        self.state.write_i64(i as i64);
     }
 }
 
@@ -117,4 +113,4 @@ impl BuildHasher for StableBuildHasher {
     fn build_hasher(&self) -> StableHasher {
         StableHasher::new()
     }
-}
+}