archeus/tests/std/parser.c

#include "../test.h"
#include "arc/std/errno.h"
#include "arc/std/parser.h"
#include "arc/std/parser/parserlang.h"

#define LAMBDA        ARC_PARSER_TAG_LAMBDA
#define CHAR          ARC_LEXER_TOKEN_ALPHALOWERCHAR
#define NUM           ARC_LEXER_TOKEN_NUMBER
#define CHAR_OR_NUM   23
#define VARIABLE_NAME 24
#define VARIABLE      25

void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){
    ARC_Lexer_InitBasicTokenRules(lexer);
}

ARC_TEST(Parser_Init){
    ARC_Parser *parser;

    uint32_t *charOrNumTokens[]      = { (uint32_t[]){ 1, CHAR }, (uint32_t[]){ 1, NUM } };
    uint32_t *variableNameTags[]     = { (uint32_t[]){ 2, CHAR_OR_NUM, VARIABLE_NAME }, (uint32_t[]){ 1, LAMBDA } };
    uint32_t *variableTokensOrTags[] = { (uint32_t[]){ 2, CHAR, VARIABLE_NAME } };
    ARC_ParserLanguageTag testTags[3] = {
        {
            VARIABLE,             //tagId
            variableTokensOrTags, //tokensOrTags
            1                     //tokenOrTagsSize
        },
        {
            VARIABLE_NAME,    //tagId
            variableNameTags, //tokensOrTags
            2                 //tokenOrTagsSize
        },
        {
            CHAR_OR_NUM,     //tagId
            charOrNumTokens, //tokensOrTags
            2                //tokenOrTagsSize
        }
    };

    ARC_Array languageArray = {
        3,       //size
        testTags //data
    };

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn);

    ARC_Parser_Destroy(parser);

    ARC_CHECK(1 == 1);
}

ARC_TEST(Parser_Basic_Parse){
    ARC_Parser *parser;

    uint32_t *charOrNumTokens[]      = { (uint32_t[]){ 1, CHAR }, (uint32_t[]){ 1, NUM } };
    uint32_t *variableNameTags[]     = { (uint32_t[]){ 2, CHAR_OR_NUM, VARIABLE_NAME }, (uint32_t[]){ 1, LAMBDA } };
    uint32_t *variableTokensOrTags[] = { (uint32_t[]){ 2, CHAR, VARIABLE_NAME } };
    ARC_ParserLanguageTag testTags[3] = {
        {
            VARIABLE,             //tagId
            variableTokensOrTags, //tokensOrTags
            1                     //tokenOrTagsSize
        },
        {
            VARIABLE_NAME,    //tagId
            variableNameTags, //tokensOrTags
            2                 //tokenOrTagsSize
        },
        {
            CHAR_OR_NUM,     //tagId
            charOrNumTokens, //tokensOrTags
            2                //tokenOrTagsSize
        }
    };

    ARC_Array languageArray = {
        3,       //size
        testTags //data
    };

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn);
    ARC_String *tempString;


    //first variable test
    ARC_String_CreateWithStrlen(&tempString, "myvar1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    //second variable test
    ARC_String_CreateWithStrlen(&tempString, "z1xwvq");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    //third variable test
    ARC_String_CreateWithStrlen(&tempString, "z1234");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    //fourth variable test
    ARC_String_CreateWithStrlen(&tempString, "aaaaa");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    ARC_Parser_Destroy(parser);
}

ARC_TEST(Parser_Basic_ParseError){
    ARC_Parser *parser;

    uint32_t *charOrNumTokens[]      = { (uint32_t[]){ 1, CHAR }, (uint32_t[]){ 1, NUM } };
    uint32_t *variableNameTags[]     = { (uint32_t[]){ 2, CHAR_OR_NUM, VARIABLE_NAME }, (uint32_t[]){ 1, LAMBDA } };
    uint32_t *variableTokensOrTags[] = { (uint32_t[]){ 2, CHAR, VARIABLE_NAME } };
    ARC_ParserLanguageTag testTags[3] = {
        {
            VARIABLE,             //tagId
            variableTokensOrTags, //tokensOrTags
            1                     //tokenOrTagsSize
        },
        {
            VARIABLE_NAME,    //tagId
            variableNameTags, //tokensOrTags
            2                 //tokenOrTagsSize
        },
        {
            CHAR_OR_NUM,     //tagId
            charOrNumTokens, //tokensOrTags
            2                //tokenOrTagsSize
        }
    };

    ARC_Array languageArray = {
        3,       //size
        testTags //data
    };

    //TODO: remove this
    arc_errno = 0;

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn);

    ARC_String *tempString;
    ARC_String_CreateWithStrlen(&tempString, "!myVar1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);

    //check again with moved character
    arc_errno = 0;
    ARC_String_CreateWithStrlen(&tempString, "my!Var1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);

    //check again with moved character
    arc_errno = 0;
    ARC_String_CreateWithStrlen(&tempString, "myVar1!");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);

    ARC_Parser_Destroy(parser);

    //reset for next test
    arc_errno = 0;
}

ARC_TEST(Parser_ParserLang_BasicTest){
    ARC_Parser *parser;
    ARC_Parser_CreateAsParserLang(&parser);

    ARC_String *tempString;
    ARC_String_CreateWithStrlen(&tempString, "<test> -> <testingStuffs>\n");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_Parser_Destroy(parser);

    ARC_CHECK(arc_errno == 0);
}