lorex/tests/test_integration.c

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

static int passed = 0;
static int failed = 0;

#define MATCH(pat, txt) test_match(pat, txt, 1, __LINE__)
#define NO_MATCH(pat, txt) test_match(pat, txt, 0, __LINE__)

static void test_match(const char *pattern, const char *text, int expect, int line) {
    lorex_error_t err;
    lorex_regex_t *re = lorex_compile(pattern, &err);
    if (!re) {
        printf("FAIL line %d: compile error for '%s': %s\n", line, pattern, lorex_error_string(err));
        failed++;
        return;
    }
    lorex_match_t m;
    int result = lorex_search(re, text, &m) ? 1 : 0;
    if (result != expect) {
        printf("FAIL line %d: '%s' vs '%s' expected %s\n", line, pattern, text, expect ? "match" : "no match");
        failed++;
    } else {
        passed++;
    }
    lorex_free(re);
}

static void test_literals(void) {
    printf("  literals...\n");
    MATCH("a", "a");
    MATCH("a", "ba");
    MATCH("a", "ab");
    MATCH("abc", "abc");
    MATCH("abc", "xabcy");
    MATCH("hello", "hello world");
    MATCH("world", "hello world");
    MATCH("lo wo", "hello world");
    NO_MATCH("abc", "ab");
    NO_MATCH("abc", "abd");
    NO_MATCH("xyz", "abc");
    NO_MATCH("hello", "helo");
    MATCH("", "anything");
    MATCH("", "");
    MATCH("a", "aaa");
    MATCH("aa", "aaa");
    MATCH("aaa", "aaa");
    NO_MATCH("aaaa", "aaa");
}

static void test_dot(void) {
    printf("  dot metacharacter...\n");
    MATCH(".", "a");
    MATCH(".", "x");
    MATCH(".", "5");
    MATCH(".", " ");
    MATCH("..", "ab");
    MATCH("...", "abc");
    MATCH("a.c", "abc");
    MATCH("a.c", "aXc");
    MATCH("a.c", "a9c");
    MATCH("a.c", "a c");
    NO_MATCH("a.c", "ac");
    NO_MATCH("a.c", "abbc");
    MATCH("....", "test");
    MATCH(".", "!");
    MATCH(".", "@");
    MATCH("a..b", "aXYb");
    MATCH("a...b", "a123b");
    NO_MATCH("a..b", "aXb");
}

static void test_anchors(void) {
    printf("  anchors...\n");
    MATCH("^a", "a");
    MATCH("^a", "abc");
    NO_MATCH("^a", "ba");
    NO_MATCH("^a", " a");
    MATCH("a$", "a");
    MATCH("a$", "ba");
    NO_MATCH("a$", "ab");
    NO_MATCH("a$", "a ");
    MATCH("^abc$", "abc");
    NO_MATCH("^abc$", "xabc");
    NO_MATCH("^abc$", "abcx");
    NO_MATCH("^abc$", " abc");
    NO_MATCH("^abc$", "abc ");
    MATCH("^$", "");
    NO_MATCH("^$", "a");
    MATCH("^hello$", "hello");
    MATCH("^hello world$", "hello world");
    NO_MATCH("^hello world$", "hello world!");
    MATCH("^a.*z$", "abcdefghijklmnopqrstuvwxyz");
    MATCH("^.", "x");
    MATCH(".$", "x");
}

static void test_star(void) {
    printf("  star quantifier...\n");
    MATCH("a*", "");
    MATCH("a*", "a");
    MATCH("a*", "aa");
    MATCH("a*", "aaa");
    MATCH("a*", "aaaaaaaaaa");
    MATCH("a*", "b");
    MATCH("a*b", "b");
    MATCH("a*b", "ab");
    MATCH("a*b", "aab");
    MATCH("a*b", "aaaaaab");
    NO_MATCH("a*b", "a");
    MATCH("ba*", "b");
    MATCH("ba*", "ba");
    MATCH("ba*", "baaa");
    MATCH(".*", "");
    MATCH(".*", "anything at all");
    MATCH("a.*b", "ab");
    MATCH("a.*b", "aXb");
    MATCH("a.*b", "aXXXXXb");
    MATCH("a.*b", "a b");
    MATCH("x*y*z*", "");
    MATCH("x*y*z*", "xyz");
    MATCH("x*y*z*", "xxxyyyzzz");
    MATCH("ab*c", "ac");
    MATCH("ab*c", "abc");
    MATCH("ab*c", "abbbbc");
}

static void test_plus(void) {
    printf("  plus quantifier...\n");
    NO_MATCH("a+", "");
    MATCH("a+", "a");
    MATCH("a+", "aa");
    MATCH("a+", "aaa");
    MATCH("a+", "aaaaaaaaaa");
    MATCH("a+", "ba");
    MATCH("a+b", "ab");
    MATCH("a+b", "aab");
    MATCH("a+b", "aaaaaab");
    NO_MATCH("a+b", "b");
    NO_MATCH("a+b", "a");
    MATCH("ba+", "ba");
    MATCH("ba+", "baaa");
    NO_MATCH("ba+", "b");
    MATCH(".+", "a");
    MATCH(".+", "anything");
    NO_MATCH(".+", "");
    MATCH("a.+b", "aXb");
    MATCH("a.+b", "aXXXXXb");
    NO_MATCH("a.+b", "ab");
    MATCH("ab+c", "abc");
    MATCH("ab+c", "abbbbc");
    NO_MATCH("ab+c", "ac");
}

static void test_question(void) {
    printf("  question quantifier...\n");
    MATCH("a?", "");
    MATCH("a?", "a");
    MATCH("a?", "aa");
    MATCH("a?b", "b");
    MATCH("a?b", "ab");
    MATCH("a?b", "aab");
    MATCH("colou?r", "color");
    MATCH("colou?r", "colour");
    NO_MATCH("colou?r", "colouur");
    MATCH("ab?c", "ac");
    MATCH("ab?c", "abc");
    NO_MATCH("ab?c", "abbc");
    MATCH("https?://", "http://");
    MATCH("https?://", "https://");
    MATCH(".?", "");
    MATCH(".?", "x");
}

static void test_alternation(void) {
    printf("  alternation...\n");
    MATCH("a|b", "a");
    MATCH("a|b", "b");
    NO_MATCH("a|b", "c");
    MATCH("cat|dog", "cat");
    MATCH("cat|dog", "dog");
    NO_MATCH("cat|dog", "rat");
    MATCH("cat|dog", "my cat");
    MATCH("cat|dog", "my dog");
    MATCH("a|b|c", "a");
    MATCH("a|b|c", "b");
    MATCH("a|b|c", "c");
    NO_MATCH("a|b|c", "d");
    MATCH("ab|cd", "ab");
    MATCH("ab|cd", "cd");
    NO_MATCH("ab|cd", "ac");
    MATCH("abc|def|ghi", "abc");
    MATCH("abc|def|ghi", "def");
    MATCH("abc|def|ghi", "ghi");
    MATCH("a|ab|abc", "abc");
    MATCH("abc|ab|a", "abc");
    MATCH("red|green|blue", "the red car");
    MATCH("red|green|blue", "green light");
    MATCH("red|green|blue", "blue sky");
}

static void test_groups(void) {
    printf("  groups...\n");
    MATCH("(a)", "a");
    MATCH("(ab)", "ab");
    MATCH("(abc)", "abc");
    MATCH("(a)(b)", "ab");
    MATCH("(a)(b)(c)", "abc");
    MATCH("(ab)+", "ab");
    MATCH("(ab)+", "abab");
    MATCH("(ab)+", "ababab");
    NO_MATCH("(ab)+", "a");
    NO_MATCH("(ab)+", "ba");
    MATCH("(ab)*", "");
    MATCH("(ab)*", "ab");
    MATCH("(ab)*", "abab");
    MATCH("(ab)?", "");
    MATCH("(ab)?", "ab");
    MATCH("(a|b)+", "a");
    MATCH("(a|b)+", "b");
    MATCH("(a|b)+", "ab");
    MATCH("(a|b)+", "ba");
    MATCH("(a|b)+", "aabb");
    MATCH("(a|b)+", "abba");
    MATCH("((a))", "a");
    MATCH("((ab))", "ab");
    MATCH("(a(b)c)", "abc");
    MATCH("(a(b(c)))", "abc");
    MATCH("((a)(b))", "ab");
    MATCH("(red|blue) car", "red car");
    MATCH("(red|blue) car", "blue car");
    NO_MATCH("(red|blue) car", "green car");
}

static void test_bracket_simple(void) {
    printf("  bracket expressions (simple)...\n");
    MATCH("[a]", "a");
    NO_MATCH("[a]", "b");
    MATCH("[ab]", "a");
    MATCH("[ab]", "b");
    NO_MATCH("[ab]", "c");
    MATCH("[abc]", "a");
    MATCH("[abc]", "b");
    MATCH("[abc]", "c");
    NO_MATCH("[abc]", "d");
    MATCH("[aeiou]", "a");
    MATCH("[aeiou]", "e");
    MATCH("[aeiou]", "i");
    MATCH("[aeiou]", "o");
    MATCH("[aeiou]", "u");
    NO_MATCH("[aeiou]", "b");
    MATCH("[abc]+", "aaa");
    MATCH("[abc]+", "abc");
    MATCH("[abc]+", "cba");
    MATCH("[abc]+", "abcabc");
    MATCH("[xyz]*", "");
    MATCH("[xyz]*", "xyz");
}

static void test_bracket_ranges(void) {
    printf("  bracket expressions (ranges)...\n");
    MATCH("[a-z]", "a");
    MATCH("[a-z]", "m");
    MATCH("[a-z]", "z");
    NO_MATCH("[a-z]", "A");
    NO_MATCH("[a-z]", "0");
    MATCH("[A-Z]", "A");
    MATCH("[A-Z]", "M");
    MATCH("[A-Z]", "Z");
    NO_MATCH("[A-Z]", "a");
    MATCH("[0-9]", "0");
    MATCH("[0-9]", "5");
    MATCH("[0-9]", "9");
    NO_MATCH("[0-9]", "a");
    MATCH("[a-zA-Z]", "a");
    MATCH("[a-zA-Z]", "Z");
    NO_MATCH("[a-zA-Z]", "5");
    MATCH("[a-zA-Z0-9]", "a");
    MATCH("[a-zA-Z0-9]", "Z");
    MATCH("[a-zA-Z0-9]", "5");
    NO_MATCH("[a-zA-Z0-9]", "!");
    MATCH("[a-z]+", "hello");
    MATCH("[A-Z]+", "HELLO");
    MATCH("[0-9]+", "12345");
    MATCH("[a-z0-9]+", "abc123");
}

static void test_bracket_negated(void) {
    printf("  bracket expressions (negated)...\n");
    NO_MATCH("[^a]", "a");
    MATCH("[^a]", "b");
    MATCH("[^a]", "x");
    NO_MATCH("[^abc]", "a");
    NO_MATCH("[^abc]", "b");
    NO_MATCH("[^abc]", "c");
    MATCH("[^abc]", "d");
    MATCH("[^abc]", "x");
    NO_MATCH("[^a-z]", "a");
    NO_MATCH("[^a-z]", "m");
    NO_MATCH("[^a-z]", "z");
    MATCH("[^a-z]", "A");
    MATCH("[^a-z]", "5");
    MATCH("[^a-z]", "!");
    NO_MATCH("[^0-9]", "5");
    MATCH("[^0-9]", "a");
    MATCH("[^0-9]+", "hello");
    NO_MATCH("[^aeiou]+", "aaa");
    MATCH("[^aeiou]+", "xyz");
}

static void test_character_classes(void) {
    printf("  character classes...\n");
    MATCH("\\d", "0");
    MATCH("\\d", "5");
    MATCH("\\d", "9");
    NO_MATCH("\\d", "a");
    NO_MATCH("\\d", " ");
    MATCH("\\d+", "123");
    MATCH("\\d+", "0");
    MATCH("\\d+", "9876543210");
    NO_MATCH("\\d+", "");
    NO_MATCH("\\d+", "abc");
    MATCH("\\D", "a");
    MATCH("\\D", " ");
    MATCH("\\D", "!");
    NO_MATCH("\\D", "5");
    MATCH("\\w", "a");
    MATCH("\\w", "Z");
    MATCH("\\w", "0");
    MATCH("\\w", "_");
    NO_MATCH("\\w", " ");
    NO_MATCH("\\w", "!");
    MATCH("\\w+", "hello");
    MATCH("\\w+", "Hello123");
    MATCH("\\w+", "var_name");
    MATCH("\\W", " ");
    MATCH("\\W", "!");
    MATCH("\\W", "@");
    NO_MATCH("\\W", "a");
    NO_MATCH("\\W", "_");
    MATCH("\\s", " ");
    MATCH("\\s", "\t");
    MATCH("\\s", "\n");
    NO_MATCH("\\s", "a");
    NO_MATCH("\\s", "5");
    MATCH("\\s+", "   ");
    MATCH("\\s+", " \t\n");
    MATCH("\\S", "a");
    MATCH("\\S", "5");
    MATCH("\\S", "!");
    NO_MATCH("\\S", " ");
    NO_MATCH("\\S", "\t");
}

static void test_quantifier_braces(void) {
    printf("  brace quantifiers...\n");
    MATCH("a{3}", "aaa");
    MATCH("a{3}", "aaaa");
    NO_MATCH("a{3}", "aa");
    MATCH("a{1}", "a");
    MATCH("a{1}", "aa");
    NO_MATCH("a{1}", "");
    MATCH("a{0}", "");
    MATCH("a{0}", "b");
    MATCH("a{2,4}", "aa");
    MATCH("a{2,4}", "aaa");
    MATCH("a{2,4}", "aaaa");
    MATCH("a{2,4}", "aaaaa");
    NO_MATCH("a{2,4}", "a");
    MATCH("a{2,}", "aa");
    MATCH("a{2,}", "aaa");
    MATCH("a{2,}", "aaaaaaaaaa");
    NO_MATCH("a{2,}", "a");
    MATCH("a{0,2}", "");
    MATCH("a{0,2}", "a");
    MATCH("a{0,2}", "aa");
    MATCH("a{0,2}", "aaa");
    MATCH("[0-9]{3}", "123");
    MATCH("[0-9]{3}", "000");
    NO_MATCH("[0-9]{3}", "12");
    MATCH("(ab){2}", "abab");
    MATCH("(ab){2}", "ababab");
    NO_MATCH("(ab){2}", "ab");
}

static void test_escape_sequences(void) {
    printf("  escape sequences...\n");
    MATCH("\\.", ".");
    NO_MATCH("\\.", "a");
    MATCH("\\*", "*");
    NO_MATCH("\\*", "a");
    MATCH("\\+", "+");
    MATCH("\\?", "?");
    MATCH("\\|", "|");
    MATCH("\\(", "(");
    MATCH("\\)", ")");
    MATCH("\\[", "[");
    MATCH("\\]", "]");
    MATCH("\\{", "{");
    MATCH("\\}", "}");
    MATCH("\\^", "^");
    MATCH("\\$", "$");
    MATCH("\\\\", "\\");
    MATCH("a\\.b", "a.b");
    NO_MATCH("a\\.b", "aXb");
    MATCH("\\d\\.\\d", "1.5");
    MATCH("c\\+\\+", "c++");
    MATCH("\\(test\\)", "(test)");
    MATCH("\\[0\\]", "[0]");
}

static void test_complex_patterns(void) {
    printf("  complex patterns...\n");
    MATCH("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}", "user@example.com");
    MATCH("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}", "test.user@mail.example.org");
    NO_MATCH("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}", "invalid");
    NO_MATCH("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}", "@example.com");
    MATCH("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}", "192.168.1.1");
    MATCH("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}", "10.0.0.1");
    MATCH("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}", "255.255.255.255");
    NO_MATCH("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}", "1.2.3");
    MATCH("https?://[a-zA-Z0-9.-]+(/[a-zA-Z0-9./-]*)?", "http://example.com");
    MATCH("https?://[a-zA-Z0-9.-]+(/[a-zA-Z0-9./-]*)?", "https://example.com");
    MATCH("https?://[a-zA-Z0-9.-]+(/[a-zA-Z0-9./-]*)?", "http://example.com/path");
    MATCH("https?://[a-zA-Z0-9.-]+(/[a-zA-Z0-9./-]*)?", "https://example.com/path/to/page");
    MATCH("\\d{3}-\\d{3}-\\d{4}", "123-456-7890");
    MATCH("\\d{3}-\\d{3}-\\d{4}", "555-123-4567");
    NO_MATCH("\\d{3}-\\d{3}-\\d{4}", "12-345-6789");
    NO_MATCH("\\d{3}-\\d{3}-\\d{4}", "1234567890");
    MATCH("\\(\\d{3}\\) \\d{3}-\\d{4}", "(123) 456-7890");
    MATCH("[A-Z]{2}\\d{6}", "AB123456");
    NO_MATCH("[A-Z]{2}\\d{6}", "A1234567");
    MATCH("\\d{4}-\\d{2}-\\d{2}", "2024-01-15");
    MATCH("\\d{2}/\\d{2}/\\d{4}", "01/15/2024");
    MATCH("\\d{1,2}:\\d{2}(:\\d{2})?", "12:30");
    MATCH("\\d{1,2}:\\d{2}(:\\d{2})?", "12:30:45");
    MATCH("\\d{1,2}:\\d{2}(:\\d{2})?", "9:05");
}

static void test_word_boundaries(void) {
    printf("  word patterns...\n");
    MATCH("\\w+", "hello");
    MATCH("\\w+", "hello123");
    MATCH("\\w+", "test_var");
    MATCH("[a-zA-Z_][a-zA-Z0-9_]*", "variable");
    MATCH("[a-zA-Z_][a-zA-Z0-9_]*", "_private");
    MATCH("[a-zA-Z_][a-zA-Z0-9_]*", "var123");
    NO_MATCH("^[a-zA-Z_][a-zA-Z0-9_]*$", "123var");
    MATCH("\\w+\\s+\\w+", "hello world");
    MATCH("\\w+\\s+\\w+", "foo bar");
    NO_MATCH("\\w+\\s+\\w+", "hello");
}

static void test_greedy_vs_nongreedy(void) {
    printf("  greedy vs non-greedy...\n");
    MATCH("a+", "aaa");
    MATCH("a+?", "aaa");
    MATCH("a*", "aaa");
    MATCH("a*?", "aaa");
    MATCH("a?", "a");
    MATCH("a??", "a");
    MATCH("a{2,4}", "aaaa");
    MATCH("a{2,4}?", "aaaa");
    MATCH(".*x", "abcx");
    MATCH(".*?x", "abcx");
}

static void test_empty_and_edge_cases(void) {
    printf("  empty and edge cases...\n");
    MATCH("", "");
    MATCH("", "abc");
    MATCH("a*", "");
    MATCH("a?", "");
    MATCH("(a*)*", "");
    MATCH("(a*)+", "");
    MATCH("(a+)*", "");
    MATCH("(a|b)*", "");
    MATCH("[a-z]*", "");
    NO_MATCH("a+", "");
    NO_MATCH(".+", "");
    NO_MATCH("[a-z]+", "");
    MATCH("^", "");
    MATCH("$", "");
    MATCH("^$", "");
    NO_MATCH("^$", "a");
    MATCH("a*b*c*", "");
    MATCH("a*b*c*", "abc");
    MATCH("a*b*c*", "aabbcc");
    MATCH("a*b*c*", "c");
    MATCH("a*b*c*", "b");
}

static void test_special_characters_in_text(void) {
    printf("  special characters in text...\n");
    MATCH("a", "a\nb");
    MATCH("b", "a\nb");
    MATCH("a.b", "a\tb");
    NO_MATCH("a.b", "a\nb");
    MATCH("\\.", "3.14");
    MATCH("\\+", "1+2");
    MATCH("\\*", "2*3");
    MATCH("\\?", "why?");
    MATCH("\\(\\)", "func()");
    MATCH("\\[\\]", "array[]");
    MATCH("\\{\\}", "object{}");
    MATCH("\\^", "x^2");
    MATCH("\\$", "$100");
    MATCH("\\|", "a|b");
}

static void test_repetition_combinations(void) {
    printf("  repetition combinations...\n");
    MATCH("a+b+", "ab");
    MATCH("a+b+", "aabb");
    MATCH("a+b+", "aaabbb");
    NO_MATCH("a+b+", "a");
    NO_MATCH("a+b+", "b");
    MATCH("a*b+", "b");
    MATCH("a*b+", "ab");
    MATCH("a*b+", "aab");
    MATCH("a+b*", "a");
    MATCH("a+b*", "ab");
    MATCH("a+b*", "abb");
    MATCH("a*b*", "");
    MATCH("a*b*", "a");
    MATCH("a*b*", "b");
    MATCH("a*b*", "ab");
    MATCH("(ab)+c+", "abc");
    MATCH("(ab)+c+", "ababcc");
    MATCH("(a+b)+", "ab");
    MATCH("(a+b)+", "aabaaab");
    MATCH("((a+)+)+", "a");
    MATCH("((a+)+)+", "aaa");
}

static void test_alternation_combinations(void) {
    printf("  alternation combinations...\n");
    MATCH("a|b|c|d|e", "a");
    MATCH("a|b|c|d|e", "e");
    NO_MATCH("a|b|c|d|e", "f");
    MATCH("(a|b)(c|d)", "ac");
    MATCH("(a|b)(c|d)", "ad");
    MATCH("(a|b)(c|d)", "bc");
    MATCH("(a|b)(c|d)", "bd");
    NO_MATCH("(a|b)(c|d)", "ab");
    MATCH("(cat|dog)s?", "cat");
    MATCH("(cat|dog)s?", "cats");
    MATCH("(cat|dog)s?", "dog");
    MATCH("(cat|dog)s?", "dogs");
    MATCH("(red|green|blue)\\s+(car|truck)", "red car");
    MATCH("(red|green|blue)\\s+(car|truck)", "green truck");
    MATCH("(a|aa|aaa)", "aaa");
    MATCH("(aaa|aa|a)", "aaa");
}

static void test_nested_groups(void) {
    printf("  nested groups...\n");
    MATCH("((a))", "a");
    MATCH("(((a)))", "a");
    MATCH("((a)(b))", "ab");
    MATCH("((a(b))c)", "abc");
    MATCH("(a(b(c)))", "abc");
    MATCH("((a|b)(c|d))", "ac");
    MATCH("(a(b|c)d)", "abd");
    MATCH("(a(b|c)d)", "acd");
    MATCH("((ab)+)", "abab");
    MATCH("(a(bc)*d)", "ad");
    MATCH("(a(bc)*d)", "abcd");
    MATCH("(a(bc)*d)", "abcbcd");
    MATCH("((a+)(b+))", "aabb");
    MATCH("(((a|b)+)c)", "ababc");
}

static void test_real_world_patterns(void) {
    printf("  real world patterns...\n");
    MATCH("[a-zA-Z]+", "Hello");
    MATCH("[a-zA-Z]+", "WORLD");
    MATCH("[a-zA-Z]+", "test");
    MATCH("-?\\d+", "123");
    MATCH("-?\\d+", "-456");
    MATCH("-?\\d+", "0");
    MATCH("-?\\d+\\.?\\d*", "3.14");
    MATCH("-?\\d+\\.?\\d*", "-2.5");
    MATCH("-?\\d+\\.?\\d*", "42");
    MATCH("[a-fA-F0-9]+", "deadbeef");
    MATCH("[a-fA-F0-9]+", "CAFEBABE");
    MATCH("[a-fA-F0-9]+", "123abc");
    MATCH("[01]+", "101010");
    MATCH("[01]+", "11110000");
    MATCH("[A-Z][a-z]+", "Hello");
    MATCH("[A-Z][a-z]+", "World");
    NO_MATCH("[A-Z][a-z]+", "hello");
    MATCH("\"[^\"]*\"", "\"hello\"");
    MATCH("\"[^\"]*\"", "\"hello world\"");
    MATCH("\"[^\"]*\"", "\"\"");
    MATCH("'[^']*'", "'test'");
    MATCH("#[a-fA-F0-9]{6}", "#ff0000");
    MATCH("#[a-fA-F0-9]{6}", "#00FF00");
    MATCH("#[a-fA-F0-9]{3}", "#f00");
}

static void test_pathological_patterns(void) {
    printf("  stress test patterns...\n");
    MATCH("a?a?a?aaa", "aaa");
    MATCH("(a+)+", "aaaa");
    MATCH("(a*)*", "aaaa");
    MATCH("(a|a)+", "aaaa");
    MATCH("((a*)*)*", "aaaa");
    MATCH("a*a*a*a*a*b", "aaaaab");
    MATCH(".*.*.*.*.*", "test");
    MATCH("(a?){5}a{5}", "aaaaa");
}

static void test_anchored_match(void) {
    printf("  anchored match (lorex_match)...\n");
    lorex_error_t err;
    lorex_match_t m;

    lorex_regex_t *re = lorex_compile("abc", &err);
    if (re) {
        if (lorex_match(re, "abc", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should match 'abc' against 'abc'\n");
            failed++;
        }
        if (!lorex_match(re, "xabc", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should not match 'abc' against 'xabc'\n");
            failed++;
        }
        if (lorex_match(re, "abcx", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should match 'abc' at start of 'abcx'\n");
            failed++;
        }
        lorex_free(re);
    }

    re = lorex_compile("^abc$", &err);
    if (re) {
        if (lorex_match(re, "abc", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should match '^abc$' against 'abc'\n");
            failed++;
        }
        if (!lorex_match(re, "abcx", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should not match '^abc$' against 'abcx'\n");
            failed++;
        }
        lorex_free(re);
    }

    re = lorex_compile("a.*z", &err);
    if (re) {
        if (lorex_match(re, "abcz", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should match 'a.*z' against 'abcz'\n");
            failed++;
        }
        if (!lorex_match(re, "xabcz", &m)) {
            passed++;
        } else {
            printf("FAIL: lorex_match should not match 'a.*z' against 'xabcz'\n");
            failed++;
        }
        lorex_free(re);
    }
}

static void test_error_strings(void) {
    printf("  error strings...\n");

    if (strcmp(lorex_error_string(LOREX_OK), "success") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_OK should return 'success'\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_INVALID_PATTERN), "invalid pattern") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_INVALID_PATTERN error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_UNBALANCED_PAREN), "unbalanced parentheses") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_UNBALANCED_PAREN error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_EMPTY_GROUP), "empty group") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_EMPTY_GROUP error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_INVALID_QUANTIFIER), "invalid quantifier") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_INVALID_QUANTIFIER error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_INVALID_ESCAPE), "invalid escape sequence") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_INVALID_ESCAPE error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_OUT_OF_MEMORY), "out of memory") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_OUT_OF_MEMORY error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string(LOREX_ERR_STATE_OVERFLOW), "state overflow") == 0) {
        passed++;
    } else {
        printf("FAIL: LOREX_ERR_STATE_OVERFLOW error string\n");
        failed++;
    }

    if (strcmp(lorex_error_string((lorex_error_t)99), "unknown error") == 0) {
        passed++;
    } else {
        printf("FAIL: unknown error code should return 'unknown error'\n");
        failed++;
    }
}

static void test_parser_errors(void) {
    printf("  parser errors...\n");
    lorex_error_t err;
    lorex_regex_t *re;

    re = lorex_compile("(abc", &err);
    if (re == NULL && err == LOREX_ERR_UNBALANCED_PAREN) {
        passed++;
    } else {
        printf("FAIL: '(abc' should fail with unbalanced paren\n");
        failed++;
        if (re) lorex_free(re);
    }

    re = lorex_compile("((a)", &err);
    if (re == NULL && err == LOREX_ERR_UNBALANCED_PAREN) {
        passed++;
    } else {
        printf("FAIL: '((a)' should fail with unbalanced paren\n");
        failed++;
        if (re) lorex_free(re);
    }

    re = lorex_compile("a{5,2}", &err);
    if (re == NULL) {
        passed++;
    } else {
        printf("FAIL: 'a{5,2}' should fail (min > max)\n");
        failed++;
        lorex_free(re);
    }

    re = lorex_compile("*abc", &err);
    if (re == NULL) {
        passed++;
    } else {
        printf("FAIL: '*abc' should fail\n");
        failed++;
        lorex_free(re);
    }

    re = lorex_compile("+abc", &err);
    if (re == NULL) {
        passed++;
    } else {
        printf("FAIL: '+abc' should fail\n");
        failed++;
        lorex_free(re);
    }

    re = lorex_compile("?abc", &err);
    if (re == NULL) {
        passed++;
    } else {
        printf("FAIL: '?abc' should fail\n");
        failed++;
        lorex_free(re);
    }
}

static void test_bracket_char_classes(void) {
    printf("  bracket character classes...\n");
    MATCH("[\\d]", "5");
    MATCH("[\\d]+", "12345");
    NO_MATCH("[\\d]", "a");
    MATCH("[\\w]", "a");
    MATCH("[\\w]", "Z");
    MATCH("[\\w]", "5");
    MATCH("[\\w]", "_");
    NO_MATCH("[\\w]", " ");
    MATCH("[\\s]", " ");
    MATCH("[\\s]", "\t");
    NO_MATCH("[\\s]", "a");
    MATCH("[a\\d]", "a");
    MATCH("[a\\d]", "5");
    NO_MATCH("[a\\d]", "b");
    MATCH("[\\da-z]", "5");
    MATCH("[\\da-z]", "m");
    NO_MATCH("[\\da-z]", "M");
    MATCH("[\\w\\s]+", "hello world");
    MATCH("[0-9\\s]+", "1 2 3");
    MATCH("[\\w-]+", "hello-world");
}

static void test_special_escapes(void) {
    printf("  special escape sequences...\n");
    MATCH("\\n", "\n");
    MATCH("a\\nb", "a\nb");
    MATCH("\\t", "\t");
    MATCH("a\\tb", "a\tb");
    MATCH("\\r", "\r");
    MATCH("a\\rb", "a\rb");
    MATCH("\\n\\t\\r", "\n\t\r");
    MATCH("[\\n]", "\n");
    MATCH("[\\t]", "\t");
    MATCH("[\\r]", "\r");
    MATCH("[\\n\\t]+", "\n\t\n");
    NO_MATCH("\\n", "n");
    NO_MATCH("\\t", "t");
    NO_MATCH("\\r", "r");
}

int main(void) {
    printf("lorex integration tests\n");
    printf("=======================\n\n");

    test_literals();
    test_dot();
    test_anchors();
    test_star();
    test_plus();
    test_question();
    test_alternation();
    test_groups();
    test_bracket_simple();
    test_bracket_ranges();
    test_bracket_negated();
    test_character_classes();
    test_quantifier_braces();
    test_escape_sequences();
    test_complex_patterns();
    test_word_boundaries();
    test_greedy_vs_nongreedy();
    test_empty_and_edge_cases();
    test_special_characters_in_text();
    test_repetition_combinations();
    test_alternation_combinations();
    test_nested_groups();
    test_real_world_patterns();
    test_pathological_patterns();
    test_anchored_match();
    test_error_strings();
    test_parser_errors();
    test_bracket_char_classes();
    test_special_escapes();

    printf("\n=======================\n");
    printf("integration: %d passed, %d failed\n", passed, failed);
    printf("total tests: %d\n", passed + failed);

    return failed > 0 ? 1 : 0;
}