mirror of
https://github.com/rust-lang/rust.git
synced 2026-05-28 20:16:58 +03:00
Nicholas Nethercote
ccc3c01162
The `HashStable` and `ToStableHashKey` traits both have a type parameter that is sometimes called `CTX` and sometimes called `HCX`. (In practice this type parameter is always instantiated as `StableHashingContext`.) Similarly, variables with these types are sometimes called `ctx` and sometimes called `hcx`. This inconsistency has bugged me for some time. The `HCX`/`hcx` form is more informative (the `H`/`h` indicates what type of context it is) and it matches other cases like `tcx`, `dcx`, `icx`. Also, RFC 430 says that type parameters should have names that are "concise UpperCamelCase, usually single uppercase letter: T". In this case `H` feels insufficient, and `Hcx` feels better. Therefore, this commit changes the code to use `Hcx`/`hcx` everywhere.
99 lines
3.0 KiB
Rust
99 lines
3.0 KiB
Rust
use super::*;
|
|
|
|
// The tests below compare the computed hashes to particular expected values
|
|
// in order to test that we produce the same results on different platforms,
|
|
// regardless of endianness and `usize` and `isize` size differences (this
|
|
// of course assumes we run these tests on platforms that differ in those
|
|
// ways). The expected values depend on the hashing algorithm used, so they
|
|
// need to be updated whenever StableHasher changes its hashing algorithm.
|
|
|
|
fn hash<T: HashStable<()>>(t: &T) -> Hash128 {
|
|
let mut h = StableHasher::new();
|
|
let ctx = &mut ();
|
|
t.hash_stable(ctx, &mut h);
|
|
h.finish()
|
|
}
|
|
|
|
// Check that bit set hash includes the domain size.
|
|
#[test]
|
|
fn test_hash_bit_set() {
|
|
use rustc_index::bit_set::DenseBitSet;
|
|
let a: DenseBitSet<usize> = DenseBitSet::new_empty(1);
|
|
let b: DenseBitSet<usize> = DenseBitSet::new_empty(2);
|
|
assert_ne!(a, b);
|
|
assert_ne!(hash(&a), hash(&b));
|
|
}
|
|
|
|
// Check that bit matrix hash includes the matrix dimensions.
|
|
#[test]
|
|
fn test_hash_bit_matrix() {
|
|
use rustc_index::bit_set::BitMatrix;
|
|
let a: BitMatrix<usize, usize> = BitMatrix::new(1, 1);
|
|
let b: BitMatrix<usize, usize> = BitMatrix::new(1, 2);
|
|
assert_ne!(a, b);
|
|
assert_ne!(hash(&a), hash(&b));
|
|
}
|
|
|
|
// Check that exchanging the value of two adjacent fields changes the hash.
|
|
#[test]
|
|
fn test_attribute_permutation() {
|
|
macro_rules! test_type {
|
|
($ty: ty) => {{
|
|
struct Foo {
|
|
a: $ty,
|
|
b: $ty,
|
|
}
|
|
|
|
impl<Hcx> HashStable<Hcx> for Foo {
|
|
fn hash_stable(&self, hcx: &mut Hcx, hasher: &mut StableHasher) {
|
|
self.a.hash_stable(hcx, hasher);
|
|
self.b.hash_stable(hcx, hasher);
|
|
}
|
|
}
|
|
|
|
#[allow(overflowing_literals)]
|
|
let mut item = Foo { a: 0xFF, b: 0xFF_FF };
|
|
let hash_a = hash(&item);
|
|
std::mem::swap(&mut item.a, &mut item.b);
|
|
let hash_b = hash(&item);
|
|
assert_ne!(
|
|
hash_a,
|
|
hash_b,
|
|
"The hash stayed the same after values were swapped for type `{}`!",
|
|
stringify!($ty)
|
|
);
|
|
}};
|
|
}
|
|
|
|
test_type!(u16);
|
|
test_type!(u32);
|
|
test_type!(u64);
|
|
test_type!(u128);
|
|
|
|
test_type!(i16);
|
|
test_type!(i32);
|
|
test_type!(i64);
|
|
test_type!(i128);
|
|
}
|
|
|
|
// Check that the `isize` hashing optimization does not produce the same hash when permuting two
|
|
// values.
|
|
#[test]
|
|
fn test_isize_compression() {
|
|
fn check_hash(a: u64, b: u64) {
|
|
let hash_a = hash(&(a as isize, b as isize));
|
|
let hash_b = hash(&(b as isize, a as isize));
|
|
assert_ne!(
|
|
hash_a, hash_b,
|
|
"The hash stayed the same when permuting values `{a}` and `{b}`!",
|
|
);
|
|
}
|
|
|
|
check_hash(0xAA, 0xAAAA);
|
|
check_hash(0xFF, 0xFFFF);
|
|
check_hash(0xAAAA, 0xAAAAAA);
|
|
check_hash(0xAAAAAA, 0xAAAAAAAA);
|
|
check_hash(0xFF, 0xFFFFFFFFFFFFFFFF);
|
|
check_hash(u64::MAX /* -1 */, 1);
|
|
}
|