roc/compiler/gen/tests/gen_hash.rs

#[macro_use]
extern crate pretty_assertions;
#[macro_use]
extern crate indoc;

extern crate bumpalo;
extern crate inkwell;
extern crate libc;
extern crate roc_gen;

#[macro_use]
mod helpers;

#[cfg(test)]
mod gen_hash {

    #[test]
    fn basic_hash() {
        assert_evals_to!(
            indoc!(
                r#"
                    Dict.hashTestOnly 0 0
                "#
            ),
            9718519427346233646,
            u64
        );
    }

    #[test]
    fn hash_str_with_seed() {
        assert_evals_to!("Dict.hashTestOnly 1 \"a\"", 0xbed235177f41d328, u64);
        assert_evals_to!("Dict.hashTestOnly 2 \"abc\"", 0xbe348debe59b27c3, u64);
    }

    #[test]
    fn hash_record() {
        assert_evals_to!("Dict.hashTestOnly 1 { x: \"a\" } ", 0xbed235177f41d328, u64);
        assert_evals_to!(
            "Dict.hashTestOnly 1 { x: 42, y: 3.14 } ",
            5348189196103430707,
            u64
        );
    }

    #[test]
    fn hash_result() {
        assert_evals_to!(
            "Dict.hashTestOnly 0 (List.get [ 0x1 ] 0) ",
            2878521786781103245,
            u64
        );
    }

    #[test]
    fn hash_linked_list() {
        assert_evals_to!(
            indoc!(
                r#"
                    LinkedList a : [ Nil, Cons a (LinkedList a) ]

                    input : LinkedList I64
                    input = Nil

                    Dict.hashTestOnly 0 input 
                "#
            ),
            0,
            u64
        );

        assert_evals_to!(
            indoc!(
                r#"
                    LinkedList a : [ Nil, Cons a (LinkedList a) ]

                    input : LinkedList I64
                    input = Cons 4 (Cons 3 Nil)

                    Dict.hashTestOnly 0 input 
                "#
            ),
            8287696503006938486,
            u64
        );
    }

    #[test]
    fn hash_expr() {
        assert_evals_to!(
            indoc!(
                r#"
                    Expr : [ Add Expr Expr, Mul Expr Expr, Val I64, Var I64 ]

                    x : Expr 
                    x = Val 1

                    Dict.hashTestOnly 0 (Add x x) 
                "#
            ),
            18264046914072177411,
            u64
        );
    }

    #[test]
    fn hash_nullable_expr() {
        assert_evals_to!(
            indoc!(
                r#"
                    Expr : [ Add Expr Expr, Mul Expr Expr, Val I64, Empty ]

                    x : Expr 
                    x = Val 1

                    Dict.hashTestOnly 0 (Add x x) 
                "#
            ),
            11103255846683455235,
            u64
        );
    }

    #[test]
    fn hash_rosetree() {
        assert_evals_to!(
            indoc!(
                r#"
                Rose a : [ Rose (List (Rose a)) ]

                x : Rose I64 
                x = Rose [] 

                Dict.hashTestOnly 0 x
                "#
            ),
            0,
            u64
        );
    }

    #[test]
    fn hash_list() {
        assert_evals_to!(
            indoc!(
                r#"
                x : List Str 
                x = [ "foo", "bar", "baz" ] 

                Dict.hashTestOnly 0 x
                "#
            ),
            10731521034618280801,
            u64
        );
    }
}