113 lines
2.8 KiB
C
113 lines
2.8 KiB
C
/*
|
|
* Copyright (c) Camden Dixie O'Brien
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
#include "construct.h"
|
|
#include "testing.h"
|
|
|
|
static void test_empty_expression(void)
|
|
{
|
|
regex_term_t *terms = malloc(1 * sizeof(regex_term_t));
|
|
terms[0].quantifier = REGEX_QUANTIFIER_NONE;
|
|
terms[0].type = REGEX_TERM_EMPTY;
|
|
regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t));
|
|
alternatives[0].count = alternatives[0].capacity = 1;
|
|
alternatives[0].contents = terms;
|
|
const regex_t regex
|
|
= { .count = 1, .capacity = 1, .contents = alternatives };
|
|
|
|
fsa_t fsa;
|
|
construct(®ex, &fsa);
|
|
|
|
ASSERT_EQ(1, fsa.count);
|
|
ASSERT_TRUE(fsa.states[fsa.initial].final);
|
|
ASSERT_EQ(0, fsa.states[fsa.initial].count);
|
|
|
|
regex_free(®ex);
|
|
fsa_free(&fsa);
|
|
}
|
|
|
|
static void test_literal_expression(void)
|
|
{
|
|
regex_term_t *terms = malloc(1 * sizeof(regex_term_t));
|
|
terms[0].quantifier = REGEX_QUANTIFIER_NONE;
|
|
terms[0].type = REGEX_TERM_LITERAL;
|
|
terms[0].literal = 'a';
|
|
regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t));
|
|
alternatives[0].count = alternatives[0].capacity = 1;
|
|
alternatives[0].contents = terms;
|
|
const regex_t regex
|
|
= { .count = 1, .capacity = 1, .contents = alternatives };
|
|
|
|
fsa_t fsa;
|
|
construct(®ex, &fsa);
|
|
|
|
const fsa_state_t *initial = &fsa.states[fsa.initial];
|
|
ASSERT_EQ(2, fsa.count);
|
|
ASSERT_EQ(1, initial->count);
|
|
ASSERT_EQ('a', initial->rules[0].input);
|
|
|
|
const int next = initial->rules[0].next;
|
|
ASSERT_TRUE(fsa.states[next].final);
|
|
ASSERT_EQ(0, fsa.states[next].count);
|
|
|
|
regex_free(®ex);
|
|
fsa_free(&fsa);
|
|
}
|
|
|
|
static void test_sequence(void)
|
|
{
|
|
regex_term_t *terms = malloc(3 * sizeof(regex_term_t));
|
|
terms[0].type = REGEX_TERM_LITERAL;
|
|
terms[0].literal = 'a';
|
|
terms[1].type = REGEX_TERM_LITERAL;
|
|
terms[1].literal = 'b';
|
|
terms[2].type = REGEX_TERM_LITERAL;
|
|
terms[2].literal = 'c';
|
|
regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t));
|
|
alternatives[0].count = alternatives[0].capacity = 3;
|
|
alternatives[0].contents = terms;
|
|
regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives };
|
|
|
|
fsa_t fsa;
|
|
construct(®ex, &fsa);
|
|
|
|
int next = fsa.initial;
|
|
const fsa_state_t *state;
|
|
|
|
state = &fsa.states[next];
|
|
ASSERT_FALSE(state->final);
|
|
ASSERT_EQ(1, state->count);
|
|
ASSERT_EQ('a', state->rules[0].input);
|
|
next = state->rules[0].next;
|
|
|
|
state = &fsa.states[next];
|
|
ASSERT_FALSE(state->final);
|
|
ASSERT_EQ(1, state->count);
|
|
ASSERT_EQ('b', state->rules[0].input);
|
|
next = state->rules[0].next;
|
|
|
|
state = &fsa.states[next];
|
|
ASSERT_FALSE(state->final);
|
|
ASSERT_EQ(1, state->count);
|
|
ASSERT_EQ('c', state->rules[0].input);
|
|
next = state->rules[0].next;
|
|
|
|
state = &fsa.states[next];
|
|
ASSERT_TRUE(state->final);
|
|
ASSERT_EQ(0, state->count);
|
|
|
|
regex_free(®ex);
|
|
fsa_free(&fsa);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
TESTING_BEGIN();
|
|
test_empty_expression();
|
|
test_literal_expression();
|
|
test_sequence();
|
|
return TESTING_END();
|
|
}
|