mirror of https://github.com/mgba-emu/mgba.git
Debugger: Simple parser tests
This commit is contained in:
Vicki Pfau
parent
47605b40e7
commit
ab2437fcb8
|
|
@ -0,0 +1,401 @@
|
|||
/* Copyright (c) 2013-2017 Jeffrey Pfau
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
#include "util/test/suite.h"
|
||||
|
||||
#include <mgba/internal/debugger/parser.h>
|
||||
|
||||
#define LEX(STR) \
|
||||
struct LexVector* lv = *state; \
|
||||
lexFree(lv); \
|
||||
LexVectorClear(lv); \
|
||||
size_t adjusted = lexExpression(lv, STR, strlen(STR)); \
|
||||
assert_false(adjusted > strlen(STR))
|
||||
|
||||
M_TEST_SUITE_SETUP(Lexer) {
|
||||
struct LexVector* lv = malloc(sizeof(struct LexVector));
|
||||
LexVectorInit(lv, 0);
|
||||
*state = lv;
|
||||
return 0;
|
||||
}
|
||||
|
||||
M_TEST_SUITE_TEARDOWN(Lexer) {
|
||||
struct LexVector* lv = *state;
|
||||
lexFree(lv);
|
||||
LexVectorDeinit(lv);
|
||||
free(lv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexEmpty) {
|
||||
LEX("");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 0);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInt) {
|
||||
LEX("0");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 0);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexDecimal) {
|
||||
LEX("10");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 10);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexBinary) {
|
||||
LEX("0b10");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 2);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexHex) {
|
||||
LEX("0x10");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 0x10);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidDecimal) {
|
||||
LEX("1a");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidBinary) {
|
||||
LEX("0b12");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidHex) {
|
||||
LEX("0x1g");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexTruncatedBinary) {
|
||||
LEX("0b");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexTruncatedHex) {
|
||||
LEX("0x");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifier) {
|
||||
LEX("x");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexAddOperator) {
|
||||
LEX("1+");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierAddOperator) {
|
||||
LEX("x+");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexSubOperator) {
|
||||
LEX("1-");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SUBTRACT);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierSubOperator) {
|
||||
LEX("x-");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_SUBTRACT);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexMulOperator) {
|
||||
LEX("1*");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MULTIPLY);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierMulOperator) {
|
||||
LEX("x*");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_MULTIPLY);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexDivOperator) {
|
||||
LEX("1/");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_DIVIDE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierDivOperator) {
|
||||
LEX("x/");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_DIVIDE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexAndOperator) {
|
||||
LEX("1&");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierAndOperator) {
|
||||
LEX("x&");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_AND);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexOrOperator) {
|
||||
LEX("1|");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierOrOperator) {
|
||||
LEX("x|");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_OR);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexXorOperator) {
|
||||
LEX("1^");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_XOR);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierXorOperator) {
|
||||
LEX("x^");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_XOR);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexLessOperator) {
|
||||
LEX("1<");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierLessOperator) {
|
||||
LEX("x<");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_LESS);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexGreaterOperator) {
|
||||
LEX("1>");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierGreaterOperator) {
|
||||
LEX("x>");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_GREATER);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexSimpleExpression) {
|
||||
LEX("1+1");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->uintValue, 1);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexOpenParen) {
|
||||
LEX("(");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexCloseParen) {
|
||||
LEX("(0)");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 0);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierCloseParen) {
|
||||
LEX("(x)");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(lv, 1)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexParentheticalExpression) {
|
||||
LEX("(1+1)");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 5);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 3)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexNestedParentheticalExpression) {
|
||||
LEX("(1+(2+3))");
|
||||
|
||||
assert_int_equal(LexVectorSize(lv), 9);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 1)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 2)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 3)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 4)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 4)->uintValue, 2);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 5)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 5)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 6)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 6)->uintValue, 3);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 7)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(lv, 8)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(Lexer,
|
||||
cmocka_unit_test(lexEmpty),
|
||||
cmocka_unit_test(lexInt),
|
||||
cmocka_unit_test(lexDecimal),
|
||||
cmocka_unit_test(lexHex),
|
||||
cmocka_unit_test(lexBinary),
|
||||
cmocka_unit_test(lexInvalidDecimal),
|
||||
cmocka_unit_test(lexInvalidHex),
|
||||
cmocka_unit_test(lexInvalidBinary),
|
||||
cmocka_unit_test(lexTruncatedHex),
|
||||
cmocka_unit_test(lexTruncatedBinary),
|
||||
cmocka_unit_test(lexIdentifier),
|
||||
cmocka_unit_test(lexAddOperator),
|
||||
cmocka_unit_test(lexIdentifierAddOperator),
|
||||
cmocka_unit_test(lexSubOperator),
|
||||
cmocka_unit_test(lexIdentifierSubOperator),
|
||||
cmocka_unit_test(lexMulOperator),
|
||||
cmocka_unit_test(lexIdentifierMulOperator),
|
||||
cmocka_unit_test(lexDivOperator),
|
||||
cmocka_unit_test(lexIdentifierDivOperator),
|
||||
cmocka_unit_test(lexAndOperator),
|
||||
cmocka_unit_test(lexIdentifierAndOperator),
|
||||
cmocka_unit_test(lexOrOperator),
|
||||
cmocka_unit_test(lexIdentifierOrOperator),
|
||||
cmocka_unit_test(lexXorOperator),
|
||||
cmocka_unit_test(lexIdentifierXorOperator),
|
||||
cmocka_unit_test(lexLessOperator),
|
||||
cmocka_unit_test(lexIdentifierLessOperator),
|
||||
cmocka_unit_test(lexGreaterOperator),
|
||||
cmocka_unit_test(lexIdentifierGreaterOperator),
|
||||
cmocka_unit_test(lexSimpleExpression),
|
||||
cmocka_unit_test(lexOpenParen),
|
||||
cmocka_unit_test(lexCloseParen),
|
||||
cmocka_unit_test(lexIdentifierCloseParen),
|
||||
cmocka_unit_test(lexParentheticalExpression),
|
||||
cmocka_unit_test(lexNestedParentheticalExpression))
|
||||
|
|
@ -7,453 +7,113 @@
|
|||
|
||||
#include <mgba/internal/debugger/parser.h>
|
||||
|
||||
#define LEX(STR) \
|
||||
struct LexVector lv; \
|
||||
LexVectorInit(&lv, 0); \
|
||||
size_t adjusted = lexExpression(&lv, STR, strlen(STR)); \
|
||||
assert_false(adjusted > strlen(STR))
|
||||
struct LPTest {
|
||||
struct LexVector lv;
|
||||
struct ParseTree tree;
|
||||
};
|
||||
|
||||
#define UNLEX \
|
||||
lexFree(&lv); \
|
||||
LexVectorDeinit(&lv)
|
||||
#define PARSE(STR) \
|
||||
struct LPTest* lp = *state; \
|
||||
lexFree(&lp->lv); \
|
||||
LexVectorClear(&lp->lv); \
|
||||
size_t adjusted = lexExpression(&lp->lv, STR, strlen(STR)); \
|
||||
assert_false(adjusted > strlen(STR)); \
|
||||
struct ParseTree* tree = &lp->tree; \
|
||||
parseLexedExpression(tree, &lp->lv)
|
||||
|
||||
M_TEST_DEFINE(lexEmpty) {
|
||||
LEX("");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 0);
|
||||
|
||||
UNLEX;
|
||||
M_TEST_SUITE_SETUP(Parser) {
|
||||
struct LPTest* lp = malloc(sizeof(struct LPTest));
|
||||
LexVectorInit(&lp->lv, 0);
|
||||
*state = lp;
|
||||
return 0;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInt) {
|
||||
LEX("0");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 0);
|
||||
|
||||
UNLEX;
|
||||
M_TEST_SUITE_TEARDOWN(Parser) {
|
||||
struct LPTest* lp = *state;
|
||||
parseFree(lp->tree.lhs); \
|
||||
parseFree(lp->tree.rhs); \
|
||||
lexFree(&lp->lv);
|
||||
LexVectorDeinit(&lp->lv);
|
||||
free(lp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexDecimal) {
|
||||
LEX("10");
|
||||
M_TEST_DEFINE(parseEmpty) {
|
||||
PARSE("");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 10);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexBinary) {
|
||||
LEX("0b10");
|
||||
M_TEST_DEFINE(parseInt) {
|
||||
PARSE("0");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 2);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->token.uintValue, 0);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexHex) {
|
||||
LEX("0x10");
|
||||
M_TEST_DEFINE(parseLexError) {
|
||||
PARSE("@");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 0x10);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_ERROR_TYPE);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidDecimal) {
|
||||
LEX("1a");
|
||||
M_TEST_DEFINE(parseSimpleExpression) {
|
||||
PARSE("1+2");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->token.operatorValue, OP_ADD);
|
||||
assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->lhs->token.uintValue, 1);
|
||||
assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->rhs->token.uintValue, 2);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidBinary) {
|
||||
LEX("0b12");
|
||||
M_TEST_DEFINE(parseAddMultplyExpression) {
|
||||
PARSE("1+2*3");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->token.operatorValue, OP_ADD);
|
||||
assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->lhs->token.uintValue, 1);
|
||||
assert_int_equal(tree->rhs->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->rhs->token.uintValue, OP_MULTIPLY);
|
||||
assert_int_equal(tree->rhs->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->rhs->lhs->token.uintValue, 2);
|
||||
assert_int_equal(tree->rhs->rhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->rhs->rhs->token.uintValue, 3);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexInvalidHex) {
|
||||
LEX("0x1g");
|
||||
M_TEST_DEFINE(parseParentheticalExpression) {
|
||||
PARSE("(1+2)");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->token.operatorValue, OP_ADD);
|
||||
assert_int_equal(tree->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->lhs->token.uintValue, 1);
|
||||
assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->rhs->token.uintValue, 2);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexTruncatedBinary) {
|
||||
LEX("0b");
|
||||
M_TEST_DEFINE(parseParentheticalAddMultplyExpression) {
|
||||
PARSE("(1+2)*3");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
|
||||
UNLEX;
|
||||
assert_int_equal(tree->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->token.operatorValue, OP_MULTIPLY);
|
||||
assert_int_equal(tree->lhs->token.type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(tree->lhs->token.uintValue, OP_ADD);
|
||||
assert_int_equal(tree->lhs->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->lhs->lhs->token.uintValue, 1);
|
||||
assert_int_equal(tree->lhs->lhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->lhs->rhs->token.uintValue, 2);
|
||||
assert_int_equal(tree->rhs->token.type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(tree->rhs->token.uintValue, 3);
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexTruncatedHex) {
|
||||
LEX("0x");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_ERROR_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifier) {
|
||||
LEX("x");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexAddOperator) {
|
||||
LEX("1+");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_ADD);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierAddOperator) {
|
||||
LEX("x+");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_ADD);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexSubOperator) {
|
||||
LEX("1-");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_SUBTRACT);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierSubOperator) {
|
||||
LEX("x-");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_SUBTRACT);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexMulOperator) {
|
||||
LEX("1*");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_MULTIPLY);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierMulOperator) {
|
||||
LEX("x*");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_MULTIPLY);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexDivOperator) {
|
||||
LEX("1/");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_DIVIDE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierDivOperator) {
|
||||
LEX("x/");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_DIVIDE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexAndOperator) {
|
||||
LEX("1&");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_AND);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierAndOperator) {
|
||||
LEX("x&");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_AND);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexOrOperator) {
|
||||
LEX("1|");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_OR);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierOrOperator) {
|
||||
LEX("x|");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_OR);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexXorOperator) {
|
||||
LEX("1^");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_XOR);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierXorOperator) {
|
||||
LEX("x^");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_XOR);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexLessOperator) {
|
||||
LEX("1<");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_LESS);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierLessOperator) {
|
||||
LEX("x<");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_LESS);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexGreaterOperator) {
|
||||
LEX("1>");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_GREATER);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierGreaterOperator) {
|
||||
LEX("x>");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 0)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_GREATER);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexSimpleExpression) {
|
||||
LEX("1+1");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->uintValue, 1);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexOpenParen) {
|
||||
LEX("(");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexCloseParen) {
|
||||
LEX("(0)");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->uintValue, 0);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexIdentifierCloseParen) {
|
||||
LEX("(x)");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 3);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_IDENTIFIER_TYPE);
|
||||
assert_string_equal(LexVectorGetPointer(&lv, 1)->identifierValue, "x");
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexParentheticalExpression) {
|
||||
LEX("(1+1)");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 5);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 3)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 3)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 4)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_DEFINE(lexNestedParentheticalExpression) {
|
||||
LEX("(1+(2+3))");
|
||||
|
||||
assert_int_equal(LexVectorSize(&lv), 9);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 0)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 1)->uintValue, 1);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 2)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 3)->type, TOKEN_OPEN_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 4)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 4)->uintValue, 2);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 5)->type, TOKEN_OPERATOR_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 5)->operatorValue, OP_ADD);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 6)->type, TOKEN_UINT_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 6)->uintValue, 3);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 7)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
assert_int_equal(LexVectorGetPointer(&lv, 8)->type, TOKEN_CLOSE_PAREN_TYPE);
|
||||
|
||||
UNLEX;
|
||||
}
|
||||
|
||||
M_TEST_SUITE_DEFINE(Lexer,
|
||||
cmocka_unit_test(lexEmpty),
|
||||
cmocka_unit_test(lexInt),
|
||||
cmocka_unit_test(lexDecimal),
|
||||
cmocka_unit_test(lexHex),
|
||||
cmocka_unit_test(lexBinary),
|
||||
cmocka_unit_test(lexInvalidDecimal),
|
||||
cmocka_unit_test(lexInvalidHex),
|
||||
cmocka_unit_test(lexInvalidBinary),
|
||||
cmocka_unit_test(lexTruncatedHex),
|
||||
cmocka_unit_test(lexTruncatedBinary),
|
||||
cmocka_unit_test(lexIdentifier),
|
||||
cmocka_unit_test(lexAddOperator),
|
||||
cmocka_unit_test(lexIdentifierAddOperator),
|
||||
cmocka_unit_test(lexSubOperator),
|
||||
cmocka_unit_test(lexIdentifierSubOperator),
|
||||
cmocka_unit_test(lexMulOperator),
|
||||
cmocka_unit_test(lexIdentifierMulOperator),
|
||||
cmocka_unit_test(lexDivOperator),
|
||||
cmocka_unit_test(lexIdentifierDivOperator),
|
||||
cmocka_unit_test(lexAndOperator),
|
||||
cmocka_unit_test(lexIdentifierAndOperator),
|
||||
cmocka_unit_test(lexOrOperator),
|
||||
cmocka_unit_test(lexIdentifierOrOperator),
|
||||
cmocka_unit_test(lexXorOperator),
|
||||
cmocka_unit_test(lexIdentifierXorOperator),
|
||||
cmocka_unit_test(lexLessOperator),
|
||||
cmocka_unit_test(lexIdentifierLessOperator),
|
||||
cmocka_unit_test(lexGreaterOperator),
|
||||
cmocka_unit_test(lexIdentifierGreaterOperator),
|
||||
cmocka_unit_test(lexSimpleExpression),
|
||||
cmocka_unit_test(lexOpenParen),
|
||||
cmocka_unit_test(lexCloseParen),
|
||||
cmocka_unit_test(lexIdentifierCloseParen),
|
||||
cmocka_unit_test(lexParentheticalExpression),
|
||||
cmocka_unit_test(lexNestedParentheticalExpression))
|
||||
M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(Parser,
|
||||
cmocka_unit_test(parseEmpty),
|
||||
cmocka_unit_test(parseInt),
|
||||
cmocka_unit_test(parseLexError),
|
||||
cmocka_unit_test(parseSimpleExpression),
|
||||
cmocka_unit_test(parseAddMultplyExpression),
|
||||
cmocka_unit_test(parseParentheticalExpression),
|
||||
cmocka_unit_test(parseParentheticalAddMultplyExpression))
|
||||
|
|
|
|||
Loading…
Reference in New Issue