test/test_sem_hm_gamma.c

   1 #include <stdbool.h>
   2 #include <stdlib.h>
   3 #include <check.h>
   4
   5 #include "../sem/hm/gamma.h"
   6 #include "../sem/hm/subst.h"
   7 #include "../sem/hm/scheme.h"
   8
   9 START_TEST(test_gamma_lookup)
  10 {
  11         struct gamma *gamma = gamma_init();
  12
  13         ck_assert_ptr_null(gamma_lookup(gamma, "fun"));
  14         ck_assert_ptr_null(gamma_lookup(gamma, "fun2"));
  15
  16         gamma_insert(gamma, "fun", scheme_generalise(gamma, type_basic(btint)));
  17
  18         ck_assert_ptr_nonnull(gamma_lookup(gamma, "fun"));
  19         ck_assert_ptr_null(gamma_lookup(gamma, "fun2"));
  20
  21         struct type *t1 = gamma_fresh(gamma);
  22         ck_assert(t1->type == tvar);
  23         struct type *t2 = gamma_fresh(gamma);
  24         ck_assert(t2->type == tvar);
  25         struct type *t3 = gamma_fresh(gamma);
  26         ck_assert(t3->type == tvar);
  27         struct type *t4 = gamma_fresh(gamma);
  28         ck_assert(t4->type == tvar);
  29
  30         ck_assert_str_ne(t1->data.tvar, t2->data.tvar);
  31         ck_assert_str_ne(t2->data.tvar, t3->data.tvar);
  32         ck_assert_str_ne(t3->data.tvar, t4->data.tvar);
  33 }
  34 END_TEST
  35
  36 START_TEST(test_scheme)
  37 {
  38         struct gamma *gamma = gamma_init();
  39
  40         char **var = malloc(sizeof(char *));
  41         var[0] = safe_strdup("a");
  42         struct scheme scheme = {.type=type_var("a"), .nvar=1, .var=var};
  43
  44         struct type *t = scheme_instantiate(gamma, &scheme);
  45         ck_assert(t->type == tvar);
  46         ck_assert_str_eq(t->data.tvar, "0");
  47
  48         scheme.type = type_list(type_var("a"));
  49         t = scheme_instantiate(gamma, &scheme);
  50         ck_assert(t->type == tlist);
  51         ck_assert(t->data.tlist->type == tvar);
  52         ck_assert_str_eq(t->data.tlist->data.tvar, "1");
  53 }
  54 END_TEST
  55
  56 START_TEST(test_subst)
  57 {
  58         struct subst *s1 = subst_id();
  59         ck_assert_int_eq(0, s1->nvar);
  60         s1 = subst_singleton("i1", type_basic(btint));
  61         ck_assert_int_eq(1, s1->nvar);
  62         s1 = subst_union(subst_id(), subst_singleton("i1", type_basic(btint)));
  63         ck_assert_int_eq(1, s1->nvar);
  64         s1 = subst_union(subst_singleton("i2", type_basic(btbool)),
  65                 subst_singleton("i1", type_basic(btint)));
  66         ck_assert_int_eq(2, s1->nvar);
  67
  68 }
  69 END_TEST
  70
  71 Suite *util_suite(void)
  72 {
  73         Suite *s = suite_create("List");
  74
  75         TCase *tc_gamma = tcase_create("Gamma lookup");
  76         tcase_add_test(tc_gamma, test_gamma_lookup);
  77         tcase_add_test(tc_gamma, test_scheme);
  78         tcase_add_test(tc_gamma, test_subst);
  79         suite_add_tcase(s, tc_gamma);
  80
  81         return s;
  82 }
  83
  84 int main(void)
  85 {
  86         int failed;
  87         Suite *s;
  88         SRunner *sr;
  89
  90         s = util_suite();
  91         sr = srunner_create(s);
  92
  93         srunner_run_all(sr, CK_NORMAL);
  94         failed = srunner_ntests_failed(sr);
  95         srunner_free(sr);
  96         return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  97 }