fn hash_memo_for_state()

in shed/hash_memo/src/lib.rs [526:600]

• 55 lines of code
• 1 McCabe index (conditional complexity)

    fn hash_memo_for_state<I: BuildHasher>(factory: I) {
        let test_value = TestStruct::new("foo", 42);

        // Base case is MemoHasher, but no wrapper
        let exemplar = {
            let mut hasher = MemoHasher::<I>::new(factory.build_hasher());
            test_value.hash(&mut hasher);
            hasher.finish()
        };

        // Now introduce our factory
        let factory = BuildMemoHasher::<I>::new(factory);

        // Make sure base case is stable for MemoHasher
        {
            let new_value = TestStruct::new("foo", 42);
            let mut hasher = factory.build_hasher();
            new_value.hash(&mut hasher);
            assert_eq!(exemplar, hasher.finish());
        }

        // Make sure MemoHasher is not matching incorrectly
        {
            let new_value = TestStruct::new("bar", 21);
            let mut hasher = factory.build_hasher();
            new_value.hash(&mut hasher);
            assert_ne!(exemplar, hasher.finish());
        }

        let test_value = EagerHashMemoizer::new(TestStruct::new("foo", 42), &factory);
        // Make sure stable for MemoHasher + EagerHashMemoizer
        {
            let mut hasher = factory.build_hasher();
            test_value.hash(&mut hasher);
            assert_eq!(exemplar, hasher.finish());
        }

        // Make sure stable reuse for MemoHasher + EagerHashMemoizer, with no call to inner_hasher
        {
            let mut hasher = factory.build_hasher();
            test_value.hash(&mut hasher);
            assert_eq!(exemplar, hasher.finish());
        }

        // Make sure MemoHasher + EagerHashMemoizer is not matching incorrectly
        {
            let new_value = EagerHashMemoizer::new(TestStruct::new("bar", 21), &factory);
            let mut hasher = factory.build_hasher();
            new_value.hash(&mut hasher);
            assert_ne!(exemplar, hasher.finish());
        }

        let test_value = LazyHashMemoizer::new(TestStruct::new("foo", 42), &factory);
        // Make sure stable for MemoHasher + LazyHashMemoizer
        {
            let mut hasher = factory.build_hasher();
            test_value.hash(&mut hasher);
            assert_eq!(exemplar, hasher.finish());
        }

        // Make sure stable reuse for MemoHasher + LazyHashMemoizer, with no call to inner_hasher
        {
            let mut hasher = factory.build_hasher();
            test_value.hash(&mut hasher);
            assert_eq!(exemplar, hasher.finish());
        }

        // Make sure MemoHasher + LazyHashMemoizer is not matching incorrectly
        {
            let new_value = LazyHashMemoizer::new(TestStruct::new("bar", 21), &factory);
            let mut hasher = factory.build_hasher();
            new_value.hash(&mut hasher);
            assert_ne!(exemplar, hasher.finish());
        }
    }