herbglitch/archeus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

working on csv data, parser works but needs more testing, might add bool to ParserData_DestroyFn callback for clearing

Browse source
This commit is contained in:
herbglitch 2024-12-04 02:43:58 -07:00
parent 4c3d357cb9
commit ca6a9c118f
13 changed files with 384 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

364
tests/std/parser.c
View file

@ -1,43 +1,24 @@
#include "../test.h"
#include "arc/std/errno.h"
#include "arc/std/parser.h"
#include "arc/std/parser/helpers.h"
#include "arc/std/lexer.h"
#include "arc/std/vector.h"
#include <stddef.h>
#include <stdlib.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
const uint32_t TEST_PARSER_CHAR_OR_NUM = 23;
const uint32_t TEST_PARSER_VARIABLE_NAME = 24;
const uint32_t TEST_PARSER_VARIABLE = 25;
const uint32_t TEST_LAMBDA = 0;
const uint32_t TEST_ALPHA_LOWER_CHAR = 1;
const uint32_t TEST_ALPHA_UPPER_CHAR = 2;
const uint32_t TEST_ALPHA_CHAR = 3;
void TEST_ParserData_RecurseStringAdd(ARC_String **data, ARC_ParserTagToken *tagToken){
if(tagToken->token != NULL){
ARC_String_Append(data, tagToken->token->data);
return;
}
//TODO: probs don't need this
if(tagToken->tagTokens == NULL){
return;
}
for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){
TEST_ParserData_RecurseStringAdd(data, (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index));
}
}
const uint32_t TEST_PARSER_ALPHA_LOWER_CHAR = 1;
const uint32_t TEST_PARSER_ALPHA_UPPER_CHAR = 2;
const uint32_t TEST_PARSER_ALPHA_CHAR = 3;
void TEST_ParserData_CreateStringFn(void **data, ARC_ParserTagToken *parsedData, void *userData){
ARC_String_Create((ARC_String **)data, NULL, 0);
TEST_ParserData_RecurseStringAdd((ARC_String **)data, parsedData);
ARC_ParserData_HelperRecurseStringAdd((ARC_String **)data, parsedData);
}
void TEST_ParserData_DestroyStringFn(void *data, void *userData){
@ -48,30 +29,27 @@ void TEST_ParserData_DestroyStringFn(void *data, void *userData){
ARC_String_Destroy((ARC_String *)data);
}
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 } };
uint32_t *charOrNumTokens[] = { (uint32_t[]){ 1, ARC_LEXER_TOKEN_ALPHA_LOWER_CHAR }, (uint32_t[]){ 1, ARC_LEXER_TOKEN_NUMBER } };
uint32_t *variableNameTags[] = { (uint32_t[]){ 2, TEST_PARSER_CHAR_OR_NUM, TEST_PARSER_VARIABLE_NAME }, (uint32_t[]){ 1, ARC_PARSER_TAG_LAMBDA } };
uint32_t *variableTokensOrTags[] = { (uint32_t[]){ 2, ARC_LEXER_TOKEN_ALPHA_LOWER_CHAR, TEST_PARSER_VARIABLE_NAME } };
//TODO: note how language function callbacks work, and how they use the parentData if createDataFn is NULL
ARC_ParserData_CreateFn createStringFn = TEST_ParserData_CreateStringFn;
ARC_ParserData_DestroyFn destroyStringFn = TEST_ParserData_DestroyStringFn;
ARC_ParserTag testTags[3] = {
{
VARIABLE, //tagId
TEST_PARSER_VARIABLE, //tagId
variableTokensOrTags, //tokensOrTags
1 //tokenOrTagsSize
},
{
VARIABLE_NAME, //tagId
variableNameTags, //tokensOrTags
2 //tokenOrTagsSize
TEST_PARSER_VARIABLE_NAME, //tagId
variableNameTags, //tokensOrTags
2 //tokenOrTagsSize
},
{
CHAR_OR_NUM, //tagId
charOrNumTokens, //tokensOrTags
2 //tokenOrTagsSize
TEST_PARSER_CHAR_OR_NUM, //tagId
charOrNumTokens, //tokensOrTags
2 //tokenOrTagsSize
}
};
@ -84,175 +62,179 @@ void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){
ARC_Lexer_InitBasicTokenRules(lexer);
}
//ARC_TEST(Parser_Init){
// ARC_Parser *parser;
// ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
//
// ARC_Parser_Destroy(parser);
//
// ARC_CHECK(arc_errno == 0);
//}
//
//ARC_TEST(Parser_Basic_Parse){
// ARC_Parser *parser;
// ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
//
// ARC_String *tempString;
//
//
// /* ~ first 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 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 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 test ~ */
// ARC_String_CreateWithStrlen(&tempString, "aaaaa");
//
// //this destroys string, so no need for cleanup
// ARC_Parser_Parse(parser, &tempString);
//
// ARC_CHECK(arc_errno == 0);
//
//
// /* ~ cleanup ~ */
// ARC_Parser_Destroy(parser);
//}
ARC_TEST(Parser_Init){
ARC_Parser *parser;
ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
//ARC_TEST(Parser_Basic_ParseError){
// ARC_Parser *parser;
// ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
//
// ARC_String *tempString;
//
//
// /* ~ first test ~ */
// 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);
//
//
// /* ~ second test ~ */
// //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);
//
//
// /* ~ third test ~ */
// //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);
//
//
// /* ~ cleanup ~ */
// ARC_Parser_Destroy(parser);
//
// //reset for next test
// arc_errno = 0;
//}
ARC_Parser_Destroy(parser);
//ARC_TEST(Parser_Basic_GetParsedValue){
// ARC_Parser *parser;
// ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, &destroyStringFn, NULL);
//
// ARC_String *tempString;
//
//
// /* ~ first test ~ */
// ARC_String_CreateWithStrlen(&tempString, "myvar1");
//
// //this destroys string, so no need for cleanup
// ARC_Parser_Parse(parser, &tempString);
//
// ARC_CHECK(arc_errno == 0);
//
// ARC_String *checkValue = (ARC_String *)ARC_Parser_GetData(parser);
// ARC_CHECK(ARC_String_EqualsCStringWithStrlen(checkValue, "myvar1"));
//
//
// /* ~ cleanup ~ */
// ARC_Parser_Destroy(parser);
//}
//
//ARC_TEST(Parser_ParserLang_BasicVector){
// ARC_Vector *testLanguage;
// ARC_Vector_Create(&testLanguage, NULL, NULL);
//
// ARC_Vector_Add(testLanguage, testTags + 0);
// ARC_Vector_Add(testLanguage, testTags + 1);
// ARC_Vector_Add(testLanguage, testTags + 2);
//
// ARC_Parser *parser;
// ARC_Parser_CreateFromVector(&parser, testLanguage, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
//
// ARC_String *tempString;
// ARC_String_CreateWithStrlen(&tempString, "variablename");
//
// //this destroys string, so no need for cleanup
// ARC_Parser_Parse(parser, &tempString);
//
// //cleanup
// ARC_Parser_Destroy(parser);
// ARC_Vector_Destroy(testLanguage);
//
// ARC_CHECK(arc_errno == 0);
//}
ARC_CHECK(arc_errno == 0);
}
ARC_TEST(Parser_Basic_Parse){
ARC_Parser *parser;
ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
ARC_String *tempString;
/* ~ first 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 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 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 test ~ */
ARC_String_CreateWithStrlen(&tempString, "aaaaa");
//this destroys string, so no need for cleanup
ARC_Parser_Parse(parser, &tempString);
ARC_CHECK(arc_errno == 0);
/* ~ cleanup ~ */
ARC_Parser_Destroy(parser);
}
ARC_TEST(Parser_Basic_ParseError){
ARC_Parser *parser;
ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
ARC_String *tempString;
/* ~ first test ~ */
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);
/* ~ second test ~ */
//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);
/* ~ third test ~ */
//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);
/* ~ cleanup ~ */
ARC_Parser_Destroy(parser);
//reset for next test
arc_errno = 0;
}
ARC_TEST(Parser_Basic_GetParsedValue){
ARC_Parser *parser;
ARC_ParserData_CreateFn createStringFn = TEST_ParserData_CreateStringFn;
ARC_ParserData_DestroyFn destroyStringFn = TEST_ParserData_DestroyStringFn;
ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, &destroyStringFn, NULL);
ARC_String *tempString;
/* ~ first test ~ */
ARC_String_CreateWithStrlen(&tempString, "myvar1");
//this destroys string, so no need for cleanup
ARC_Parser_Parse(parser, &tempString);
ARC_CHECK(arc_errno == 0);
ARC_String *checkValue = (ARC_String *)ARC_Parser_GetData(parser);
ARC_CHECK(ARC_String_EqualsCStringWithStrlen(checkValue, "myvar1"));
/* ~ cleanup ~ */
ARC_Parser_Destroy(parser);
}
ARC_TEST(Parser_ParserLang_BasicVector){
ARC_Vector *testLanguage;
ARC_Vector_Create(&testLanguage, NULL, NULL);
ARC_Vector_Add(testLanguage, testTags + 0);
ARC_Vector_Add(testLanguage, testTags + 1);
ARC_Vector_Add(testLanguage, testTags + 2);
ARC_Parser *parser;
ARC_Parser_CreateFromVector(&parser, testLanguage, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL);
ARC_String *tempString;
ARC_String_CreateWithStrlen(&tempString, "variablename");
//this destroys string, so no need for cleanup
ARC_Parser_Parse(parser, &tempString);
//cleanup
ARC_Parser_Destroy(parser);
ARC_Vector_Destroy(testLanguage);
ARC_CHECK(arc_errno == 0);
}
/* ~ parser tests ~ */
void TEST_Parser_InitBasicLexerTokenRules(ARC_Lexer *lexer){
//null
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(TEST_LAMBDA, 0));
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(ARC_PARSER_TAG_LAMBDA, 0));
//alpha char
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_ALPHA_LOWER_CHAR, 'a', 'z'));
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_ALPHA_UPPER_CHAR, 'A', 'Z'));
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_PARSER_ALPHA_LOWER_CHAR, 'a', 'z'));
ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_PARSER_ALPHA_UPPER_CHAR, 'A', 'Z'));
}
uint32_t TEST_Parser_GetStringIdFn(ARC_String *string){
if(ARC_String_EqualsCStringWithStrlen(string, "<alphaChar>")){
return TEST_ALPHA_CHAR;
return TEST_PARSER_ALPHA_CHAR;
}
if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){
return TEST_ALPHA_LOWER_CHAR;
return TEST_PARSER_ALPHA_LOWER_CHAR;
}
if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){
return TEST_ALPHA_UPPER_CHAR;
return TEST_PARSER_ALPHA_UPPER_CHAR;
}
return ~(uint32_t)0;

25
tests/std/parser/parserlang.c
View file

@ -4,23 +4,20 @@
#include "arc/std/string.h"
#include "arc/std/parser/parserlang.h"
const uint32_t TEST_LAMBDA = 0;
const uint32_t TEST_ALPHA_LOWER_CHAR = 1;
const uint32_t TEST_ALPHA_UPPER_CHAR = 2;
const uint32_t TEST_ALPHA_CHAR = 3;
uint32_t TEST_PARSERLANG_ALPHA_CHAR = 24;
/* ~ parserlang tests ~ */
uint32_t TEST_ParserLang_GetIdFn(ARC_String *string){
if(ARC_String_EqualsCStringWithStrlen(string, "<alphaChar>")){
return TEST_ALPHA_CHAR;
return TEST_PARSERLANG_ALPHA_CHAR;
}
if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){
return TEST_ALPHA_LOWER_CHAR;
return ARC_PARSERLANG_TOKEN_ALPHA_LOWER_CHAR;
}
if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){
return TEST_ALPHA_UPPER_CHAR;
return ARC_PARSERLANG_TOKEN_ALPHA_UPPER_CHAR;
}
return ~(uint32_t)0;
@ -31,7 +28,7 @@ ARC_TEST(Parser_ParserLang_BasicTest){
ARC_ParserLang_CreateAsParser(&parser, TEST_ParserLang_GetIdFn);
ARC_String *tempString;
ARC_String_CreateWithStrlen(&tempString, "<alphaChar> -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR\n");
ARC_String_CreateWithStrlen(&tempString, "\n\n<alphaChar> -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR\n\n\n");
//this destroys string, so no need for cleanup
ARC_Parser_Parse(parser, &tempString);
@ -40,13 +37,13 @@ ARC_TEST(Parser_ParserLang_BasicTest){
void *data = ARC_Parser_GetData(parser);
ARC_ParserTag *tag = ARC_Vector_Get((ARC_Vector *)data, 0);
ARC_CHECK(tag->tagId == TEST_ALPHA_CHAR);
ARC_CHECK(tag->tagId == TEST_PARSERLANG_ALPHA_CHAR);
ARC_CHECK(tag->tokensOrTagsSize == 2);
ARC_CHECK(tag->tokensOrTags[0][0] == 1);
ARC_CHECK(tag->tokensOrTags[0][1] == TEST_ALPHA_LOWER_CHAR);
ARC_CHECK(tag->tokensOrTags[1][0] == 1);
ARC_CHECK(tag->tokensOrTags[1][1] == TEST_ALPHA_UPPER_CHAR);
ARC_CHECK(tag->tokensOrTagsSize == 2);
ARC_CHECK(tag->tokensOrTags[0][0] == 1);
ARC_CHECK(tag->tokensOrTags[0][1] == ARC_PARSERLANG_TOKEN_ALPHA_LOWER_CHAR);
ARC_CHECK(tag->tokensOrTags[1][0] == 1);
ARC_CHECK(tag->tokensOrTags[1][1] == ARC_PARSERLANG_TOKEN_ALPHA_UPPER_CHAR);
ARC_Parser_Destroy(parser);
}