Add initial unit tests
- Add µnit source and header files - Add test target to the build system - Implement a thorough lexer test suite - Implement a minimal AST test suite
This commit is contained in:
896
tests/lexer.c
Normal file
896
tests/lexer.c
Normal file
@ -0,0 +1,896 @@
|
||||
#include "../src/lexer.h"
|
||||
#include "../src/error.h"
|
||||
#include "munit.h"
|
||||
#include <string.h>
|
||||
|
||||
void lexer_setup_memory_test(lexer_t *lex, const char *input) {
|
||||
munit_assert_null(lex->fp);
|
||||
FILE *stream = fmemopen((void *)input, strlen(input), "rb");
|
||||
munit_assert_not_null(stream);
|
||||
lex->fp = stream;
|
||||
lex->line_number = 0;
|
||||
lex->character_number = 0;
|
||||
lex->buffer_count = 0;
|
||||
}
|
||||
|
||||
void lexer_expect_one_token(lexer_t *lex, lexer_token_id_t id, const char *value, size_t line, size_t column) {
|
||||
lexer_token_t token = {};
|
||||
|
||||
error_t *err = lexer_next(lex, &token);
|
||||
munit_assert_null(err);
|
||||
|
||||
munit_assert_int(token.id, ==, id);
|
||||
munit_assert_string_equal(token.value, value);
|
||||
munit_assert_int(token.line_number, ==, line);
|
||||
munit_assert_int(token.character_number, ==, column);
|
||||
lexer_token_cleanup(&token);
|
||||
}
|
||||
|
||||
void lexer_expect_eof(lexer_t *lex) {
|
||||
lexer_token_t token = {};
|
||||
error_t *err = lexer_next(lex, &token);
|
||||
munit_assert_ptr_equal(err, err_eof);
|
||||
}
|
||||
|
||||
void lexer_test_one_token(lexer_token_id_t id, const char *value) {
|
||||
lexer_t lex = {};
|
||||
lexer_setup_memory_test(&lex, value);
|
||||
lexer_expect_one_token(&lex, id, value, 0, 0);
|
||||
lexer_expect_eof(&lex);
|
||||
lexer_close(&lex);
|
||||
}
|
||||
|
||||
MunitResult test_lexer_identifier(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_IDENTIFIER, "identifier");
|
||||
lexer_test_one_token(TOKEN_IDENTIFIER, "_identifier");
|
||||
lexer_test_one_token(TOKEN_IDENTIFIER, "_identifier123_55");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
typedef struct token_data {
|
||||
lexer_token_id_t id;
|
||||
char *value;
|
||||
size_t line;
|
||||
size_t column;
|
||||
} token_data_t;
|
||||
|
||||
typedef struct boundary {
|
||||
const char *input;
|
||||
token_data_t first;
|
||||
token_data_t second;
|
||||
} boundary_t;
|
||||
|
||||
void test_lexer_boundary(boundary_t boundaries[]) {
|
||||
for (size_t i = 0; boundaries[i].input; ++i) {
|
||||
auto boundary = boundaries[i];
|
||||
auto first = boundary.first;
|
||||
auto second = boundary.second;
|
||||
|
||||
lexer_t lex = {};
|
||||
lexer_setup_memory_test(&lex, boundary.input);
|
||||
lexer_expect_one_token(&lex, first.id, first.value, first.line, first.column);
|
||||
lexer_expect_one_token(&lex, second.id, second.value, second.line, second.column);
|
||||
lexer_expect_eof(&lex);
|
||||
lexer_close(&lex);
|
||||
}
|
||||
}
|
||||
|
||||
MunitResult test_lexer_identifier_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"id:", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_COLON, ":", 0, 2} },
|
||||
{"id[", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_LBRACKET, "[", 0, 2} },
|
||||
{"id]", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_RBRACKET, "]", 0, 2} },
|
||||
{"id+", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_PLUS, "+", 0, 2} },
|
||||
{"id-", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_MINUS, "-", 0, 2} },
|
||||
{"id*", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_ASTERISK, "*", 0, 2} },
|
||||
{"id.", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_DOT, ".", 0, 2} },
|
||||
{"id;comment", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_COMMENT, ";comment", 0, 2}},
|
||||
{"id\n", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 2} },
|
||||
{"id\r\n", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 2} },
|
||||
{"id ", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 2} },
|
||||
{"id\t", {TOKEN_IDENTIFIER, "id", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 2} },
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_decimal(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "123");
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "0");
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "42");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_decimal_with_suffix(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "123:8");
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "0:16");
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "42:32");
|
||||
lexer_test_one_token(TOKEN_DECIMAL, "69:64");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_hexadecimal(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0x123");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xDEAD");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0x0");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xabcdef");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xABCDEF");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_hexadecimal_with_suffix(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0x123:8");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xDEAD:16");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xABC:32");
|
||||
lexer_test_one_token(TOKEN_HEXADECIMAL, "0xffff:64");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_octal(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o777");
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o0");
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o123");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_octal_with_suffix(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o777:8");
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o123:16");
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o777:32");
|
||||
lexer_test_one_token(TOKEN_OCTAL, "0o123:64");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_binary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b101");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b0");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b1");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b01010101");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_binary_with_suffix(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b101:8");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b0:16");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b1:32");
|
||||
lexer_test_one_token(TOKEN_BINARY, "0b01010101:64");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_colon(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_COLON, ":");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_comma(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_COMMA, ",");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_lbracket(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_LBRACKET, "[");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_rbracket(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_RBRACKET, "]");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_plus(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_PLUS, "+");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_minus(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_MINUS, "-");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_asterisk(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_ASTERISK, "*");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_dot(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_DOT, ".");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_comment(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_COMMENT, ";This is a comment");
|
||||
lexer_test_one_token(TOKEN_COMMENT, "; Another comment");
|
||||
lexer_test_one_token(TOKEN_COMMENT, ";");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_whitespace(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
lexer_test_one_token(TOKEN_WHITESPACE, " ");
|
||||
lexer_test_one_token(TOKEN_WHITESPACE, " ");
|
||||
lexer_test_one_token(TOKEN_WHITESPACE, "\t");
|
||||
lexer_test_one_token(TOKEN_WHITESPACE, " \t ");
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_newlines(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
// Test simple newline
|
||||
lexer_t lex = {};
|
||||
lexer_setup_memory_test(&lex, "\n");
|
||||
lexer_expect_one_token(&lex, TOKEN_NEWLINE, "\n", 0, 0);
|
||||
lexer_expect_eof(&lex);
|
||||
lexer_close(&lex);
|
||||
|
||||
// Test Windows-style newline
|
||||
lexer_t lex2 = {};
|
||||
lexer_setup_memory_test(&lex2, "\r\n");
|
||||
lexer_expect_one_token(&lex2, TOKEN_NEWLINE, "\r\n", 0, 0);
|
||||
lexer_expect_eof(&lex2);
|
||||
lexer_close(&lex2);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_line_numbers(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
lexer_t lex = {};
|
||||
lexer_setup_memory_test(&lex, "a\nb\nc");
|
||||
|
||||
lexer_expect_one_token(&lex, TOKEN_IDENTIFIER, "a", 0, 0);
|
||||
lexer_expect_one_token(&lex, TOKEN_NEWLINE, "\n", 0, 1);
|
||||
lexer_expect_one_token(&lex, TOKEN_IDENTIFIER, "b", 1, 0);
|
||||
lexer_expect_one_token(&lex, TOKEN_NEWLINE, "\n", 1, 1);
|
||||
lexer_expect_one_token(&lex, TOKEN_IDENTIFIER, "c", 2, 0);
|
||||
lexer_expect_eof(&lex);
|
||||
lexer_close(&lex);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_decimal_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"123,", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_COMMA, ",", 0, 3} },
|
||||
{"123:", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_COLON, ":", 0, 3} },
|
||||
{"123[", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_LBRACKET, "[", 0, 3} },
|
||||
{"123]", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_RBRACKET, "]", 0, 3} },
|
||||
{"123+", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_PLUS, "+", 0, 3} },
|
||||
{"123-", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_MINUS, "-", 0, 3} },
|
||||
{"123*", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_ASTERISK, "*", 0, 3} },
|
||||
{"123.", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_DOT, ".", 0, 3} },
|
||||
{"123;", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_COMMENT, ";", 0, 3} },
|
||||
{"123\n", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 3} },
|
||||
{"123\r\n", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 3} },
|
||||
{"123 ", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 3} },
|
||||
{"123\t", {TOKEN_DECIMAL, "123", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 3}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_hexadecimal_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"0x123,", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_COMMA, ",", 0, 5} },
|
||||
{"0x123:", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_COLON, ":", 0, 5} },
|
||||
{"0x123[", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_LBRACKET, "[", 0, 5} },
|
||||
{"0x123]", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_RBRACKET, "]", 0, 5} },
|
||||
{"0x123+", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_PLUS, "+", 0, 5} },
|
||||
{"0x123-", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_MINUS, "-", 0, 5} },
|
||||
{"0x123*", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_ASTERISK, "*", 0, 5} },
|
||||
{"0x123.", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_DOT, ".", 0, 5} },
|
||||
{"0x123;", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_COMMENT, ";", 0, 5} },
|
||||
{"0x123\n", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 5} },
|
||||
{"0x123\r\n", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 5} },
|
||||
{"0x123 ", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 5} },
|
||||
{"0x123\t", {TOKEN_HEXADECIMAL, "0x123", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 5}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_octal_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"0o123,", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_COMMA, ",", 0, 5} },
|
||||
{"0o123:", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_COLON, ":", 0, 5} },
|
||||
{"0o123[", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_LBRACKET, "[", 0, 5} },
|
||||
{"0o123]", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_RBRACKET, "]", 0, 5} },
|
||||
{"0o123+", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_PLUS, "+", 0, 5} },
|
||||
{"0o123-", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_MINUS, "-", 0, 5} },
|
||||
{"0o123*", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_ASTERISK, "*", 0, 5} },
|
||||
{"0o123.", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_DOT, ".", 0, 5} },
|
||||
{"0o123;", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_COMMENT, ";", 0, 5} },
|
||||
{"0o123\n", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 5} },
|
||||
{"0o123\r\n", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 5} },
|
||||
{"0o123 ", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 5} },
|
||||
{"0o123\t", {TOKEN_OCTAL, "0o123", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 5}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_binary_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"0b101,", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_COMMA, ",", 0, 5} },
|
||||
{"0b101:", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_COLON, ":", 0, 5} },
|
||||
{"0b101[", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_LBRACKET, "[", 0, 5} },
|
||||
{"0b101]", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_RBRACKET, "]", 0, 5} },
|
||||
{"0b101+", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_PLUS, "+", 0, 5} },
|
||||
{"0b101-", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_MINUS, "-", 0, 5} },
|
||||
{"0b101*", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_ASTERISK, "*", 0, 5} },
|
||||
{"0b101.", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_DOT, ".", 0, 5} },
|
||||
{"0b101;", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_COMMENT, ";", 0, 5} },
|
||||
{"0b101\n", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 5} },
|
||||
{"0b101\r\n", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 5} },
|
||||
{"0b101 ", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 5} },
|
||||
{"0b101\t", {TOKEN_BINARY, "0b101", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 5}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_colon_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{":,", {TOKEN_COLON, ":", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"::", {TOKEN_COLON, ":", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{":[", {TOKEN_COLON, ":", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{":]", {TOKEN_COLON, ":", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{":+", {TOKEN_COLON, ":", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{":-", {TOKEN_COLON, ":", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{":*", {TOKEN_COLON, ":", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{":.", {TOKEN_COLON, ":", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{":;", {TOKEN_COLON, ":", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{":\n", {TOKEN_COLON, ":", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{":\r\n", {TOKEN_COLON, ":", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{": ", {TOKEN_COLON, ":", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{":\t", {TOKEN_COLON, ":", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_comma_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{",,", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{",:", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{",[", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{",]", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{",+", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{",-", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{",*", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{",.", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{",;", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{",\n", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{",\r\n", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{", ", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{",\t", {TOKEN_COMMA, ",", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_lbracket_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"[,", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"[:", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{"[[", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{"[]", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{"[+", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{"[-", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{"[*", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"[.", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{"[;", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{"[\n", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{"[\r\n", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{"[ ", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{"[\t", {TOKEN_LBRACKET, "[", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_rbracket_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"],", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"]:", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{"][", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{"]]", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{"]+", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{"]-", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{"]*", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"].", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{"];", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{"]\n", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{"]\r\n", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{"] ", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{"]\t", {TOKEN_RBRACKET, "]", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_plus_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"+,", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"+:", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{"+[", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{"+]", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{"++", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{"+-", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{"+*", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"+.", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{"+;", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{"+\n", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{"+\r\n", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{"+ ", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{"+\t", {TOKEN_PLUS, "+", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_minus_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"-,", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"-:", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{"-[", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{"-]", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{"-+", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{"--", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{"-*", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"-.", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{"-;", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{"-\n", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{"-\r\n", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{"- ", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{"-\t", {TOKEN_MINUS, "-", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_asterisk_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"*,", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{"*:", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{"*[", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{"*]", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{"*+", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{"*-", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{"**", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"*.", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{"*;", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{"*\n", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{"*\r\n", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{"* ", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{"*\t", {TOKEN_ASTERISK, "*", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_dot_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{".,", {TOKEN_DOT, ".", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{".:", {TOKEN_DOT, ".", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{".[", {TOKEN_DOT, ".", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{".]", {TOKEN_DOT, ".", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{".+", {TOKEN_DOT, ".", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{".-", {TOKEN_DOT, ".", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{".*", {TOKEN_DOT, ".", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{"..", {TOKEN_DOT, ".", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{".;", {TOKEN_DOT, ".", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{".\n", {TOKEN_DOT, ".", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{".\r\n", {TOKEN_DOT, ".", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1} },
|
||||
{". ", {TOKEN_DOT, ".", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 1} },
|
||||
{".\t", {TOKEN_DOT, ".", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_comment_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{";comment\n", {TOKEN_COMMENT, ";comment", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 8} },
|
||||
{";comment\r\n", {TOKEN_COMMENT, ";comment", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 8}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_whitespace_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{" ,", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_COMMA, ",", 0, 1} },
|
||||
{" :", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_COLON, ":", 0, 1} },
|
||||
{" [", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_LBRACKET, "[", 0, 1} },
|
||||
{" ]", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_RBRACKET, "]", 0, 1} },
|
||||
{" +", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_PLUS, "+", 0, 1} },
|
||||
{" -", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_MINUS, "-", 0, 1} },
|
||||
{" *", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_ASTERISK, "*", 0, 1} },
|
||||
{" .", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_DOT, ".", 0, 1} },
|
||||
{" ;", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_COMMENT, ";", 0, 1} },
|
||||
{" \n", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 1} },
|
||||
{" \r\n", {TOKEN_WHITESPACE, " ", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 1}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_newline_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"\n,", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_COMMA, ",", 1, 0} },
|
||||
{"\n:", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_COLON, ":", 1, 0} },
|
||||
{"\n[", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_LBRACKET, "[", 1, 0} },
|
||||
{"\n]", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_RBRACKET, "]", 1, 0} },
|
||||
{"\n+", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_PLUS, "+", 1, 0} },
|
||||
{"\n-", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_MINUS, "-", 1, 0} },
|
||||
{"\n*", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_ASTERISK, "*", 1, 0} },
|
||||
{"\n.", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_DOT, ".", 1, 0} },
|
||||
{"\n;", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_COMMENT, ";", 1, 0} },
|
||||
{"\n\n", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_NEWLINE, "\n", 1, 0} },
|
||||
{"\n\r\n", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_NEWLINE, "\r\n", 1, 0} },
|
||||
{"\n ", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_WHITESPACE, " ", 1, 0} },
|
||||
{"\n\t", {TOKEN_NEWLINE, "\n", 0, 0}, {TOKEN_WHITESPACE, "\t", 1, 0}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_crlf_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"\r\n,", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_COMMA, ",", 1, 0} },
|
||||
{"\r\n:", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_COLON, ":", 1, 0} },
|
||||
{"\r\n[", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_LBRACKET, "[", 1, 0} },
|
||||
{"\r\n]", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_RBRACKET, "]", 1, 0} },
|
||||
{"\r\n+", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_PLUS, "+", 1, 0} },
|
||||
{"\r\n-", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_MINUS, "-", 1, 0} },
|
||||
{"\r\n*", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_ASTERISK, "*", 1, 0} },
|
||||
{"\r\n.", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_DOT, ".", 1, 0} },
|
||||
{"\r\n;", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_COMMENT, ";", 1, 0} },
|
||||
{"\r\n\n", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_NEWLINE, "\n", 1, 0} },
|
||||
{"\r\n\r\n", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_NEWLINE, "\r\n", 1, 0} },
|
||||
{"\r\n ", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_WHITESPACE, " ", 1, 0} },
|
||||
{"\r\n\t", {TOKEN_NEWLINE, "\r\n", 0, 0}, {TOKEN_WHITESPACE, "\t", 1, 0}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_number_boundary(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
boundary_t boundaries[] = {
|
||||
{"0x123:8,", {TOKEN_HEXADECIMAL, "0x123:8", 0, 0}, {TOKEN_COMMA, ",", 0, 7} },
|
||||
{"0x123:16:", {TOKEN_HEXADECIMAL, "0x123:16", 0, 0}, {TOKEN_COLON, ":", 0, 8} },
|
||||
{"0o777:32[", {TOKEN_OCTAL, "0o777:32", 0, 0}, {TOKEN_LBRACKET, "[", 0, 8} },
|
||||
{"0b101:64]", {TOKEN_BINARY, "0b101:64", 0, 0}, {TOKEN_RBRACKET, "]", 0, 8} },
|
||||
{"0x123:8+", {TOKEN_HEXADECIMAL, "0x123:8", 0, 0}, {TOKEN_PLUS, "+", 0, 7} },
|
||||
{"0x123:16-", {TOKEN_HEXADECIMAL, "0x123:16", 0, 0}, {TOKEN_MINUS, "-", 0, 8} },
|
||||
{"0o777:32*", {TOKEN_OCTAL, "0o777:32", 0, 0}, {TOKEN_ASTERISK, "*", 0, 8} },
|
||||
{"0b101:64.", {TOKEN_BINARY, "0b101:64", 0, 0}, {TOKEN_DOT, ".", 0, 8} },
|
||||
{"0x123:8;", {TOKEN_HEXADECIMAL, "0x123:8", 0, 0}, {TOKEN_COMMENT, ";", 0, 7} },
|
||||
{"0x123:16\n", {TOKEN_HEXADECIMAL, "0x123:16", 0, 0}, {TOKEN_NEWLINE, "\n", 0, 8} },
|
||||
{"0o777:32\r\n", {TOKEN_OCTAL, "0o777:32", 0, 0}, {TOKEN_NEWLINE, "\r\n", 0, 8} },
|
||||
{"0b101:64 ", {TOKEN_BINARY, "0b101:64", 0, 0}, {TOKEN_WHITESPACE, " ", 0, 8} },
|
||||
{"0x123:8\t", {TOKEN_HEXADECIMAL, "0x123:8", 0, 0}, {TOKEN_WHITESPACE, "\t", 0, 7}},
|
||||
{nullptr, {}, {} },
|
||||
};
|
||||
|
||||
test_lexer_boundary(boundaries);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_maximum_length_numbers(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
char *numbers[] = {
|
||||
"9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"9999999999999999999988",
|
||||
"9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"9999999999999999998:64",
|
||||
"0x99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"9999999999999999999988",
|
||||
"0x99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"9999999999999999998:64",
|
||||
nullptr,
|
||||
};
|
||||
|
||||
for (size_t i = 0; numbers[i]; ++i) {
|
||||
auto number = numbers[i];
|
||||
munit_assert_size(128, ==, strlen(number));
|
||||
lexer_t lex = {};
|
||||
lexer_token_t token = {};
|
||||
lexer_setup_memory_test(&lex, number);
|
||||
lexer_next(&lex, &token);
|
||||
munit_assert_true(token.id == TOKEN_DECIMAL || token.id == TOKEN_HEXADECIMAL);
|
||||
munit_assert_size(128, ==, strlen(token.value));
|
||||
lexer_token_cleanup(&token);
|
||||
lexer_close(&lex);
|
||||
}
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_too_long_numbers(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
char *numbers[] = {
|
||||
"9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"99999999999999999999988",
|
||||
"0x99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"99999999999999999999988",
|
||||
"9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"99999999999999999998:64",
|
||||
"0x99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
"99999999999999999998:64",
|
||||
};
|
||||
|
||||
// Without suffix we expect 128 characters and then failure
|
||||
for (size_t i = 0; i < 2; ++i) {
|
||||
auto number = numbers[i];
|
||||
munit_assert_size(129, ==, strlen(number));
|
||||
lexer_t lex = {};
|
||||
lexer_token_t token = {};
|
||||
lexer_setup_memory_test(&lex, number);
|
||||
lexer_next(&lex, &token);
|
||||
munit_assert_int(TOKEN_ERROR, ==, token.id);
|
||||
munit_assert_size(128, ==, strlen(token.value));
|
||||
lexer_token_cleanup(&token);
|
||||
lexer_close(&lex);
|
||||
}
|
||||
|
||||
// With suffix we fail at the suffix boundary
|
||||
for (size_t i = 2; i < 4; ++i) {
|
||||
auto number = numbers[i];
|
||||
munit_assert_size(129, ==, strlen(number));
|
||||
lexer_t lex = {};
|
||||
lexer_token_t token = {};
|
||||
lexer_setup_memory_test(&lex, number);
|
||||
lexer_next(&lex, &token);
|
||||
munit_assert_int(TOKEN_ERROR, ==, token.id);
|
||||
munit_assert_size(128, >=, strlen(token.value));
|
||||
lexer_token_cleanup(&token);
|
||||
|
||||
lexer_expect_one_token(&lex, TOKEN_COLON, ":", 0, 126);
|
||||
lexer_expect_one_token(&lex, TOKEN_DECIMAL, "64", 0, 127);
|
||||
lexer_close(&lex);
|
||||
}
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_max_whitespace_length(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
char whitespace[1025];
|
||||
memset(whitespace, ' ', 1024);
|
||||
whitespace[1024] = '\0';
|
||||
|
||||
munit_assert_size(1024, ==, strlen(whitespace));
|
||||
lexer_t lex = {};
|
||||
lexer_token_t token = {};
|
||||
lexer_setup_memory_test(&lex, whitespace);
|
||||
lexer_next(&lex, &token);
|
||||
munit_assert_int(TOKEN_WHITESPACE, ==, token.id);
|
||||
munit_assert_size(1024, ==, strlen(token.value));
|
||||
lexer_token_cleanup(&token);
|
||||
lexer_close(&lex);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitResult test_lexer_too_long_whitespace(const MunitParameter params[], void *data) {
|
||||
(void)params;
|
||||
(void)data;
|
||||
|
||||
char whitespace[1026];
|
||||
memset(whitespace, ' ', 1025);
|
||||
whitespace[1025] = '\0';
|
||||
|
||||
munit_assert_size(1025, ==, strlen(whitespace));
|
||||
lexer_t lex = {};
|
||||
lexer_token_t token = {};
|
||||
lexer_setup_memory_test(&lex, whitespace);
|
||||
lexer_next(&lex, &token);
|
||||
munit_assert_int(TOKEN_ERROR, ==, token.id);
|
||||
munit_assert_size(1024, ==, strlen(token.value));
|
||||
lexer_token_cleanup(&token);
|
||||
|
||||
lexer_expect_one_token(&lex, TOKEN_WHITESPACE, " ", 0, 1024);
|
||||
lexer_close(&lex);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
MunitTest lexer_tests[] = {
|
||||
{"/identifier", test_lexer_identifier, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/identifier_boundary", test_lexer_identifier_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/decimal", test_lexer_decimal, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/decimal_boundary", test_lexer_decimal_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/hexadecimal", test_lexer_hexadecimal, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/hexadecimal_with_suffix", test_lexer_hexadecimal_with_suffix, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/hexadecimal_boundary", test_lexer_hexadecimal_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/octal", test_lexer_octal, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/octal_with_suffix", test_lexer_octal_with_suffix, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/octal_boundary", test_lexer_octal_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/binary", test_lexer_binary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/binary_with_suffix", test_lexer_binary_with_suffix, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/binary_boundary", test_lexer_binary_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/number_boundary", test_lexer_number_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/colon", test_lexer_colon, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/colon_boundary", test_lexer_colon_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/comma", test_lexer_comma, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/comma_boundary", test_lexer_comma_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/lbracket", test_lexer_lbracket, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/lbracket_boundary", test_lexer_lbracket_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/rbracket", test_lexer_rbracket, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/rbracket_boundary", test_lexer_rbracket_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/plus", test_lexer_plus, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/plus_boundary", test_lexer_plus_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/minus", test_lexer_minus, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/minus_boundary", test_lexer_minus_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/asterisk", test_lexer_asterisk, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/asterisk_boundary", test_lexer_asterisk_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/dot", test_lexer_dot, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/dot_boundary", test_lexer_dot_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/comment", test_lexer_comment, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/comment_boundary", test_lexer_comment_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/whitespace", test_lexer_whitespace, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/whitespace_boundary", test_lexer_whitespace_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/newlines", test_lexer_newlines, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/newline_boundary", test_lexer_newline_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/crlf_boundary", test_lexer_crlf_boundary, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/line_numbers", test_lexer_line_numbers, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/maximum_length_numbers", test_lexer_maximum_length_numbers, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/too_long_numbers", test_lexer_too_long_numbers, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/max_whitespace_length", test_lexer_max_whitespace_length, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{"/too_long_whitespace", test_lexer_too_long_whitespace, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr},
|
||||
{nullptr, nullptr, nullptr, nullptr, MUNIT_TEST_OPTION_NONE, nullptr}
|
||||
};
|
||||
Reference in New Issue
Block a user