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.lisp");
  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_NUMBER, 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_NUMBER, 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_NUMBER, 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_negative_numbers_test)
  58 {
  59     Gc *gc = create_gc();
  60     struct ParseResult result = read_expr_from_string(gc, "-12345");
  61
  62     ASSERT_FALSE(result.is_error, {
  63             fprintf(stderr, "Parsing failed: %s", result.error_message);
  64     });
  65     ASSERT_EQ(enum ExprType, EXPR_ATOM, result.expr.type, {
  66             fprintf(stderr, "Expected: %s\n", expr_type_as_string(_expected));
  67             fprintf(stderr, "Actual: %s\n", expr_type_as_string(_actual));
  68     });
  69     ASSERT_EQ(enum AtomType, ATOM_NUMBER, result.expr.atom->type, {
  70             fprintf(stderr, "Expected: %s\n", atom_type_as_string(_expected));
  71             fprintf(stderr, "Actual: %s\n", atom_type_as_string(_actual));
  72     });
  73     ASSERT_LONGINTEQ(-12345L, result.expr.atom->num);
  74
  75     destroy_gc(gc);
  76
  77     return 0;
  78 }
  79
  80 TEST(read_all_exprs_from_string_empty_test)
  81 {
  82     Gc *gc = create_gc();
  83     struct ParseResult result = read_all_exprs_from_string(gc, "");
  84
  85     ASSERT_TRUE(result.is_error, {
  86             fprintf(stderr,
  87                     "Parsing is expected to fail, "
  88                     "but it did not\n");
  89     });
  90
  91     destroy_gc(gc);
  92
  93     return 0;
  94 }
  95
  96 TEST(read_all_exprs_from_string_one_test)
  97 {
  98     Gc *gc = create_gc();
  99     struct ParseResult result = read_all_exprs_from_string(gc, "(+ 1 2)");
 100
 101     ASSERT_FALSE(result.is_error, {
 102             fprintf(stderr,
 103                     "Parsing was unsuccessful: %s\n",
 104                     result.error_message);
 105     });
 106
 107     ASSERT_EQ(long int, 1, length_of_list(result.expr), {
 108             fprintf(stderr, "Expected: %ld\n", _expected);
 109             fprintf(stderr, "Actual: %ld\n", _actual);
 110             fprintf(stderr, "Expression: ");
 111             print_expr_as_sexpr(stderr, result.expr);
 112             fprintf(stderr, "\n");
 113     });
 114
 115     destroy_gc(gc);
 116
 117     return 0;
 118 }
 119
 120 TEST(read_all_exprs_from_string_two_test)
 121 {
 122     Gc *gc = create_gc();
 123     struct ParseResult result = read_all_exprs_from_string(
 124         gc,
 125         "(+ 1 2) (+ 3 4)");
 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, 2, 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_bad_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_TRUE(result.is_error, {
 154             fprintf(stderr, "Parsing didn't fail as expected\n");
 155     });
 156
 157     destroy_gc(gc);
 158
 159     return 0;
 160 }
 161
 162 TEST(read_all_exprs_from_string_trailing_spaces_test)
 163 {
 164     Gc *gc = create_gc();
 165     const char *source_code = "5  ";
 166     struct ParseResult result = read_all_exprs_from_string(gc, source_code);
 167
 168     ASSERT_FALSE(result.is_error, {
 169             fprintf(stderr, "Parsing failed: %s\n", result.error_message);
 170             fprintf(stderr, "Position: %ld\n", result.end - source_code);
 171     });
 172
 173     return 0;
 174 }
 175
 176 TEST_SUITE(parser_suite)
 177 {
 178     TEST_RUN(read_expr_from_file_test);
 179     TEST_RUN(parse_negative_numbers_test);
 180     TEST_RUN(read_all_exprs_from_string_empty_test);
 181     TEST_RUN(read_all_exprs_from_string_one_test);
 182     TEST_RUN(read_all_exprs_from_string_two_test);
 183     // TODO(#467): read_all_exprs_from_string_bad_test is failing
 184     TEST_IGNORE(read_all_exprs_from_string_bad_test);
 185     TEST_RUN(read_all_exprs_from_string_trailing_spaces_test);
 186
 187     return 0;
 188 }
 189
 190
 191
 192 #endif  // PARSER_SUITE_H_