fn equality_lazy()

in shed/hash_memo/src/lib.rs [315:385]

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

    fn equality_lazy<I: BuildHasher + Clone>(factory: I) {
        let a = LazyHashMemoizer::new(TestStruct::new("foo", 42), &factory);
        let b = LazyHashMemoizer::new(TestStruct::new("bar", 21), &factory);
        assert_ne!(a, b);

        let c = LazyHashMemoizer::new(TestStruct::new("foo", 42), &factory);
        assert_eq!(a, c);

        // Borrow base case sanity check
        let r = TestStruct::new("foo", 42);
        {
            let borrow: &TestStruct = c.borrow();
            assert_eq!(borrow, &r);
        }

        // Test map of inner works with memo + regular hasher
        {
            let mut m = HashMap::with_hasher(factory.clone());
            // make it big enough there are multiple buckets
            for i in 0..1000 {
                m.insert(TestStruct::new("foo", i), i);
            }
            assert_eq!(Some(&42), m.get(&c));
            assert_eq!(Some(&42), m.get(&r));
            assert_eq!(None, m.get(&b));
        }

        // Test map of memo works with memo + regular hasher
        {
            let mut m =
                HashMap::<LazyHashMemoizer<TestStruct, I>, u32, I>::with_hasher(factory.clone());
            for i in 0..1000 {
                m.insert(
                    LazyHashMemoizer::new(TestStruct::new("foo", i), &factory),
                    i,
                );
            }
            // Fine, even though not using the memo hasher lazy memo lookup is consistent
            assert_eq!(Some(&42), m.get(&c));
            // To have the map borrow lookup work one must be using the MemoHasher
            // Which is why this returns None
            assert_eq!(None, m.get(&r));
            assert_eq!(None, m.get(&b));
        }

        // Test map of inner works with memo + our hasher
        let factory = BuildMemoHasher::new(factory.clone());
        {
            let mut m = HashMap::with_hasher(factory.clone());
            for i in 0..1000 {
                m.insert(TestStruct::new("foo", i), i);
            }
            assert_eq!(Some(&42), m.get(&c));
            assert_eq!(Some(&42), m.get(&r));
            assert_eq!(None, m.get(&b));
        }

        // Test map of memo works with memo + our hasher
        {
            let mut m = HashMap::with_hasher(factory.clone());
            for i in 0..1000 {
                let a = LazyHashMemoizer::new(TestStruct::new("foo", i), &factory);
                m.insert(a.clone(), i);
                assert_eq!(Some(&i), m.get(&a));
            }

            assert_eq!(Some(&42), m.get(&c));
            assert_eq!(Some(&42), m.get(&r));
            assert_eq!(None, m.get(&b));
        }
    }