regex-engine/tests/desugar_tests.c

/*
 * Copyright (c) Camden Dixie O'Brien
 * SPDX-License-Identifier: AGPL-3.0-only
 */

#include "desugar.h"
#include "testing.h"

#include <stddef.h>

static void a_is_unchanged(void)
{
	parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
	terms[0].quantifier = PARSE_QUANTIFIER_NONE;
	terms[0].type = PARSE_TERM_LITERAL;
	terms[0].literal = 'a';
	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = terms;
	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };

	desugar_regex(&t);
	ASSERT_EQ(1, t.count);
	ASSERT_NOT_NULL(t.contents);
	ASSERT_EQ(1, t.contents[0].count);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
	ASSERT_EQ('a', t.contents[0].contents[0].literal);

	parse_free_tree_children(&t);
}

static void abc_is_unchanged(void)
{
	parse_term_t *terms = malloc(3 * sizeof(parse_term_t));
	terms[0].type = PARSE_TERM_LITERAL;
	terms[0].literal = 'a';
	terms[1].type = PARSE_TERM_LITERAL;
	terms[1].literal = 'b';
	terms[2].type = PARSE_TERM_LITERAL;
	terms[2].literal = 'c';
	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 3;
	alternatives[0].contents = terms;
	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };

	desugar_regex(&t);
	ASSERT_EQ(1, t.count);
	ASSERT_NOT_NULL(t.contents);
	ASSERT_EQ(3, t.contents[0].count);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
	ASSERT_EQ('a', t.contents[0].contents[0].literal);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type);
	ASSERT_EQ('b', t.contents[0].contents[1].literal);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[2].type);
	ASSERT_EQ('c', t.contents[0].contents[2].literal);

	parse_free_tree_children(&t);
}

static void a_star_is_unchanged(void)
{
	parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
	terms[0].quantifier = PARSE_QUANTIFIER_STAR;
	terms[0].type = PARSE_TERM_LITERAL;
	terms[0].literal = 'a';
	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = terms;
	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };

	desugar_regex(&t);
	ASSERT_EQ(1, t.count);
	ASSERT_NOT_NULL(t.contents);
	ASSERT_EQ(1, t.contents[0].count);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_QUANTIFIER_STAR, t.contents[0].contents[0].quantifier);
	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
	ASSERT_EQ('a', t.contents[0].contents[0].literal);

	parse_free_tree_children(&t);
}

static void a_or_b_or_c_is_unchanged(void)
{
	const char *literals = "abc";
	parse_sequence_t *alternatives = malloc(3 * sizeof(parse_sequence_t));
	for (int i = 0; i < 3; ++i) {
		parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
		terms[0].quantifier = PARSE_QUANTIFIER_NONE;
		terms[0].type = PARSE_TERM_LITERAL;
		terms[0].literal = literals[i];

		alternatives[i].count = alternatives[i].capacity = 1;
		alternatives[i].contents = terms;
	}
	parse_tree_t t = { .count = 3, .capacity = 3, .contents = alternatives };

	desugar_regex(&t);
	ASSERT_EQ(3, t.count);
	ASSERT_NOT_NULL(t.contents);
	for (int i = 0; i < 3; ++i) {
		ASSERT_EQ(1, t.contents[i].count);
		ASSERT_NOT_NULL(t.contents[i].contents);
		ASSERT_EQ(
		    PARSE_QUANTIFIER_NONE, t.contents[i].contents[0].quantifier);
		ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[i].contents[0].type);
		ASSERT_EQ(literals[i], t.contents[i].contents[0].literal);
	}

	parse_free_tree_children(&t);
}

static void subexpr_a_is_unchanged(void)
{
	parse_term_t *inner_terms = malloc(1 * sizeof(parse_term_t));
	inner_terms[0].quantifier = PARSE_QUANTIFIER_NONE;
	inner_terms[0].type = PARSE_TERM_LITERAL;
	inner_terms[0].literal = 'a';
	parse_sequence_t *inner_alternatives
	    = malloc(1 * sizeof(parse_sequence_t));
	inner_alternatives[0].count = inner_alternatives[0].capacity = 1;
	inner_alternatives[0].contents = inner_terms;
	parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
	terms[0].quantifier = PARSE_QUANTIFIER_NONE;
	terms[0].type = PARSE_TERM_SUBEXPR;
	terms[0].subexpr.count = terms[0].subexpr.capacity = 1;
	terms[0].subexpr.contents = inner_alternatives;
	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = terms;
	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };

	desugar_regex(&t);

	parse_free_tree_children(&t);
}

static void a_plus_becomes_subexpr_aa_star(void)
{
	parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
	terms[0].quantifier = PARSE_QUANTIFIER_PLUS;
	terms[0].type = PARSE_TERM_LITERAL;
	terms[0].literal = 'a';
	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
	alternatives[0].count = alternatives[0].capacity = 1;
	alternatives[0].contents = terms;
	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };

	desugar_regex(&t);
	ASSERT_EQ(1, t.count);
	ASSERT_NOT_NULL(t.contents);
	ASSERT_EQ(1, t.contents[0].count);
	ASSERT_NOT_NULL(t.contents[0].contents);
	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
	ASSERT_EQ(PARSE_TERM_SUBEXPR, t.contents[0].contents[0].type);

	const parse_tree_t *inner = &t.contents[0].contents[0].subexpr;
	ASSERT_EQ(1, inner->count);
	ASSERT_NOT_NULL(inner->contents);
	ASSERT_EQ(2, inner->contents[0].count);
	ASSERT_NOT_NULL(inner->contents[0].contents);
	ASSERT_EQ(
	    PARSE_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier);
	ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[0].type);
	ASSERT_EQ('a', inner->contents[0].contents[0].literal);
	ASSERT_EQ(
	    PARSE_QUANTIFIER_STAR, inner->contents[0].contents[1].quantifier);
	ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[1].type);
	ASSERT_EQ('a', inner->contents[0].contents[1].literal);

	parse_free_tree_children(&t);
}

int main(void)
{
	TESTING_BEGIN();
	a_is_unchanged();
	abc_is_unchanged();
	a_star_is_unchanged();
	a_or_b_or_c_is_unchanged();
	subexpr_a_is_unchanged();
	a_plus_becomes_subexpr_aa_star();
	return TESTING_END();
}