diff --git a/tests/TestBinaryOpNode.cc b/tests/TestBinaryOpNode.cc
index c789d3a2b8a685068943cd437caeb6c5dc34d6d7..0bbfd3019ea66d3ae375f0d0a3a23b0e8d2b975a 100644
--- a/tests/TestBinaryOpNode.cc
+++ b/tests/TestBinaryOpNode.cc
@@ -1,5 +1,5 @@
-#include "ast/BinaryOpNode.h"
-#include "ast/LiteralNode.h"
+#include "ast/expression/BinaryOpNode.h"
+#include "ast/expression/LiteralNode.h"
#include "utils/Common.h"
#include <gtest/gtest.h>
@@ -27,9 +27,10 @@ TEST_F(TestBinaryOpNode, Construction)
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 3);
- BinaryOpNode node(left, BinaryOp::PLUS, right);
+ Token op(loc, "+", TokenType::PLUS);
+ BinaryOpNode node(left, op, right);
- ASSERT_EQ(node.get_op(), BinaryOp::PLUS);
+ ASSERT_EQ(node.get_op().get_type(), TokenType::PLUS);
ASSERT_EQ(node.get_left(), left);
ASSERT_EQ(node.get_right(), right);
}
@@ -40,7 +41,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 3);
- BinaryOpNode node(left, BinaryOp::PLUS, right);
+ Token op(loc, "+", TokenType::PLUS);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -51,7 +53,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 10);
LiteralNode* right = new LiteralNode(loc, 4);
- BinaryOpNode node(left, BinaryOp::MINUS, right);
+ Token op(loc, "-", TokenType::MINUS);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -62,7 +65,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 6);
- BinaryOpNode node(left, BinaryOp::MULTIPLY, right);
+ Token op(loc, "*", TokenType::MULTIPLY);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -73,7 +77,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 20);
LiteralNode* right = new LiteralNode(loc, 4);
- BinaryOpNode node(left, BinaryOp::DIVIDE, right);
+ Token op(loc, "/", TokenType::DIVIDE);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -84,7 +89,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 17);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::MODULO, right);
+ Token op(loc, "%", TokenType::MODULO);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -95,7 +101,8 @@ TEST_F(TestBinaryOpNode, ArithmeticOperations)
{
LiteralNode* left = new LiteralNode(loc, 2);
LiteralNode* right = new LiteralNode(loc, 3);
- BinaryOpNode node(left, BinaryOp::POWER, right);
+ Token op(loc, "^", TokenType::POWER);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<int>());
@@ -109,7 +116,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::EQUAL, right);
+ Token op(loc, "==", TokenType::EQUAL);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -120,7 +128,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 3);
- BinaryOpNode node(left, BinaryOp::NOT_EQUAL, right);
+ Token op(loc, "!=", TokenType::NOT_EQUAL);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -131,7 +140,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 3);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::LESS, right);
+ Token op(loc, "<", TokenType::LESS);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -142,7 +152,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::LESS_EQUAL, right);
+ Token op(loc, "<=", TokenType::LESS_EQUAL);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -153,7 +164,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 8);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::GREATER, right);
+ Token op(loc, ">", TokenType::GREATER);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -164,7 +176,8 @@ TEST_F(TestBinaryOpNode, ComparisonOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::GREATER_EQUAL, right);
+ Token op(loc, ">=", TokenType::GREATER_EQUAL);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -178,7 +191,8 @@ TEST_F(TestBinaryOpNode, LogicalOperations)
{
LiteralNode* left = new LiteralNode(loc, true);
LiteralNode* right = new LiteralNode(loc, true);
- BinaryOpNode node(left, BinaryOp::AND, right);
+ Token op(loc, "&&", TokenType::AND);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -189,7 +203,8 @@ TEST_F(TestBinaryOpNode, LogicalOperations)
{
LiteralNode* left = new LiteralNode(loc, false);
LiteralNode* right = new LiteralNode(loc, true);
- BinaryOpNode node(left, BinaryOp::OR, right);
+ Token op(loc, "||", TokenType::OR);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<bool>());
@@ -203,7 +218,8 @@ TEST_F(TestBinaryOpNode, MixedTypeOperations)
{
LiteralNode* left = new LiteralNode(loc, 5);
LiteralNode* right = new LiteralNode(loc, 3.5);
- BinaryOpNode node(left, BinaryOp::PLUS, right);
+ Token op(loc, "+", TokenType::PLUS);
+ BinaryOpNode node(left, op, right);
NodeValue result = node.get_value();
ASSERT_TRUE(result.is_a<double>());
@@ -217,7 +233,8 @@ TEST_F(TestBinaryOpNode, ErrorCases)
{
LiteralNode* left = new LiteralNode(loc, 10);
LiteralNode* right = new LiteralNode(loc, 0);
- BinaryOpNode node(left, BinaryOp::DIVIDE, right);
+ Token op(loc, "/", TokenType::DIVIDE);
+ BinaryOpNode node(left, op, right);
ASSERT_THROW(node.get_value(), RuntimeError);
}
@@ -226,7 +243,8 @@ TEST_F(TestBinaryOpNode, ErrorCases)
{
LiteralNode* left = new LiteralNode(loc, String("hello"));
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::MODULO, right);
+ Token op(loc, "%", TokenType::MODULO);
+ BinaryOpNode node(left, op, right);
ASSERT_THROW(node.get_value(), TypeError);
}
@@ -235,7 +253,8 @@ TEST_F(TestBinaryOpNode, ErrorCases)
{
LiteralNode* left = new LiteralNode(loc, String("hello"));
LiteralNode* right = new LiteralNode(loc, 123);
- BinaryOpNode node(left, BinaryOp::PLUS, right);
+ Token op(loc, "+", TokenType::PLUS);
+ BinaryOpNode node(left, op, right);
ASSERT_THROW(node.get_value(), TypeError);
}
@@ -245,7 +264,8 @@ TEST_F(TestBinaryOpNode, StringRepresentation)
{
LiteralNode* left = new LiteralNode(loc, 10);
LiteralNode* right = new LiteralNode(loc, 5);
- BinaryOpNode node(left, BinaryOp::PLUS, right);
+ Token op(loc, "+", TokenType::PLUS);
+ BinaryOpNode node(left, op, right);
ASSERT_EQ(node.to_s(), "(10 + 5)");
}
@@ -254,7 +274,8 @@ TEST_F(TestBinaryOpNode, Evaluate)
{
LiteralNode* left = new LiteralNode(loc, 7);
LiteralNode* right = new LiteralNode(loc, 3);
- BinaryOpNode node(left, BinaryOp::MINUS, right);
+ Token op(loc, "-", TokenType::MINUS);
+ BinaryOpNode node(left, op, right);
Node* result = node.evaluate();
ASSERT_NE(result, nullptr);
@@ -272,8 +293,11 @@ TEST_F(TestBinaryOpNode, NestedOperations)
LiteralNode* three = new LiteralNode(loc, 3);
LiteralNode* two = new LiteralNode(loc, 2);
- BinaryOpNode* addition = new BinaryOpNode(five, BinaryOp::PLUS, three);
- BinaryOpNode multiplication(addition, BinaryOp::MULTIPLY, two);
+ Token plus_op(loc, "+", TokenType::PLUS);
+ Token mult_op(loc, "*", TokenType::MULTIPLY);
+
+ BinaryOpNode* addition = new BinaryOpNode(five, plus_op, three);
+ BinaryOpNode multiplication(addition, mult_op, two);
NodeValue result = multiplication.get_value();
ASSERT_TRUE(result.is_a<int>());
diff --git a/tests/TestLexer.cc b/tests/TestLexer.cc
index e6092ba46d012512d88d7212cb1b5dc95803176a..c9de712b6111a8ecee5e8e8881a2ce1657aced19 100644
--- a/tests/TestLexer.cc
+++ b/tests/TestLexer.cc
@@ -61,24 +61,6 @@ TEST_F(TestLexer, Lexer)
ASSERT_EQ(tokens[4].get_type(), TokenType::SEMICOLON);
}
-TEST_F(TestLexer, LexerFromFile)
-{
- Lexer lexer{read_file("examples/math.funk"), "examples/math.funk"};
- auto tokens = lexer.tokenize();
-
- ASSERT_EQ(tokens.size(), 10);
- ASSERT_EQ(tokens[0].get_type(), TokenType::L_PAR);
- ASSERT_EQ(tokens[1].get_type(), TokenType::NUMB);
- ASSERT_EQ(tokens[2].get_type(), TokenType::PLUS);
- ASSERT_EQ(tokens[3].get_type(), TokenType::NUMB);
- ASSERT_EQ(tokens[4].get_type(), TokenType::R_PAR);
- ASSERT_EQ(tokens[5].get_type(), TokenType::DIVIDE);
- ASSERT_EQ(tokens[6].get_type(), TokenType::NUMB);
- ASSERT_EQ(tokens[7].get_type(), TokenType::MULTIPLY);
- ASSERT_EQ(tokens[8].get_type(), TokenType::NUMB);
- ASSERT_EQ(tokens[9].get_type(), TokenType::EOF_TOKEN);
-}
-
int main(int argc, char** argv)
{
::testing::InitGoogleTest(&argc, argv);
diff --git a/tests/TestLiteralNode.cc b/tests/TestLiteralNode.cc
index cda9b6872e9660a43236172d597775b533ec2234..c4fdc828696c771bf12ac5201384379e2180d9b8 100644
--- a/tests/TestLiteralNode.cc
+++ b/tests/TestLiteralNode.cc
@@ -1,4 +1,4 @@
-#include "ast/LiteralNode.h"
+#include "ast/expression/LiteralNode.h"
#include "utils/Common.h"
#include <gtest/gtest.h>
@@ -81,7 +81,7 @@ TEST_F(TestLiteralNode, String)
ASSERT_TRUE(node.get_value().is_a<String>());
ASSERT_FALSE(node.get_value().is_nothing());
ASSERT_EQ(node.get_value().get<String>(), "hello");
- ASSERT_EQ(node.to_s(), "hello");
+ ASSERT_EQ(node.to_s(), "\"hello\"");
ASSERT_EQ(node.get_value().cast<bool>(), true);
ASSERT_THROW(node.get_value().cast<int>(), TypeError);
ASSERT_THROW(node.get_value().cast<double>(), TypeError);
diff --git a/tests/TestUnaryOpNode.cc b/tests/TestUnaryOpNode.cc
index 2be026bb5a6e5dbd48af5df1ea239c799558c62c..9ad2a89e320b8cb4a76bb1db9b5e12aee829bb8d 100644
--- a/tests/TestUnaryOpNode.cc
+++ b/tests/TestUnaryOpNode.cc
@@ -1,5 +1,5 @@
-#include "ast/LiteralNode.h"
-#include "ast/UnaryOpNode.h"
+#include "ast/expression/LiteralNode.h"
+#include "ast/expression/UnaryOpNode.h"
#include "utils/Common.h"
#include <gtest/gtest.h>
@@ -27,13 +27,16 @@ TEST_F(TestUnaryOpNode, Construction)
LiteralNode* intVal = new LiteralNode(loc, 5);
LiteralNode* boolVal = new LiteralNode(loc, false);
- UnaryOpNode negateNode(UnaryOp::NEGATE, intVal);
- UnaryOpNode notNode(UnaryOp::NOT, boolVal);
+ Token minus_token(loc, "-", TokenType::MINUS);
+ Token not_token(loc, "not", TokenType::NOT);
- ASSERT_EQ(negateNode.get_op(), UnaryOp::NEGATE);
+ UnaryOpNode negateNode(minus_token, intVal);
+ UnaryOpNode notNode(not_token, boolVal);
+
+ ASSERT_EQ(negateNode.get_op().get_type(), TokenType::MINUS);
ASSERT_EQ(negateNode.get_expr(), intVal);
- ASSERT_EQ(notNode.get_op(), UnaryOp::NOT);
+ ASSERT_EQ(notNode.get_op().get_type(), TokenType::NOT);
ASSERT_EQ(notNode.get_expr(), boolVal);
}
@@ -42,8 +45,11 @@ TEST_F(TestUnaryOpNode, NegateEvaluation)
LiteralNode* val1 = new LiteralNode(loc, 5);
LiteralNode* val2 = new LiteralNode(loc, 3.14);
- UnaryOpNode negateInt(UnaryOp::NEGATE, val1);
- UnaryOpNode negateDouble(UnaryOp::NEGATE, val2);
+ Token minus_token(loc, "-", TokenType::MINUS);
+ Token not_token(loc, "not", TokenType::NOT);
+
+ UnaryOpNode negateInt(minus_token, val1);
+ UnaryOpNode negateDouble(minus_token, val2);
ASSERT_EQ(negateInt.get_value().get<int>(), -5);
ASSERT_DOUBLE_EQ(negateDouble.get_value().get<double>(), -3.14);
@@ -54,8 +60,10 @@ TEST_F(TestUnaryOpNode, NotEvaluation)
LiteralNode* val1 = new LiteralNode(loc, true);
LiteralNode* val2 = new LiteralNode(loc, false);
- UnaryOpNode notTrue(UnaryOp::NOT, val1);
- UnaryOpNode notFalse(UnaryOp::NOT, val2);
+ Token not_token(loc, "not", TokenType::NOT);
+
+ UnaryOpNode notTrue(not_token, val1);
+ UnaryOpNode notFalse(not_token, val2);
ASSERT_FALSE(notTrue.get_value().get<bool>());
ASSERT_TRUE(notFalse.get_value().get<bool>());
@@ -66,7 +74,8 @@ TEST_F(TestUnaryOpNode, ErrorCases)
// Negate string value
{
LiteralNode* val = new LiteralNode(loc, String("test"));
- UnaryOpNode node(UnaryOp::NEGATE, val);
+ Token minus_token(loc, "-", TokenType::MINUS);
+ UnaryOpNode node(minus_token, val);
ASSERT_THROW(node.get_value(), TypeError);
}
@@ -74,7 +83,8 @@ TEST_F(TestUnaryOpNode, ErrorCases)
// Negate boolean value, apparently this works in c++ but it's ugly
{
LiteralNode* val = new LiteralNode(loc, true);
- UnaryOpNode node(UnaryOp::NEGATE, val);
+ Token minus_token(loc, "-", TokenType::MINUS);
+ UnaryOpNode node(minus_token, val);
ASSERT_THROW(node.get_value(), TypeError);
}
@@ -82,7 +92,8 @@ TEST_F(TestUnaryOpNode, ErrorCases)
// Logical NOT on non-boolean value
{
LiteralNode* val = new LiteralNode(loc, 5);
- UnaryOpNode node(UnaryOp::NOT, val);
+ Token op(loc, "not", TokenType::NOT);
+ UnaryOpNode node(op, val);
ASSERT_THROW(node.get_value(), TypeError);
}
@@ -91,7 +102,8 @@ TEST_F(TestUnaryOpNode, ErrorCases)
TEST_F(TestUnaryOpNode, StringRepresentation)
{
LiteralNode* val = new LiteralNode(loc, 5);
- UnaryOpNode node(UnaryOp::NEGATE, val);
+ Token minus_token(loc, "-", TokenType::MINUS);
+ UnaryOpNode node(minus_token, val);
ASSERT_EQ(node.to_s(), "(-5)");
}