omicron
27099c9899
- 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
897 lines
41 KiB
C
897 lines
41 KiB
C
#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}
|
|
};
|