src/lexer.c

@@ -87,9 +87,10 @@ ASTNodeResult tokenize_number(const char *input, size_t *offset) {
     if (is_integer) {
         new_node.type = NODE_INTEGER;
         I64Result status = string_to_integer(buf);
-        if (status.is_valid == LEXER_OK) {
+        if (!status.is_valid) {
-            new_node.data.integer = status.number;
+            return (ASTNodeResult) {.is_valid = false, .err = status.err};
         }
+        new_node.data.integer = status.number;
         *offset = current;
         return (ASTNodeResult) {.is_valid = true, .node = new_node};
     }

test/CMakeLists.txt

@@ -1,15 +1,9 @@
 find_package(cmocka REQUIRED)
 
-add_executable(test_nodeArray test_ASTNodeArray.c)
 add_executable(test_lexer test_lexer.c)
 add_executable(test_parser test_parser.c)
 add_executable(test_evaluator test_evaluator.c)
 
-target_link_libraries(test_nodeArray
-    calculator_lib
-    cmocka::cmocka
-)
-
 target_link_libraries(test_lexer
     calculator_lib
     cmocka::cmocka
@@ -25,7 +19,6 @@ target_link_libraries(test_evaluator
     cmocka::cmocka
 )
 
-add_test(NAME nodeArray_tests COMMAND test_nodeArray)
 add_test(NAME lexer_tests COMMAND test_lexer)
 add_test(NAME parser_tests COMMAND test_parser)
 add_test(NAME evaluator_tests COMMAND test_evaluator)

test/test_evaluator.c

@@ -13,10 +13,8 @@ static void test_basic_evaluation(void** state) {
     (void) state;
 
     char expr[256] = "2 + 4 * 40 / 2";
-    ASTNodeArray context;
+    TokenizeResult tokens = tokenize(expr);
-
+    ParseResult result = parse(tokens);
-    tokenize(expr, &context);
-    ParseResult result = parse(&context);
     int64_t value = evaluate(result);
 
     assert_int_equal(value, 82);

test/test_lexer.c

@@ -21,27 +21,27 @@ static void test_tokenize_normal_expresion(void **state) {
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 2);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 1, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_ADD);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 2, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 3);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 3, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_DIV);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 4, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 66);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 5, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_MUL);
 
-    arraylist_get(tokens.arr, 0, &node);
+    arraylist_get(tokens.arr, 6, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 789);
 }
@@ -53,7 +53,7 @@ static void test_tokenize_unrecognized_symbol(void **state) {
     TokenizeResult tokens = tokenize(expr);
 
     assert_false(tokens.is_valid);
-    assert_uint_equal(tokens.err, LEXER_WRONG_SYNTAX);
+    assert_uint_equal(tokens.err, LEXER_NOT_RECOGNIZED_SYMBOL);
 }
 
 static void test_tokenize_wrong_sintax(void **state) {
@@ -83,8 +83,8 @@ static void test_string_to_number_normal(void **state) {
 static void test_string_to_number_overflow(void **state) {
     (void) state;
 
-    // Number is INT64_MAX but with a extra 8 at the end
+    // Number is INT64_MAX but with a extra 899 at the end
-    char num[32] = "92233720368547758078yy7";
+    char num[32] = "92233720368547758079";
     size_t offset = 0;
     ASTNodeResult result = tokenize_number(num, &offset);
     assert_false(result.is_valid);

test/test_parser.c

@@ -1,4 +1,5 @@
 #include "arena.h"
+#include "arraylist.h"
 #include "lexer.h"
 #include "parser.h"
 #include <stdarg.h>
@@ -12,13 +13,12 @@ static void test_parsing_basic_expression(void **state) {
     (void) state;
 
     char expr[256] = "2 + 3 / 66 * 789";
-    ASTNodeArray tokens;
+    TokenizeResult tokens = tokenize(expr);
-    ASTNode node;
 
-    assert_int_equal(tokenize(expr, &tokens), LEXER_OK);
+    assert_true(tokens.is_valid);
-    assert_int_equal(tokens.len, 7);
+    assert_int_equal(arraylist_size(tokens.arr), 7);
 
-    ParseResult result = parse(&tokens);
+    ParseResult result = parse(tokens);
     // Assert head is +
     assert_int_equal(result.tree->type, NODE_BINARY_OP);
     assert_int_equal(result.tree->data.binary.op, OP_ADD);