code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/ahash-0.7.8/src/specialize.rs

@@ -1,239 +0,0 @@
-use core::hash::BuildHasher;
-use core::hash::Hash;
-use core::hash::Hasher;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(feature = "std")]
-extern crate std as alloc;
-
-#[cfg(feature = "specialize")]
-use crate::BuildHasherExt;
-#[cfg(feature = "specialize")]
-use alloc::string::String;
-#[cfg(feature = "specialize")]
-use alloc::vec::Vec;
-
-/// Provides a way to get an optimized hasher for a given data type.
-/// Rather than using a Hasher generically which can hash any value, this provides a way to get a specialized hash
-/// for a specific type. So this may be faster for primitive types.
-/// # Example
-/// ```
-/// use std::hash::BuildHasher;
-/// use ahash::RandomState;
-/// use ahash::CallHasher;
-///
-/// let hash_builder = RandomState::new();
-/// //...
-/// let value: u32 = 17;
-/// let hash = u32::get_hash(&value, &hash_builder);
-/// ```
-/// Note that the type used to invoke `get_hash` must be the same a the type of value passed.
-/// For example get a hasher specialized on `[u8]` can invoke:
-/// ```
-/// /// use std::hash::BuildHasher;
-/// # use ahash::RandomState;
-/// # use ahash::CallHasher;
-/// # let hash_builder = RandomState::new();
-/// let bytes: [u8; 4] = [1, 2, 3, 4];
-/// let hash = <[u8]>::get_hash(&bytes, &hash_builder);
-/// ```
-pub trait CallHasher {
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64;
-}
-
-#[cfg(not(feature = "specialize"))]
-impl<T> CallHasher for T
-where
-    T: Hash + ?Sized,
-{
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        let mut hasher = build_hasher.build_hasher();
-        value.hash(&mut hasher);
-        hasher.finish()
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl<T> CallHasher for T
-where
-    T: Hash + ?Sized,
-{
-    #[inline]
-    default fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        let mut hasher = build_hasher.build_hasher();
-        value.hash(&mut hasher);
-        hasher.finish()
-    }
-}
-
-macro_rules! call_hasher_impl {
-    ($typ:ty) => {
-        #[cfg(feature = "specialize")]
-        impl CallHasher for $typ {
-            #[inline]
-            fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-                build_hasher.hash_as_u64(value)
-            }
-        }
-    };
-}
-call_hasher_impl!(u8);
-call_hasher_impl!(u16);
-call_hasher_impl!(u32);
-call_hasher_impl!(u64);
-call_hasher_impl!(i8);
-call_hasher_impl!(i16);
-call_hasher_impl!(i32);
-call_hasher_impl!(i64);
-
-#[cfg(feature = "specialize")]
-impl CallHasher for u128 {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_fixed_length(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for i128 {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_fixed_length(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for usize {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_fixed_length(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for isize {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_fixed_length(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for [u8] {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_str(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for Vec<u8> {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_str(value)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl CallHasher for str {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_str(value)
-    }
-}
-
-#[cfg(all(feature = "specialize"))]
-impl CallHasher for String {
-    #[inline]
-    fn get_hash<H: Hash + ?Sized, B: BuildHasher>(value: &H, build_hasher: &B) -> u64 {
-        build_hasher.hash_as_str(value)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    #[cfg(feature = "specialize")]
-    pub fn test_specialized_invoked() {
-        let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
-        let shortened = u64::get_hash(&0, &build_hasher);
-        let mut hasher = AHasher::new_with_keys(1, 2);
-        0_u64.hash(&mut hasher);
-        assert_ne!(hasher.finish(), shortened);
-    }
-
-    /// Tests that some non-trivial transformation takes place.
-    #[test]
-    pub fn test_input_processed() {
-        let build_hasher = RandomState::with_seeds(2, 2, 2, 2);
-        assert_ne!(0, u64::get_hash(&0, &build_hasher));
-        assert_ne!(1, u64::get_hash(&0, &build_hasher));
-        assert_ne!(2, u64::get_hash(&0, &build_hasher));
-        assert_ne!(3, u64::get_hash(&0, &build_hasher));
-        assert_ne!(4, u64::get_hash(&0, &build_hasher));
-        assert_ne!(5, u64::get_hash(&0, &build_hasher));
-
-        assert_ne!(0, u64::get_hash(&1, &build_hasher));
-        assert_ne!(1, u64::get_hash(&1, &build_hasher));
-        assert_ne!(2, u64::get_hash(&1, &build_hasher));
-        assert_ne!(3, u64::get_hash(&1, &build_hasher));
-        assert_ne!(4, u64::get_hash(&1, &build_hasher));
-        assert_ne!(5, u64::get_hash(&1, &build_hasher));
-
-        let xored = u64::get_hash(&0, &build_hasher) ^ u64::get_hash(&1, &build_hasher);
-        assert_ne!(0, xored);
-        assert_ne!(1, xored);
-        assert_ne!(2, xored);
-        assert_ne!(3, xored);
-        assert_ne!(4, xored);
-        assert_ne!(5, xored);
-    }
-
-    #[test]
-    pub fn test_ref_independent() {
-        let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
-        assert_eq!(u8::get_hash(&&1, &build_hasher), u8::get_hash(&1, &build_hasher));
-        assert_eq!(u16::get_hash(&&2, &build_hasher), u16::get_hash(&2, &build_hasher));
-        assert_eq!(u32::get_hash(&&3, &build_hasher), u32::get_hash(&3, &build_hasher));
-        assert_eq!(u64::get_hash(&&4, &build_hasher), u64::get_hash(&4, &build_hasher));
-        assert_eq!(u128::get_hash(&&5, &build_hasher), u128::get_hash(&5, &build_hasher));
-        assert_eq!(
-            str::get_hash(&"test", &build_hasher),
-            str::get_hash("test", &build_hasher)
-        );
-        assert_eq!(
-            str::get_hash(&"test", &build_hasher),
-            String::get_hash(&"test".to_string(), &build_hasher)
-        );
-        #[cfg(feature = "specialize")]
-        assert_eq!(
-            str::get_hash(&"test", &build_hasher),
-            <[u8]>::get_hash("test".as_bytes(), &build_hasher)
-        );
-
-        let build_hasher = RandomState::with_seeds(10, 20, 30, 40);
-        assert_eq!(u8::get_hash(&&&1, &build_hasher), u8::get_hash(&1, &build_hasher));
-        assert_eq!(u16::get_hash(&&&2, &build_hasher), u16::get_hash(&2, &build_hasher));
-        assert_eq!(u32::get_hash(&&&3, &build_hasher), u32::get_hash(&3, &build_hasher));
-        assert_eq!(u64::get_hash(&&&4, &build_hasher), u64::get_hash(&4, &build_hasher));
-        assert_eq!(u128::get_hash(&&&5, &build_hasher), u128::get_hash(&5, &build_hasher));
-        assert_eq!(
-            str::get_hash(&&"test", &build_hasher),
-            str::get_hash("test", &build_hasher)
-        );
-        assert_eq!(
-            str::get_hash(&&"test", &build_hasher),
-            String::get_hash(&"test".to_string(), &build_hasher)
-        );
-        #[cfg(feature = "specialize")]
-        assert_eq!(
-            str::get_hash(&&"test", &build_hasher),
-            <[u8]>::get_hash(&"test".to_string().into_bytes(), &build_hasher)
-        );
-    }
-}

data/ext/cargo-vendor/ahash-0.7.8/tests/bench.rs

@@ -1,154 +0,0 @@
-use ahash::{CallHasher, RandomState};
-use criterion::*;
-use fxhash::FxHasher;
-use std::collections::hash_map::DefaultHasher;
-use std::hash::{Hash, Hasher};
-
-#[cfg(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-))]
-fn aeshash<H: Hash>(b: &H) -> u64 {
-    let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
-    H::get_hash(b, &build_hasher)
-}
-#[cfg(not(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-)))]
-fn aeshash<H: Hash>(_b: &H) -> u64 {
-    panic!("aes must be enabled")
-}
-
-#[cfg(not(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-)))]
-fn fallbackhash<H: Hash>(b: &H) -> u64 {
-    let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
-    H::get_hash(b, &build_hasher)
-}
-#[cfg(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-))]
-fn fallbackhash<H: Hash>(_b: &H) -> u64 {
-    panic!("aes must be disabled")
-}
-
-fn fnvhash<H: Hash>(b: &H) -> u64 {
-    let mut hasher = fnv::FnvHasher::default();
-    b.hash(&mut hasher);
-    hasher.finish()
-}
-
-fn siphash<H: Hash>(b: &H) -> u64 {
-    let mut hasher = DefaultHasher::default();
-    b.hash(&mut hasher);
-    hasher.finish()
-}
-
-fn fxhash<H: Hash>(b: &H) -> u64 {
-    let mut hasher = FxHasher::default();
-    b.hash(&mut hasher);
-    hasher.finish()
-}
-
-fn seahash<H: Hash>(b: &H) -> u64 {
-    let mut hasher = seahash::SeaHasher::default();
-    b.hash(&mut hasher);
-    hasher.finish()
-}
-
-const STRING_LENGTHS: [u32; 12] = [1, 3, 4, 7, 8, 15, 16, 24, 33, 68, 132, 1024];
-
-fn gen_strings() -> Vec<String> {
-    STRING_LENGTHS
-        .iter()
-        .map(|len| {
-            let mut string = String::default();
-            for pos in 1..=*len {
-                let c = (48 + (pos % 10) as u8) as char;
-                string.push(c);
-            }
-            string
-        })
-        .collect()
-}
-
-const U8_VALUE: u8 = 123;
-const U16_VALUE: u16 = 1234;
-const U32_VALUE: u32 = 12345678;
-const U64_VALUE: u64 = 1234567890123456;
-const U128_VALUE: u128 = 12345678901234567890123456789012;
-
-fn bench_ahash(c: &mut Criterion) {
-    let mut group = c.benchmark_group("aeshash");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(aeshash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(aeshash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(aeshash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(aeshash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(aeshash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(aeshash(s))));
-}
-
-fn bench_fallback(c: &mut Criterion) {
-    let mut group = c.benchmark_group("fallback");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(fallbackhash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(fallbackhash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(fallbackhash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(fallbackhash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(fallbackhash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(fallbackhash(s))));
-}
-
-fn bench_fx(c: &mut Criterion) {
-    let mut group = c.benchmark_group("fx");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(fxhash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(fxhash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(fxhash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(fxhash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(fxhash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(fxhash(s))));
-}
-
-fn bench_fnv(c: &mut Criterion) {
-    let mut group = c.benchmark_group("fnv");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(fnvhash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(fnvhash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(fnvhash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(fnvhash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(fnvhash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(fnvhash(s))));
-}
-
-fn bench_sea(c: &mut Criterion) {
-    let mut group = c.benchmark_group("sea");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(seahash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(seahash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(seahash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(seahash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(seahash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(seahash(s))));
-}
-
-fn bench_sip(c: &mut Criterion) {
-    let mut group = c.benchmark_group("sip");
-    group.bench_with_input("u8", &U8_VALUE, |b, s| b.iter(|| black_box(siphash(s))));
-    group.bench_with_input("u16", &U16_VALUE, |b, s| b.iter(|| black_box(siphash(s))));
-    group.bench_with_input("u32", &U32_VALUE, |b, s| b.iter(|| black_box(siphash(s))));
-    group.bench_with_input("u64", &U64_VALUE, |b, s| b.iter(|| black_box(siphash(s))));
-    group.bench_with_input("u128", &U128_VALUE, |b, s| b.iter(|| black_box(siphash(s))));
-    group.bench_with_input("string", &gen_strings(), |b, s| b.iter(|| black_box(siphash(s))));
-}
-
-criterion_main!(benches);
-criterion_group!(
-    benches,
-    bench_ahash,
-    bench_fallback,
-    bench_fx,
-    bench_fnv,
-    bench_sea,
-    bench_sip
-);

data/ext/cargo-vendor/ahash-0.7.8/tests/map_tests.rs

@@ -1,203 +0,0 @@
-use std::hash::{BuildHasher, Hash, Hasher};
-
-use criterion::*;
-use fxhash::FxHasher;
-
-use ahash::{AHasher, CallHasher, RandomState};
-
-fn gen_word_pairs() -> Vec<String> {
-    let words: Vec<_> = r#"
-a, ability, able, about, above, accept, according, account, across, act, action,
-activity, actually, add, address, administration, admit, adult, affect, after,
-again, against, age, agency, agent, ago, agree, agreement, ahead, air, all,
-allow, almost, alone, along, already, also, although, always, American, among,
-amount, analysis, and, animal, another, answer, any, anyone, anything, appear,
-apply, approach, area, argue, arm, around, arrive, art, article, artist, as,
-ask, assume, at, attack, attention, attorney, audience, author, authority,
-available, avoid, away, baby, back, bad, bag, ball, bank, bar, base, be, beat,
-beautiful, because, become, bed, before, begin, behavior, behind, believe,
-benefit, best, better, between, beyond, big, bill, billion, bit, black, blood,
-blue, board, body, book, born, both, box, boy, break, bring, brother, budget,
-build, building, business, but, buy, by, call, camera, campaign, can, cancer,
-candidate, capital, car, card, care, career, carry, case, catch, cause, cell,
-center, central, century, certain, certainly, chair, challenge, chance, change,
-character, charge, check, child, choice, choose, church, citizen, city, civil,
-claim, class, clear, clearly, close, coach, cold, collection, college, color,
-come, commercial, common, community, company, compare, computer, concern,
-condition, conference, Congress, consider, consumer, contain, continue, control,
-cost, could, country, couple, course, court, cover, create, crime, cultural,
-culture, cup, current, customer, cut, dark, data, daughter, day, dead, deal,
-death, debate, decade, decide, decision, deep, defense, degree, Democrat,
-democratic, describe, design, despite, detail, determine, develop, development,
-die, difference, different, difficult, dinner, direction, director, discover,
-discuss, discussion, disease, do, doctor, dog, door, down, draw, dream, drive,
-drop, drug, during, each, early, east, easy, eat, economic, economy, edge,
-education, effect, effort, eight, either, election, else, employee, end, energy,
-enjoy, enough, enter, entire, environment, environmental, especially, establish,
-even, evening, event, ever, every, everybody, everyone, everything, evidence,
-exactly, example, executive, exist, expect, experience, expert, explain, eye,
-face, fact, factor, fail, fall, family, far, fast, father, fear, federal, feel,
-feeling, few, field, fight, figure, fill, film, final, finally, financial, find,
-fine, finger, finish, fire, firm, first, fish, five, floor, fly, focus, follow,
-food, foot, for, force, foreign, forget, form, former, forward, four, free,
-friend, from, front, full, fund, future, game, garden, gas, general, generation,
-get, girl, give, glass, go, goal, good, government, great, green, ground, group,
-grow, growth, guess, gun, guy, hair, half, hand, hang, happen, happy, hard,
-have, he, head, health, hear, heart, heat, heavy, help, her, here, herself,
-high, him, himself, his, history, hit, hold, home, hope, hospital, hot, hotel,
-hour, house, how, however, huge, human, hundred, husband, I, idea, identify, if,
-image, imagine, impact, important, improve, in, include, including, increase,
-indeed, indicate, individual, industry, information, inside, instead,
-institution, interest, interesting, international, interview, into, investment,
-involve, issue, it, item, its, itself, job, join, just, keep, key, kid, kill,
-kind, kitchen, know, knowledge, land, language, large, last, late, later, laugh,
-law, lawyer, lay, lead, leader, learn, least, leave, left, leg, legal, less,
-let, letter, level, lie, life, light, like, likely, line, list, listen, little,
-live, local, long, look, lose, loss, lot, love, low, machine, magazine, main,
-maintain, major, majority, make, man, manage, management, manager, many, market,
-marriage, material, matter, may, maybe, me, mean, measure, media, medical, meet,
-meeting, member, memory, mention, message, method, middle, might, military,
-million, mind, minute, miss, mission, model, modern, moment, money, month, more,
-morning, most, mother, mouth, move, movement, movie, Mr, Mrs, much, music, must,
-my, myself, name, nation, national, natural, nature, near, nearly, necessary,
-need, network, never, new, news, newspaper, next, nice, night, no, none, nor,
-north, not, note, nothing, notice, now, n't, number, occur, of, off, offer,
-office, officer, official, often, oh, oil, ok, old, on, once, one, only, onto,
-open, operation, opportunity, option, or, order, organization, other, others,
-our, out, outside, over, own, owner, page, pain, painting, paper, parent, part,
-participant, particular, particularly, partner, party, pass, past, patient,
-pattern, pay, peace, people, per, perform, performance, perhaps, period, person,
-personal, phone, physical, pick, picture, piece, place, plan, plant, play,
-player, PM, point, police, policy, political, politics, poor, popular,
-population, position, positive, possible, power, practice, prepare, present,
-president, pressure, pretty, prevent, price, private, probably, problem,
-process, produce, product, production, professional, professor, program,
-project, property, protect, prove, provide, public, pull, purpose, push, put,
-quality, question, quickly, quite, race, radio, raise, range, rate, rather,
-reach, read, ready, real, reality, realize, really, reason, receive, recent,
-recently, recognize, record, red, reduce, reflect, region, relate, relationship,
-religious, remain, remember, remove, report, represent, Republican, require,
-research, resource, respond, response, responsibility, rest, result, return,
-reveal, rich, right, rise, risk, road, rock, role, room, rule, run, safe, same,
-save, say, scene, school, science, scientist, score, sea, season, seat, second,
-section, security, see, seek, seem, sell, send, senior, sense, series, serious,
-serve, service, set, seven, several, sex, sexual, shake, share, she, shoot,
-short, shot, should, shoulder, show, side, sign, significant, similar, simple,
-simply, since, sing, single, sister, sit, site, situation, six, size, skill,
-skin, small, smile, so, social, society, soldier, some, somebody, someone,
-something, sometimes, son, song, soon, sort, sound, source, south, southern,
-space, speak, special, specific, speech, spend, sport, spring, staff, stage,
-stand, standard, star, start, state, statement, station, stay, step, still,
-stock, stop, store, story, strategy, street, strong, structure, student, study,
-stuff, style, subject, success, successful, such, suddenly, suffer, suggest,
-summer, support, sure, surface, system, table, take, talk, task, tax, teach,
-teacher, team, technology, television, tell, ten, tend, term, test, than, thank,
-that, the, their, them, themselves, then, theory, there, these, they, thing,
-think, third, this, those, though, thought, thousand, threat, three, through,
-throughout, throw, thus, time, to, today, together, tonight, too, top, total,
-tough, toward, town, trade, traditional, training, travel, treat, treatment,
-tree, trial, trip, trouble, true, truth, try, turn, TV, two, type, under,
-understand, unit, until, up, upon, us, use, usually, value, various, very,
-victim, view, violence, visit, voice, vote, wait, walk, wall, want, war, watch,
-water, way, we, weapon, wear, week, weight, well, west, western, what, whatever,
-when, where, whether, which, while, white, who, whole, whom, whose, why, wide,
-wife, will, win, wind, window, wish, with, within, without, woman, wonder, word,
-work, worker, world, worry, would, write, writer, wrong, yard, yeah, year, yes,
-yet, you, young, your, yourself"#
-        .split(',')
-        .map(|word| word.trim())
-        .collect();
-
-    let mut word_pairs: Vec<_> = Vec::new();
-    for word in &words {
-        for other_word in &words {
-            word_pairs.push(word.to_string() + " " + other_word);
-        }
-    }
-    assert_eq!(1_000_000, word_pairs.len());
-    word_pairs
-}
-
-#[allow(unused)] // False positive
-fn test_hash_common_words<B: BuildHasher>(build_hasher: &B) {
-    let word_pairs: Vec<_> = gen_word_pairs();
-    check_for_collisions(build_hasher, &word_pairs, 32);
-}
-
-#[allow(unused)] // False positive
-fn check_for_collisions<H: Hash, B: BuildHasher>(build_hasher: &B, items: &[H], bucket_count: usize) {
-    let mut buckets = vec![0; bucket_count];
-    for item in items {
-        let value = hash(item, build_hasher) as usize;
-        buckets[value % bucket_count] += 1;
-    }
-    let mean = items.len() / bucket_count;
-    let max = *buckets.iter().max().unwrap();
-    let min = *buckets.iter().min().unwrap();
-    assert!(
-        (min as f64) > (mean as f64) * 0.95,
-        "min: {}, max:{}, {:?}",
-        min,
-        max,
-        buckets
-    );
-    assert!(
-        (max as f64) < (mean as f64) * 1.05,
-        "min: {}, max:{}, {:?}",
-        min,
-        max,
-        buckets
-    );
-}
-
-#[allow(unused)] // False positive
-fn hash<H: Hash, B: BuildHasher>(b: &H, build_hasher: &B) -> u64 {
-    H::get_hash(b, build_hasher)
-}
-
-#[test]
-fn test_bucket_distribution() {
-    let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
-    test_hash_common_words(&build_hasher);
-    let sequence: Vec<_> = (0..320000).collect();
-    check_for_collisions(&build_hasher, &sequence, 32);
-    let sequence: Vec<_> = (0..2560000).collect();
-    check_for_collisions(&build_hasher, &sequence, 256);
-    let sequence: Vec<_> = (0..320000).map(|i| i * 1024).collect();
-    check_for_collisions(&build_hasher, &sequence, 32);
-    let sequence: Vec<_> = (0..2560000_u64).map(|i| i * 1024).collect();
-    check_for_collisions(&build_hasher, &sequence, 256);
-}
-
-fn ahash_vec<H: Hash>(b: &Vec<H>) -> u64 {
-    let mut total: u64 = 0;
-    for item in b {
-        let mut hasher = AHasher::new_with_keys(1234, 5678);
-        item.hash(&mut hasher);
-        total = total.wrapping_add(hasher.finish());
-    }
-    total
-}
-
-fn fxhash_vec<H: Hash>(b: &Vec<H>) -> u64 {
-    let mut total: u64 = 0;
-    for item in b {
-        let mut hasher = FxHasher::default();
-        item.hash(&mut hasher);
-        total = total.wrapping_add(hasher.finish());
-    }
-    total
-}
-
-fn bench_ahash_words(c: &mut Criterion) {
-    let words = gen_word_pairs();
-    c.bench_function("aes_words", |b| b.iter(|| black_box(ahash_vec(&words))));
-}
-
-fn bench_fx_words(c: &mut Criterion) {
-    let words = gen_word_pairs();
-    c.bench_function("fx_words", |b| b.iter(|| black_box(fxhash_vec(&words))));
-}
-
-criterion_main!(benches);
-criterion_group!(benches, bench_ahash_words, bench_fx_words,);

data/ext/cargo-vendor/ahash-0.7.8/tests/nopanic.rs

@@ -1,72 +0,0 @@
-use ahash::{AHasher, CallHasher, RandomState};
-use std::hash::BuildHasher;
-
-#[macro_use]
-extern crate no_panic;
-
-#[inline(never)]
-#[no_panic]
-fn hash_test_final(num: i32, string: &str) -> (u64, u64) {
-    use core::hash::Hasher;
-    let mut hasher1 = AHasher::new_with_keys(1, 2);
-    let mut hasher2 = AHasher::new_with_keys(3, 4);
-    hasher1.write_i32(num);
-    hasher2.write(string.as_bytes());
-    (hasher1.finish(), hasher2.finish())
-}
-
-#[inline(never)]
-fn hash_test_final_wrapper(num: i32, string: &str) {
-    hash_test_final(num, string);
-}
-
-struct SimpleBuildHasher {
-    hasher: AHasher,
-}
-
-impl BuildHasher for SimpleBuildHasher {
-    type Hasher = AHasher;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        self.hasher.clone()
-    }
-}
-
-#[inline(never)]
-#[no_panic]
-fn hash_test_specialize(num: i32, string: &str) -> (u64, u64) {
-    let hasher1 = AHasher::new_with_keys(1, 2);
-    let hasher2 = AHasher::new_with_keys(1, 2);
-    (
-        i32::get_hash(&num, &SimpleBuildHasher { hasher: hasher1 }),
-        <[u8]>::get_hash(string.as_bytes(), &SimpleBuildHasher { hasher: hasher2 }),
-    )
-}
-
-#[inline(never)]
-fn hash_test_random_wrapper(num: i32, string: &str) {
-    hash_test_specialize(num, string);
-}
-
-#[inline(never)]
-#[no_panic]
-fn hash_test_random(num: i32, string: &str) -> (u64, u64) {
-    let build_hasher1 = RandomState::with_seeds(1, 2, 3, 4);
-    let build_hasher2 = RandomState::with_seeds(1, 2, 3, 4);
-    (
-        i32::get_hash(&num, &build_hasher1),
-        <[u8]>::get_hash(string.as_bytes(), &build_hasher2),
-    )
-}
-
-#[inline(never)]
-fn hash_test_specialize_wrapper(num: i32, string: &str) {
-    hash_test_specialize(num, string);
-}
-
-#[test]
-fn test_no_panic() {
-    hash_test_final_wrapper(2, "Foo");
-    hash_test_specialize_wrapper(2, "Bar");
-    hash_test_random_wrapper(2, "Baz");
-}

data/ext/cargo-vendor/bindgen-0.69.5/.cargo-checksum.json

@@ -1 +0,0 @@
-{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"2e366e2bc7bc2c80f2b255275e9e83a819cdf41273112c6fb5715655b3e381b7","Cargo.toml":"d10d6f86983b40b72ffa5ae86c2c4452ca004c11af5d9f7213fc8a4ed198064f","Cargo.toml.orig":"42ff550b0258e6b123ec5c6de05a7e9bd2dfd9fe04c4b1d99d194ec98cdad6cc","LICENSE":"c23953d9deb0a3312dbeaf6c128a657f3591acee45067612fa68405eaa4525db","README.md":"b2334e4077a9bc329516e3e0c7f89887c4f073647d95fb71b6917edf4c310ba3","build.rs":"4a9c4ac3759572e17de312a9d3f4ced3b6fd3c71811729e5a8d06bfbd1ac8f82","callbacks.rs":"cd5a1b0fc665b034d97615d0b6817cbef299dbf5276254c7e63f1c29674993ad","clang.rs":"e6477425453f7abd21b0b1cf8ee455bda3bf0cb4c567630c088d43ac87897815","codegen/bitfield_unit.rs":"fddeaeab5859f4e82081865595b7705f5c0774d997df95fa5c655b81b9cae125","codegen/bitfield_unit_tests.rs":"9df86490de5e9d66ccea583dcb686dd440375dc1a3c3cf89a89d5de3883bf28a","codegen/dyngen.rs":"6d8bed53c6de66bc658b3186041c2b75549f49b0f0363ff18b87c8dcf2f5a05b","codegen/error.rs":"0c3d198f4866ccbbcd8b1136fc5cfd2507a9eca5ab85934af29a7e2a7d8d8c2a","codegen/helpers.rs":"443a2c3495185ced2a9d68c02204bebfa8c4186f4275bf9ed3af90c3a3e159d7","codegen/impl_debug.rs":"80df6136327b1ca8c7d1c2961290b5ab00b85b49b22c02f26a590bc68fb230af","codegen/impl_partialeq.rs":"db739d7ba6f5ba4033d6bf62c276f35217c20eab27230cf07dadf59e8b2f71bb","codegen/mod.rs":"206e4e2c14cec17c13d11e568557332b51ce1e41ce8128182de44dab69221662","codegen/postprocessing/merge_extern_blocks.rs":"284457a3c75e945217bab4e5a4280fef0fcc03c31e12cc5010aab87f34c0b6c7","codegen/postprocessing/mod.rs":"160a6d6701cabf2514e23570df1bd1b648c909cc27b7c583f21d98fe0c16722e","codegen/postprocessing/sort_semantically.rs":"f465d1e8cc119082eb79c164b5cd780a370821e8bf56585b287dd3b51fc4a542","codegen/serialize.rs":"1f1eb8b04fec9655dc302442451f9622ad6365eb37bf588a119a60e79f37002c","codegen/struct_layout.rs":"922cc71fb309716879aeea4775bbc29751ca5d431083ca83d7beb0a90862a302","deps.rs":"af3dd24a7808b5abf0c4ed4b10bbceb8eef32be980ff085b8a766d8f089af1a4","diagnostics.rs":"dc40cd5e9710922422c5c9420e2351f5d976e7a1d7275e4f4ce742cad9eb53f8","extra_assertions.rs":"fb4484c0e9fcbea9ec7265f5fbd01e2b33ac022b2b17e060dce7886819d57e40","features.rs":"b27adc6bb50e9aae50fd75568a7576382c6409f585b6be0047d7a9314c98d569","ir/analysis/derive.rs":"cba290e9c4ba271e90524149ad3b874f37843bfdfab12d513cc85d2665447fd5","ir/analysis/has_destructor.rs":"e7e95c3b0989b6375cd3eabaac85a36ecc2915a1fd3700c7d26fe04e8dc83ba3","ir/analysis/has_float.rs":"a56b97bf913f132c2c63dc202b45c692c416a8c9fdc6b2baeee30362fb0d4405","ir/analysis/has_type_param_in_array.rs":"788ebb4ba2cf46a22f1e4ff3005d51f38d414b72e95355f7ff4125521e2d9525","ir/analysis/has_vtable.rs":"83efa40ae89147170eabdff1387e60aba574ca4cd4cdef22692753594f09d6c6","ir/analysis/mod.rs":"9d949c27451da4ed72994b31c04ddeb89eeb342fd23ea572d3962d4ccf774841","ir/analysis/sizedness.rs":"f0a9302f3c6ad694d76cfab11dbaf5392ecaf7f04bc7b211a5a003776b963896","ir/analysis/template_params.rs":"3ff27e2198e292a348876aa1faba39cc4b1870a24a7e173feac0b3c592001e13","ir/annotations.rs":"5ed03d025862d0d21852a76c86a993772624e123fdc3752415d588a0b4e643ab","ir/comment.rs":"4c9c20b5a3da086211e92adec0822831dbc0b7ebee98fee313edcae9ae8d55ec","ir/comp.rs":"c048866353695ac8190ab03511123be82d34ca73fb865a2578cb5a2e04390431","ir/context.rs":"03175218512c42792aae7b56a764c0237a447664dda5f1a8269a42bed46d3be2","ir/derive.rs":"c21e470bb0091f20bfa366110880d48984fc3cf7071fdf36eccfa64f3eca231c","ir/dot.rs":"75bdfd83d9e754ba726f6a5529ba1d9ff46f5bf49bf237452985eb008fed0854","ir/enum_ty.rs":"f4bfa6d18ba4977fb66f5d5e4a7674eded93b761404d91cdd6fdd50029db455a","ir/function.rs":"0ecee923382b0a49265bc970ac90a73740ec5ba3c33466b2cfe8aa462df59bd5","ir/int.rs":"601736f0ad0949e40684a9ce89bafbfefa71743df6ee6c342e44888a0f141ae0","ir/item.rs":"65f2351dd3971d8a76470a78f5b6b1ebdda067ab5bae4641246aa986d9579e29","ir/item_kind.rs":"33e21104b0bb824a696a52cd520567ae56158010a1df14777e68ac5f8ad7e8fa","ir/layout.rs":"8fbafc0eeee17abb703a18613be1066e38838d4b67f5916f714bf545e545bc1a","ir/mod.rs":"a3b98b1732111a980a795c72eaf1e09101e842ef2de76b4f2d4a7857f8d4cee4","ir/module.rs":"b2961ffa4acb0c19f084c5db084b8a17bda7158066782a73b80ee7d838789bf9","ir/objc.rs":"8f57a9180d57a690449f20ed1be80209db5f8a410bb067ae8bf5e0ecab16a5e4","ir/template.rs":"3f59efa9670ca90215d4374be869c9dbecb98a8d1041e7c6e4ab69a62bb982c2","ir/traversal.rs":"a4ec73d3533d4b93386153baf6a2ca846ee51228c76ed51105229d3ddcd74466","ir/ty.rs":"fd71d11e89e085921317349e1912ab56e7335d870c2d25df9e13a8ffbd6430c9","ir/var.rs":"40d18226706de0ee5f002d0b5617dbcba35de0605edd531c75e3a76d000f0f4f","lib.rs":"7496f72a177b5965ed56a2ab9af0f64e70abbc53cc6c196a15e6760dd6235adf","log_stubs.rs":"9f974e041e35c8c7e29985d27ae5cd0858d68f8676d1dc005c6388d7d011707f","options/as_args.rs":"76efa4e662cc7f89ef1c1fe089d03a3c1c019ffe2aa0a30a4d49ed41e987d1c7","options/helpers.rs":"f4a7681e29b2dcc3be9249478c499d685b9e29d4f4ca4ae8bff7a91668cd8f15","options/mod.rs":"1805cec86c563633b29b57292287c9efd3b5c724132ec1c13acee57858942e74","parse.rs":"fce3616e0464aa7414888e5d00d4df18c83bb3034a1c807d36a07a3c586e475a","regex_set.rs":"b411d64bc803947a3f69dcedcd7d03716aacbc7b1c5148b82de1cc469d9336d9","time.rs":"8efe317e7c6b5ba8e0865ce7b49ca775ee8a02590f4241ef62f647fa3c22b68e"},"package":"271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"}