Function hash_collisions

libs/@local/hashql/core/src/intern/map.rs:989–1053

()

    #[test]
    fn hash_collisions() {
        // Create a type with controlled hash collisions
        #[derive(Debug, Copy, Clone, PartialEq, Eq)]
        struct CollisionValue {
            id: u32,
            collision_group: u32,
        }

        impl Hash for CollisionValue {
            fn hash<H: Hasher>(&self, state: &mut H) {
                // Only hash the collision_group, causing collisions
                self.collision_group.hash(state);
            }
        }

        #[derive(Debug, PartialEq, Eq, Hash)]
        struct CollisionType {
            id: TaggedId,
            value: CollisionValue,
        }

        impl HasId for CollisionType {
            type Id = TaggedId;

            fn id(&self) -> Self::Id {
                self.id
            }
        }

        impl<'heap> Decompose<'heap> for CollisionType {
            type Partial = CollisionValue;

            fn from_parts(id: TaggedId, partial: Interned<'heap, CollisionValue>) -> Self {
                Self {
                    id,
                    value: *partial.as_ref(),
                }
            }
        }

        let heap = Heap::new();
        let map = InternMap::<CollisionType>::new(&heap);

        // Create values with the same hash but different equality
        let value1 = map.intern_partial(CollisionValue {
            id: 1,
            collision_group: 42,
        });

        let value2 = map.intern_partial(CollisionValue {
            id: 2,
            collision_group: 42,
        });

        // They should have different IDs despite hash collision
        assert_ne!(value1.id(), value2.id());

        // Interning the same value again should return the same ID