test/parser_suite.h

   1 #ifndef PARSER_SUITE_H_
   2 #define PARSER_SUITE_H_
   3
   4 #include "test.h"
   5 #include "ebisp/parser.h"
   6 #include "ebisp/gc.h"
   7 #include "ebisp/builtins.h"
   8
   9 TEST(read_expr_from_file_test)
  10 {
  11     Gc *gc = create_gc();
  12
  13     struct ParseResult result = read_expr_from_file(gc, "test-data/simple-sum.ebi");
  14
  15     ASSERT_TRUE(!result.is_error, {
  16             fprintf(stderr,
  17                     "Parsing failed: %s",
  18                     result.error_message);
  19     });
  20
  21     struct Expr head = result.expr;
  22
  23     struct Expr expr = head;
  24     ASSERT_INTEQ(EXPR_CONS, expr.type);
  25     ASSERT_INTEQ(EXPR_ATOM, expr.cons->car.type);
  26     ASSERT_INTEQ(ATOM_SYMBOL, expr.cons->car.atom->type);
  27     ASSERT_STREQ("+", expr.cons->car.atom->sym);
  28
  29     expr = expr.cons->cdr;
  30     ASSERT_INTEQ(EXPR_CONS, expr.type);
  31     ASSERT_INTEQ(EXPR_ATOM, expr.cons->car.type);
  32     ASSERT_INTEQ(ATOM_INTEGER, expr.cons->car.atom->type);
  33     ASSERT_LONGINTEQ(1L, expr.cons->car.atom->num);
  34
  35     expr = expr.cons->cdr;
  36     ASSERT_INTEQ(EXPR_CONS, expr.type);
  37     ASSERT_INTEQ(EXPR_ATOM, expr.cons->car.type);
  38     ASSERT_INTEQ(ATOM_INTEGER, expr.cons->car.atom->type);
  39     ASSERT_LONGINTEQ(2L, expr.cons->car.atom->num);
  40
  41     expr = expr.cons->cdr;
  42     ASSERT_INTEQ(EXPR_CONS, expr.type);
  43     ASSERT_INTEQ(EXPR_ATOM, expr.cons->car.type);
  44     ASSERT_INTEQ(ATOM_INTEGER, expr.cons->car.atom->type);
  45     ASSERT_LONGINTEQ(3L, expr.cons->car.atom->num);
  46
  47     expr = expr.cons->cdr;
  48     ASSERT_INTEQ(EXPR_ATOM, expr.type);
  49     ASSERT_INTEQ(ATOM_SYMBOL, expr.atom->type);
  50     ASSERT_STREQ("nil", expr.atom->sym);
  51
  52     destroy_gc(gc);
  53
  54     return 0;
  55 }
  56
  57 TEST(parse_reals_test)
  58 {
  59     Gc *gc = create_gc();
  60
  61     const char *input = "3.1415";
  62     struct ParseResult result = read_expr_from_string(gc, input);
  63
  64     ASSERT_FALSE(result.is_error, {
  65         fprintf(stderr, "Parsing failed: %s\n", result.error_message);
  66     });
  67
  68     EPIC_ASSERT_EQ(struct Expr, result.expr, REAL(gc, 3.1416f));
  69
  70     destroy_gc(gc);
  71
  72     return 0;
  73 }
  74
  75 TEST(parse_negative_integers_test)
  76 {
  77     Gc *gc = create_gc();
  78     struct ParseResult result = read_expr_from_string(gc, "-12345");
  79
  80     ASSERT_FALSE(result.is_error, {
  81             fprintf(stderr, "Parsing failed: %s", result.error_message);
  82     });
  83     ASSERT_EQ(enum ExprType, EXPR_ATOM, result.expr.type, {
  84             fprintf(stderr, "Expected: %s\n", expr_type_as_string(_expected));
  85             fprintf(stderr, "Actual: %s\n", expr_type_as_string(_actual));
  86     });
  87     ASSERT_EQ(enum AtomType, ATOM_INTEGER, result.expr.atom->type, {
  88             fprintf(stderr, "Expected: %s\n", atom_type_as_string(_expected));
  89             fprintf(stderr, "Actual: %s\n", atom_type_as_string(_actual));
  90     });
  91     ASSERT_LONGINTEQ(-12345L, result.expr.atom->num);
  92
  93     destroy_gc(gc);
  94
  95     return 0;
  96 }
  97
  98 TEST(read_all_exprs_from_string_empty_test)
  99 {
 100     Gc *gc = create_gc();
 101     struct ParseResult result = read_all_exprs_from_string(gc, "");
 102
 103     ASSERT_FALSE(result.is_error, {
 104             fprintf(stderr,
 105                     "Parsing was unsuccessful: %s\n",
 106                     result.error_message);
 107     });
 108
 109     ASSERT_EQ(long int, 0, length_of_list(result.expr), {
 110             fprintf(stderr, "Expected: %ld\n", _expected);
 111             fprintf(stderr, "Actual: %ld\n", _actual);
 112             fprintf(stderr, "Expression: ");
 113             print_expr_as_sexpr(stderr, result.expr);
 114             fprintf(stderr, "\n");
 115     });
 116
 117     destroy_gc(gc);
 118
 119     return 0;
 120 }
 121
 122 TEST(read_all_exprs_from_string_one_test)
 123 {
 124     Gc *gc = create_gc();
 125     struct ParseResult result = read_all_exprs_from_string(gc, "(+ 1 2)");
 126
 127     ASSERT_FALSE(result.is_error, {
 128             fprintf(stderr,
 129                     "Parsing was unsuccessful: %s\n",
 130                     result.error_message);
 131     });
 132
 133     ASSERT_EQ(long int, 1, length_of_list(result.expr), {
 134             fprintf(stderr, "Expected: %ld\n", _expected);
 135             fprintf(stderr, "Actual: %ld\n", _actual);
 136             fprintf(stderr, "Expression: ");
 137             print_expr_as_sexpr(stderr, result.expr);
 138             fprintf(stderr, "\n");
 139     });
 140
 141     destroy_gc(gc);
 142
 143     return 0;
 144 }
 145
 146 TEST(read_all_exprs_from_string_two_test)
 147 {
 148     Gc *gc = create_gc();
 149     struct ParseResult result = read_all_exprs_from_string(
 150         gc,
 151         "(+ 1 2) (+ 3 4)");
 152
 153     ASSERT_FALSE(result.is_error, {
 154             fprintf(stderr,
 155                     "Parsing was unsuccessful: %s\n",
 156                     result.error_message);
 157     });
 158
 159     ASSERT_EQ(long int, 2, length_of_list(result.expr), {
 160             fprintf(stderr, "Expected: %ld\n", _expected);
 161             fprintf(stderr, "Actual: %ld\n", _actual);
 162             fprintf(stderr, "Expression: ");
 163             print_expr_as_sexpr(stderr, result.expr);
 164             fprintf(stderr, "\n");
 165     });
 166
 167     destroy_gc(gc);
 168
 169     return 0;
 170 }
 171
 172 TEST(read_all_exprs_from_string_bad_test)
 173 {
 174     Gc *gc = create_gc();
 175     struct ParseResult result = read_all_exprs_from_string(
 176         gc,
 177         "(+ 1 2) + 3 4)");
 178
 179     ASSERT_TRUE(result.is_error, {
 180             fprintf(stderr, "Parsing didn't fail as expected\n");
 181     });
 182
 183     destroy_gc(gc);
 184
 185     return 0;
 186 }
 187
 188 TEST(read_all_exprs_from_string_trailing_spaces_test)
 189 {
 190     Gc *gc = create_gc();
 191     const char *source_code = "5  ";
 192     struct ParseResult result = read_all_exprs_from_string(gc, source_code);
 193
 194     ASSERT_FALSE(result.is_error, {
 195             fprintf(stderr, "Parsing failed: %s\n", result.error_message);
 196             fprintf(stderr, "Position: %zd\n", result.end - source_code);
 197     });
 198
 199     return 0;
 200 }
 201
 202 TEST_SUITE(parser_suite)
 203 {
 204     TEST_RUN(read_expr_from_file_test);
 205     TEST_RUN(parse_negative_integers_test);
 206     TEST_RUN(read_all_exprs_from_string_empty_test);
 207     TEST_RUN(read_all_exprs_from_string_one_test);
 208     TEST_RUN(read_all_exprs_from_string_two_test);
 209     // TODO(#467): read_all_exprs_from_string_bad_test is failing
 210     TEST_IGNORE(read_all_exprs_from_string_bad_test);
 211     TEST_RUN(read_all_exprs_from_string_trailing_spaces_test);
 212     TEST_RUN(parse_reals_test);
 213
 214     return 0;
 215 }
 216
 217
 218
 219 #endif  // PARSER_SUITE_H_