[WIP] upgrade to stable xxh3 (v0.8.0)

Cargo.toml

@@ -16,7 +16,7 @@ license = "MIT"
 
 [dependencies]
 cfg-if = { version = "0.1", default-features = false }
-static_assertions = { version = "1.0", default-features = false }
+static_assertions = { version = "1.1", default-features = false }
 rand = { version = ">= 0.3.10, < 0.8", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true}
 digest = { version = "0.9", default-features = false, optional = true  }

comparison/src/c_xxhash.rs

@@ -16,17 +16,17 @@ mod ffi {
     }
 
     extern "C" {
-        pub fn XXH32(input: *const c_void, length: size_t, seed: u32) -> XXH32_hash_t;
-        pub fn XXH64(input: *const c_void, length: size_t, seed: u64) -> XXH64_hash_t;
+        pub fn XXH32(input: *const c_void, length: size_t, seed: XXH32_hash_t) -> XXH32_hash_t;
+        pub fn XXH64(input: *const c_void, length: size_t, seed: XXH64_hash_t) -> XXH64_hash_t;
         pub fn XXH3_64bits_withSeed(
-            data: *const ::std::os::raw::c_void,
-            len: usize,
-            seed: ::std::os::raw::c_ulonglong,
+            data: *const c_void,
+            len: size_t,
+            seed: XXH64_hash_t,
         ) -> XXH64_hash_t;
         pub fn XXH3_128bits_withSeed(
-            data: *const ::std::os::raw::c_void,
-            len: usize,
-            seed: ::std::os::raw::c_ulonglong,
+            data: *const c_void,
+            len: size_t,
+            seed: XXH64_hash_t,
         ) -> XXH128_hash_t;
     }
 }

comparison/src/lib.rs

@@ -3,7 +3,7 @@
 use proptest::{collection::vec as propvec, prelude::*};
 use std::hash::Hasher;
 #[cfg(test)]
-use twox_hash::{XxHash32, XxHash64};
+use twox_hash::{xxh3, HasherExt, XxHash32, XxHash64};
 
 pub mod c_xxhash;
 
@@ -12,6 +12,12 @@ pub fn hash_once(mut hasher: impl Hasher, data: &[u8]) -> u64 {
     hasher.finish()
 }
 
+#[cfg(test)]
+pub fn hash_once_ext(mut hasher: impl HasherExt, data: &[u8]) -> u128 {
+    hasher.write(&data);
+    hasher.finish_ext()
+}
+
 #[cfg(test)]
 fn hash_by_chunks(mut hasher: impl Hasher, mut data: &[u8], chunk_sizes: &[usize]) -> u64 {
     for &chunk_size in chunk_sizes {
@@ -23,6 +29,17 @@ fn hash_by_chunks(mut hasher: impl Hasher, mut data: &[u8], chunk_sizes: &[usize
     hasher.finish()
 }
 
+#[cfg(test)]
+fn hash_by_chunks_ext(mut hasher: impl HasherExt, mut data: &[u8], chunk_sizes: &[usize]) -> u128 {
+    for &chunk_size in chunk_sizes {
+        let (this_chunk, remaining) = data.split_at(chunk_size);
+        hasher.write(this_chunk);
+        data = remaining;
+    }
+
+    hasher.finish_ext()
+}
+
 prop_compose! {
     fn data_and_offset
         ()
@@ -81,6 +98,41 @@ proptest! {
 
         prop_assert_eq!(our_result, their_result as u64);
     }
+
+    #[test]
+    fn same_results_as_c_for_xxh3_64_bit(seed: u64, data: Vec<u8>) {
+        let our_result = hash_once(xxh3::Hash64::with_seed(seed), &data);
+        let their_result = c_xxhash::xxh3_hash64(&data, seed);
+
+        prop_assert_eq!(our_result, their_result);
+    }
+
+    #[test]
+    fn same_results_as_c_with_offset_for_xxh3_64_bit(seed: u64, (data, offset) in data_and_offset()) {
+        let data = &data[offset..];
+        let our_result = hash_once(xxh3::Hash64::with_seed(seed), data);
+        let their_result = c_xxhash::xxh3_hash64(data, seed);
+
+        prop_assert_eq!(our_result, their_result);
+    }
+
+    #[test]
+    fn same_results_as_c_for_xxh3_128_bit(seed: u64, data: Vec<u8>) {
+        let our_result = hash_once_ext(xxh3::Hash128::with_seed(seed), &data);
+        let their_result = c_xxhash::xxh3_hash128(&data, seed);
+
+        prop_assert_eq!(our_result, their_result);
+    }
+
+    #[test]
+    fn same_results_as_c_with_offset_for_xxh3_128_bit(seed: u64, (data, offset) in data_and_offset()) {
+        let data = &data[offset..];
+        let our_result = hash_once_ext(xxh3::Hash128::with_seed(seed), data);
+        let their_result = c_xxhash::xxh3_hash128(data, seed);
+
+        prop_assert_eq!(our_result, their_result);
+    }
+
 }
 
 proptest! {
@@ -101,4 +153,21 @@ proptest! {
 
         prop_assert_eq!(chunked_result, monolithic_result);
     }
+
+    #[test]
+    fn same_results_with_many_chunks_as_one_for_xxh3_64_bit(seed: u64, (data, chunk_sizes) in data_and_chunk_sizes()) {
+        let chunked_result = hash_by_chunks(xxh3::Hash64::with_seed(seed), &data, &chunk_sizes);
+        let monolithic_result = hash_once(xxh3::Hash64::with_seed(seed), &data);
+
+        prop_assert_eq!(chunked_result, monolithic_result);
+    }
+
+    #[test]
+    fn same_results_with_many_chunks_as_one_for_xxh3_128_bit(seed: u64, (data, chunk_sizes) in data_and_chunk_sizes()) {
+        let chunked_result = hash_by_chunks_ext(xxh3::Hash128::with_seed(seed), &data, &chunk_sizes);
+        let monolithic_result = hash_once_ext(xxh3::Hash128::with_seed(seed), &data);
+
+        prop_assert_eq!(chunked_result, monolithic_result);
+    }
+
 }

src/lib.rs

@@ -55,7 +55,7 @@ mod digest_support;
 
 pub use crate::sixty_four::XxHash64;
 pub use crate::thirty_two::XxHash32;
-pub use crate::xxh3::{Hash128 as Xxh3Hash128, Hash64 as Xxh3Hash64};
+pub use crate::xxh3::{Hash128 as Xxh3Hash128, Hash64 as Xxh3Hash64, HasherExt};
 
 /// A backwards compatibility type alias. Consider directly using
 /// `XxHash64` instead.