95 lines
3.6 KiB
C
95 lines
3.6 KiB
C
#include <stdio.h>
|
|
#include "main.h"
|
|
|
|
struct test
|
|
{
|
|
char * regex;
|
|
struct match
|
|
{
|
|
char * s;
|
|
int expect;
|
|
} matches[0xff];
|
|
} test_suite[] =
|
|
{
|
|
// Basic
|
|
{"abc", {{"a", 0},{"abc", 1}, {"abcd",0 }, {NULL}}},
|
|
{"a.c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"aac", 1}, {NULL}}},
|
|
{"ab+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 0}, {NULL}}},
|
|
{"ab*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
|
|
{"ab?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 0}, {"ac", 1}, {NULL}}},
|
|
|
|
// . Compose
|
|
{"a..c", {{"a", 0},{"abc", 0}, {"abcd",0 }, {"acc", 0}, {"ac", 0}, {"abbc", 1}, {NULL}}},
|
|
{"a.+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 0}, {"abbc", 1}, {NULL}}},
|
|
{"a.*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 1}, {"abbc", 1}, {NULL}}},
|
|
{"a.?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 1}, {NULL}}},
|
|
|
|
// TODO: Implement NFA to DFA to avoid loops
|
|
|
|
// Equal to *
|
|
{"ab+?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
|
|
{"ab*?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
|
|
//{"ab?+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"ababc", 1}, {"ac", 1}, {NULL}}},
|
|
//{"ab?*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"ababc", 1}, {"ac", 1}, {NULL}}},
|
|
{"a+*", {{"aaaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1}, {NULL}}},
|
|
//{"a**", {{"aaaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1}, {NULL}}},
|
|
|
|
// Nilpotent
|
|
{"ab??c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 0}, {"ac", 1}, {"c", 0}, {NULL}}},
|
|
{"ab++c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 0}, {"c", 0}, {"ababc",0}, {NULL}}},
|
|
//{"ab**c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {"c", 1}, {"ababc",1}, {NULL}}},
|
|
|
|
// UNION
|
|
{"a()", {{"a", 1},{"abc", 0}, {"b", 0 }, {"ba", 0}, {NULL}}},
|
|
{"a(b)", {{"ab", 1},{"abc", 0}, {"b", 0 }, {"ba", 0}, {NULL}}},
|
|
{"a(b)*", {{"ab", 1},{"abb", 1}, {"a", 1 }, {"ba", 0}, {NULL}}},
|
|
{"a|b", {{"a", 1},{"abc", 0}, {"b", 1 }, {"ba", 0}, {NULL}}},
|
|
{"(a|.)*", {{"a", 1},{"abc", 1}, {"b", 1 }, {"ba", 1}, {NULL}}},
|
|
{"(.|a)*", {{"a", 1},{"abc", 1}, {"b", 1 }, {"ba", 1}, {NULL}}},
|
|
{"(b|a)*", {{"a", 1},{"cab", 0}, {"b", 1 }, {"ab", 1}, {"cacb", 0}, {NULL}}},
|
|
{"c(b|a)*", {{"ca", 1},{"cab", 1}, {"b", 0 }, {"bb", 0}, {"cacb", 0}, {NULL}}},
|
|
{"ab|b", {{"ab", 1}, {"b", 1}, {"abb", 0}, {NULL}}},
|
|
{"a|b|c", {{"a", 1}, {"b", 1}, {"c", 1},{"d",0}, {NULL}}},
|
|
{"((a|b)|c)d", {{"ad", 1}, {"bd", 1}, {"cd", 1},{"a",0}, {NULL}}},
|
|
|
|
// BLOCK
|
|
{"(abb", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
|
|
{"abb)", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
|
|
{"a(bb", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
|
|
{"ab)b", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
|
|
{"(ab)b", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
|
|
{"(ab)+", {{"ab", 1}, {"abab", 1}, {"b", 0}, {NULL}}},
|
|
{"(a(bc)*)", {{"a", 1}, {"abc", 1}, {"abb", 0}, {NULL}}},
|
|
{"(ab|cd)", {{"ab", 1}, {"cd", 1}, {"abcd", 0}, {NULL}}},
|
|
|
|
// REDOS
|
|
{"a*b?a*", {{"aaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaba", 1}, {NULL}}},
|
|
} ;
|
|
|
|
|
|
int main(void)
|
|
{
|
|
int i=0, j=0;
|
|
|
|
for(i =0; i<sizeof(test_suite)/sizeof(*test_suite); ++i)
|
|
{
|
|
struct test t = test_suite[i];
|
|
struct rgx_nfa * nfa;
|
|
|
|
printf("\n\t%s\n", t.regex);
|
|
nfa = rgx_compile(NULL, t.regex, 1);
|
|
|
|
if (!nfa ){
|
|
printf("Malformed\n");
|
|
continue;
|
|
}
|
|
|
|
for( struct match * m = t.matches; m->s; ++m)
|
|
{
|
|
int res;
|
|
res = rgx_run(nfa, m->s);
|
|
printf("%s: %d %s\n", res == m->expect?"PASS":"FAIL", res, m->s);
|
|
}
|
|
}
|
|
}
|