lorex/tests/test_lexer.c

/* retoor <retoor@molodetz.nl> */
#include "../include/lexer.h"
#include <stdio.h>
#include <assert.h>
#include <string.h>

static int tests_passed = 0;
static int tests_failed = 0;

#define TEST(name) static void test_##name(void)
#define RUN_TEST(name) do { \
    printf("  %s... ", #name); \
    test_##name(); \
    printf("ok\n"); \
    tests_passed++; \
} while(0)

#define ASSERT(cond) do { \
    if (!(cond)) { \
        printf("FAILED at line %d: %s\n", __LINE__, #cond); \
        tests_failed++; \
        return; \
    } \
} while(0)

TEST(simple_chars) {
    lexer_t lexer;
    lexer_init(&lexer, "abc");

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'b');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'c');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_EOF);
}

TEST(meta_chars) {
    lexer_t lexer;
    lexer_init(&lexer, ".*+?|()^$");

    ASSERT(lexer_next(&lexer).type == TOKEN_DOT);
    ASSERT(lexer_next(&lexer).type == TOKEN_STAR);
    ASSERT(lexer_next(&lexer).type == TOKEN_PLUS);
    ASSERT(lexer_next(&lexer).type == TOKEN_QUESTION);
    ASSERT(lexer_next(&lexer).type == TOKEN_PIPE);
    ASSERT(lexer_next(&lexer).type == TOKEN_LPAREN);
    ASSERT(lexer_next(&lexer).type == TOKEN_RPAREN);
    ASSERT(lexer_next(&lexer).type == TOKEN_CARET);
    ASSERT(lexer_next(&lexer).type == TOKEN_DOLLAR);
    ASSERT(lexer_next(&lexer).type == TOKEN_EOF);
}

TEST(escaped_chars) {
    lexer_t lexer;
    lexer_init(&lexer, "\\*\\+\\.");

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '*');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '+');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '.');
}

TEST(character_classes) {
    lexer_t lexer;
    lexer_init(&lexer, "\\d\\w\\s\\D\\W\\S");

    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_DIGIT);
    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_WORD);
    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_SPACE);
    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_NDIGIT);
    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_NWORD);
    ASSERT(lexer_next(&lexer).type == TOKEN_CLASS_NSPACE);
}

TEST(bracket_expression) {
    lexer_t lexer;
    lexer_init(&lexer, "[abc]");

    ASSERT(lexer_next(&lexer).type == TOKEN_LBRACKET);

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'b');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'c');

    ASSERT(lexer_next(&lexer).type == TOKEN_RBRACKET);
}

TEST(bracket_range) {
    lexer_t lexer;
    lexer_init(&lexer, "[a-z]");

    ASSERT(lexer_next(&lexer).type == TOKEN_LBRACKET);

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    ASSERT(lexer_next(&lexer).type == TOKEN_DASH);

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'z');

    ASSERT(lexer_next(&lexer).type == TOKEN_RBRACKET);
}

TEST(negated_bracket) {
    lexer_t lexer;
    lexer_init(&lexer, "[^a]");

    ASSERT(lexer_next(&lexer).type == TOKEN_LBRACKET);
    ASSERT(lexer_next(&lexer).type == TOKEN_CARET);

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    ASSERT(lexer_next(&lexer).type == TOKEN_RBRACKET);
}

TEST(quantifier_braces) {
    lexer_t lexer;
    lexer_init(&lexer, "a{3}");

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    ASSERT(lexer_next(&lexer).type == TOKEN_LBRACE);

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '3');

    ASSERT(lexer_next(&lexer).type == TOKEN_RBRACE);
}

TEST(peek) {
    lexer_t lexer;
    lexer_init(&lexer, "ab");

    token_t t = lexer_peek(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    t = lexer_peek(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'a');

    t = lexer_peek(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == 'b');
}

TEST(escape_sequences) {
    lexer_t lexer;
    lexer_init(&lexer, "\\n\\t\\r");

    token_t t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '\n');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '\t');

    t = lexer_next(&lexer);
    ASSERT(t.type == TOKEN_CHAR && t.value == '\r');
}

int main(void) {
    printf("lexer tests:\n");

    RUN_TEST(simple_chars);
    RUN_TEST(meta_chars);
    RUN_TEST(escaped_chars);
    RUN_TEST(character_classes);
    RUN_TEST(bracket_expression);
    RUN_TEST(bracket_range);
    RUN_TEST(negated_bracket);
    RUN_TEST(quantifier_braces);
    RUN_TEST(peek);
    RUN_TEST(escape_sequences);

    printf("\nlexer: %d passed, %d failed\n", tests_passed, tests_failed);
    return tests_failed > 0 ? 1 : 0;
}