karma/interpreter-cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

moved the utils for the parser to a global utils

Browse Source 
folder for the tests (that utils is includable
only by the tests and not the src code, I added a
compiler flag only for the tests in the makefile,
but the compiler_flags.txt is global for the lsp,
gotta be careful with that)
This commit is contained in:
Karma Riuk
2025-07-19 13:27:25 +02:00
parent d1dd5f9dab
commit c943380d58
11 changed files with 419 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
test/parser/expression.cpp
View File

@@ -7,43 +7,49 @@
TEST_SUITE("Parser: expression") {
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Simple expression statement with identifier"
) {
setup("foobar;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
ast::identifier* ident =
cast<ast::identifier>(expression_stmt->expression);
test::utils::cast<ast::identifier>(expression_stmt->expression);
REQUIRE(ident->value == "foobar");
REQUIRE(ident->token_literal() == "foobar");
};
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Simple expression statement with integer"
) {
setup("5;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
test_integer_literal(expression_stmt->expression, 5);
test::utils::test_integer_literal(expression_stmt->expression, 5);
};
TEST_CASE_FIXTURE(ParserFixture, "Simple statements with booleans") {
TEST_CASE_FIXTURE(
test::utils::ParserFixture,
"Simple statements with booleans"
) {
SUBCASE("True literal") {
setup("true;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
test_boolean_literal(expression_stmt->expression, true);
test::utils::test_boolean_literal(
expression_stmt->expression,
true
);
}
SUBCASE("False literal") {
@@ -51,9 +57,12 @@ TEST_SUITE("Parser: expression") {
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
test_boolean_literal(expression_stmt->expression, false);
test::utils::test_boolean_literal(
expression_stmt->expression,
false
);
}
SUBCASE("True let statement") {
@@ -61,10 +70,10 @@ TEST_SUITE("Parser: expression") {
REQUIRE(program->statements.size() == 1);
ast::let_stmt* let_stmt =
cast<ast::let_stmt>(program->statements[0]);
test::utils::cast<ast::let_stmt>(program->statements[0]);
CHECK(let_stmt->name->value == "foo");
test_boolean_literal(let_stmt->value, true);
test::utils::test_boolean_literal(let_stmt->value, true);
}
SUBCASE("False let statement") {
@@ -72,15 +81,15 @@ TEST_SUITE("Parser: expression") {
REQUIRE(program->statements.size() == 1);
ast::let_stmt* let_stmt =
cast<ast::let_stmt>(program->statements[0]);
test::utils::cast<ast::let_stmt>(program->statements[0]);
CHECK(let_stmt->name->value == "bar");
test_boolean_literal(let_stmt->value, false);
test::utils::test_boolean_literal(let_stmt->value, false);
}
}
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Simple expression statement with prefix before integer"
) {
#define CASE(name, input, _op, _right) \
@@ -89,13 +98,13 @@ TEST_SUITE("Parser: expression") {
\
REQUIRE(program->statements.size() == 1); \
ast::expression_stmt* expression_stmt = \
cast<ast::expression_stmt>(program->statements[0]); \
test::utils::cast<ast::expression_stmt>(program->statements[0]); \
\
ast::prefix_expr* prefix_expr = \
cast<ast::prefix_expr>(expression_stmt->expression); \
test::utils::cast<ast::prefix_expr>(expression_stmt->expression); \
\
REQUIRE(prefix_expr->op == _op); \
test_integer_literal(prefix_expr->right, _right); \
test::utils::test_integer_literal(prefix_expr->right, _right); \
}
CASE("Prefix: '!'", "!5;", "!", 5);
@@ -104,7 +113,7 @@ TEST_SUITE("Parser: expression") {
}
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Simple expression statement with infix between integers"
) {
#define CASE(name, input, _left, _op, _right) \
@@ -113,9 +122,9 @@ TEST_SUITE("Parser: expression") {
REQUIRE(program->statements.size() == 1); \
\
ast::expression_stmt* expression_stmt = \
cast<ast::expression_stmt>(program->statements[0]); \
test::utils::cast<ast::expression_stmt>(program->statements[0]); \
\
test_infix_expression( \
test::utils::test_infix_expression( \
expression_stmt->expression, \
_left, \
_op, \
@@ -136,85 +145,91 @@ TEST_SUITE("Parser: expression") {
#undef CASE
}
TEST_CASE_FIXTURE(ParserFixture, "Slightly more complex infix expression") {
TEST_CASE_FIXTURE(
test::utils::ParserFixture,
"Slightly more complex infix expression"
) {
setup("5 - -15;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
ast::infix_expr* infix_expr =
cast<ast::infix_expr>(expression_stmt->expression);
test::utils::cast<ast::infix_expr>(expression_stmt->expression);
test_integer_literal(infix_expr->left, 5);
test::utils::test_integer_literal(infix_expr->left, 5);
CHECK(infix_expr->op == "-");
ast::prefix_expr* prefix_expr =
cast<ast::prefix_expr>(infix_expr->right);
test::utils::cast<ast::prefix_expr>(infix_expr->right);
CHECK(prefix_expr->op == "-");
test_integer_literal(prefix_expr->right, 15);
test::utils::test_integer_literal(prefix_expr->right, 15);
}
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Slightly even more complex infix expression"
) {
setup("5 - -15 * 3;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
ast::infix_expr* infix_expr =
cast<ast::infix_expr>(expression_stmt->expression);
test::utils::cast<ast::infix_expr>(expression_stmt->expression);
test_integer_literal(infix_expr->left, 5);
test::utils::test_integer_literal(infix_expr->left, 5);
CHECK(infix_expr->op == "-");
ast::infix_expr* second_infix_expr =
cast<ast::infix_expr>(infix_expr->right);
test::utils::cast<ast::infix_expr>(infix_expr->right);
CHECK(second_infix_expr->op == "*");
ast::prefix_expr* prefix_expr =
cast<ast::prefix_expr>(second_infix_expr->left);
test::utils::cast<ast::prefix_expr>(second_infix_expr->left);
CHECK(prefix_expr->op == "-");
test_integer_literal(prefix_expr->right, 15);
test::utils::test_integer_literal(prefix_expr->right, 15);
test_integer_literal(second_infix_expr->right, 3);
test::utils::test_integer_literal(second_infix_expr->right, 3);
}
TEST_CASE_FIXTURE(
ParserFixture,
test::utils::ParserFixture,
"Checking operator precedence with simple example"
) {
setup("5 * -15 - 3;");
REQUIRE(program->statements.size() == 1);
ast::expression_stmt* expression_stmt =
cast<ast::expression_stmt>(program->statements[0]);
test::utils::cast<ast::expression_stmt>(program->statements[0]);
ast::infix_expr* infix_expr =
cast<ast::infix_expr>(expression_stmt->expression);
test::utils::cast<ast::infix_expr>(expression_stmt->expression);
ast::infix_expr* second_infix_expr =
cast<ast::infix_expr>(infix_expr->left);
test::utils::cast<ast::infix_expr>(infix_expr->left);
CHECK(second_infix_expr->op == "*");
test_integer_literal(second_infix_expr->left, 5);
test::utils::test_integer_literal(second_infix_expr->left, 5);
ast::prefix_expr* prefix_expr =
cast<ast::prefix_expr>(second_infix_expr->right);
test::utils::cast<ast::prefix_expr>(second_infix_expr->right);
CHECK(prefix_expr->op == "-");
test_integer_literal(prefix_expr->right, 15);
test::utils::test_integer_literal(prefix_expr->right, 15);
CHECK(infix_expr->op == "-");
test_integer_literal(infix_expr->right, 3);
test::utils::test_integer_literal(infix_expr->right, 3);
}
TEST_CASE_FIXTURE(ParserFixture, "Full Operator Precedence test") {
TEST_CASE_FIXTURE(
test::utils::ParserFixture,
"Full Operator Precedence test"
) {
struct test {
std::string input;
std::string expected;
@@ -254,7 +269,7 @@ TEST_SUITE("Parser: expression") {
}
}
TEST_CASE_FIXTURE(ParserFixture, "Test to see trace") {
TEST_CASE_FIXTURE(test::utils::ParserFixture, "Test to see trace") {
setup("-1 * 2 - 3");
CHECK(program->str() == "(((-1) * 2) - 3)");
setup("-1 - 2 * 3");