710 lines
21 KiB
V
710 lines
21 KiB
V
/*
|
||
regex_test.v
|
||
|
||
Copyright (c) 2026 Dario Deledda. All rights reserved.
|
||
Use of this source code is governed by an MIT license
|
||
that can be found in the LICENSE file.
|
||
*/
|
||
import regex.pcre
|
||
|
||
fn main() {
|
||
println('Running pcre tests...\n')
|
||
|
||
test_regex()
|
||
test_complex_quantifiers()
|
||
test_range_quantifiers()
|
||
test_anchors()
|
||
test_word_boundaries()
|
||
test_flags()
|
||
test_named_groups()
|
||
test_non_capturing_groups()
|
||
|
||
// New features tests
|
||
test_find_all()
|
||
test_find_from()
|
||
test_replace()
|
||
// test_stress_vm()
|
||
|
||
println('\nAll tests passed!')
|
||
}
|
||
|
||
// --- New Feature Tests ---
|
||
|
||
fn test_find_all() {
|
||
println('\n--- Testing find_all() ---')
|
||
|
||
// Basic extraction
|
||
tst_find_all(r'\d+', '123 abc 456', ['123', '456'])
|
||
tst_find_all(r'\w+', 'hi there', ['hi', 'there'])
|
||
|
||
// No matches
|
||
tst_find_all(r'\d+', 'no numbers', [])
|
||
|
||
// Pattern matching empty strings (e.g., boundaries)
|
||
// Note: Behavior depends on engine implementation regarding empty matches.
|
||
// Current VM advances index if match length is 0 to avoid infinite loop.
|
||
// Pattern \b matches at 0 (start), 3 (after 123), 4 (before abc), 7 (after abc)
|
||
// But find_all usually returns non-overlapping text. \b returns empty string.
|
||
// tst_find_all(r'\b', '123 abc', ['', '', '', '']) // Commented out, specific implementation detail
|
||
|
||
// Anchored find_all (should only match once if anchored at start)
|
||
tst_find_all(r'^\w+', 'word word word', ['word'])
|
||
|
||
// Overlapping logic check (find_all is typically non-overlapping)
|
||
// "ana" in "banana". Indices: 1 ("ana"). Next search starts at 4 ("na").
|
||
tst_find_all(r'ana', 'banana', ['ana'])
|
||
}
|
||
|
||
fn test_find_from() {
|
||
println('\n--- Testing find_from() ---')
|
||
|
||
text := 'test test test'
|
||
|
||
// Start from 0 (finds first)
|
||
tst_find_from(r'test', text, 0, 0, 'test')
|
||
|
||
// Start from 1 (skips first, finds second)
|
||
tst_find_from(r'test', text, 1, 5, 'test')
|
||
|
||
// Start from 6 (finds third)
|
||
tst_find_from(r'test', text, 6, 10, 'test')
|
||
|
||
// Start from end (finds nothing)
|
||
tst_find_from(r'test', text, 11, -1, 'none')
|
||
|
||
// Out of bounds
|
||
tst_find_from(r'test', text, 50, -1, 'none')
|
||
|
||
// Start exactly at match position
|
||
tst_find_from(r'test', text, 5, 5, 'test')
|
||
}
|
||
|
||
fn test_replace() {
|
||
println('\n--- Testing replace() ---')
|
||
|
||
// Simple replacement
|
||
tst_replace(r'\d+', 'abc 123 def', 'NUM', 'abc NUM def')
|
||
|
||
// Group substitution
|
||
tst_replace(r'(\w+), (\w+)', 'Doe, John', '$2 $1', 'John Doe')
|
||
|
||
// Multiple replacements?
|
||
// The current replace() implementation in the provided code
|
||
// usually replaces the FIRST occurrence (based on find()).
|
||
// Let's verify:
|
||
tst_replace(r'a', 'bananas', 'o', 'bonanas')
|
||
|
||
tst_replace(r'(^[#.]+)|([#.]+$)', r'_#abc.#_ab#', '*', '_#abc.#_ab*')
|
||
|
||
// Invalid group index (should ignore or remove)
|
||
tst_replace(r'(\d+)', '123', 'Num: $9', 'Num: ')
|
||
}
|
||
|
||
/*
|
||
fn test_stress_vm() {
|
||
println('\n--- Testing VM Stability (Stress Test) ---')
|
||
// Recursive engines often crash on patterns like (a*)* or very long strings
|
||
// if not carefully managed. The VM should handle this via heap stack.
|
||
|
||
long_text := 'a'.repeat(2000)
|
||
tst_find(r'a+', long_text, long_text)
|
||
|
||
println(' [Pass] Long string match')
|
||
|
||
// Backtracking stress
|
||
// Pattern: (a+)+b matching aaaaa....a (fails)
|
||
// This forces extensive backtracking.
|
||
short_text := 'a'.repeat(25)
|
||
mut r := pcre.compile(r'(a+)+b') or { panic(err) }
|
||
r.max_stack_depth = 4000 // increase the stack depth for this test
|
||
res := r.find(short_text)
|
||
assert res == none
|
||
println(' [Pass] Backtracking stress test')
|
||
}
|
||
*/
|
||
|
||
// --- Existing Tests ---
|
||
|
||
fn test_flags() {
|
||
println('\n--- Testing Flags ((?i), (?m), (?s)) ---')
|
||
|
||
// 1. Case Insensitive (?i)
|
||
tst_find('(?i)cat', 'Cat', 'Cat')
|
||
tst_find('(?i)CAT', 'cat', 'cat')
|
||
tst_find('(?i)[a-z]+', 'UPPER', 'UPPER') // char class expansion
|
||
tst_find('(?i)x', 'X', 'X')
|
||
tst_find('(?i)x', 'y', 'none')
|
||
|
||
// Mixed (flag applies to subsequent tokens)
|
||
tst_find('c(?i)at', 'cAT', 'cAT')
|
||
tst_find('c(?i)at', 'Cat', 'none') // first 'c' is case-sensitive
|
||
|
||
// 2. Multiline (?m)
|
||
// ^ matches start of line
|
||
tst_find('(?m)^line2', 'line1\nline2', 'line2')
|
||
tst_find('^line2', 'line1\nline2', 'none') // Default: matches only start of string
|
||
|
||
// $ matches end of line
|
||
tst_find('(?m)line1$', 'line1\nline2', 'line1')
|
||
tst_find('line1$', 'line1\nline2', 'none') // Default: matches only end of string
|
||
|
||
// 3. Dot-all / Singleline (?s)
|
||
// . matches newline
|
||
tst_find('(?s)a.b', 'a\nb', 'a\nb')
|
||
tst_find('a.b', 'a\nb', 'none') // Default: . does not match \n
|
||
|
||
// 4. Combined Flags (?im)
|
||
tst_find('(?im)^line2', 'LINE1\nLINE2', 'LINE2')
|
||
|
||
// --- Negative Tests (Flags) ---
|
||
tst_find('(?i)cat', 'dog', 'none')
|
||
tst_find('(?m)^line2', 'line1 line2', 'none') // Not at start of line
|
||
}
|
||
|
||
fn test_word_boundaries() {
|
||
println('\n--- Testing Word Boundaries (\\b and \\B) ---')
|
||
|
||
// 1. Word Boundary (\b)
|
||
tst_find('\\bcat', 'cat', 'cat')
|
||
tst_find('\\bcat', 'concat', 'none')
|
||
tst_find('\\bcat', 'catapult', 'cat')
|
||
|
||
tst_find('cat\\b', 'cat', 'cat')
|
||
tst_find('cat\\b', 'concat', 'cat')
|
||
tst_find('cat\\b', 'catapult', 'none')
|
||
|
||
tst_find('\\bcat\\b', 'cat', 'cat')
|
||
tst_find('\\bcat\\b', 'a cat is here', 'cat')
|
||
tst_find('\\bcat\\b', 'concat', 'none')
|
||
tst_find('\\bcat\\b', 'catapult', 'none')
|
||
|
||
tst_find('\\btest\\b', 'test.', 'test')
|
||
tst_find('\\btest\\b', '(test)', 'test')
|
||
|
||
// 2. Non-Word Boundary (\B)
|
||
tst_find('a\\B', 'ab', 'a')
|
||
tst_find('a\\B', 'a.', 'none')
|
||
tst_find('\\Bcat', 'concat', 'cat')
|
||
tst_find('\\Bcat', 'cat', 'none')
|
||
tst_find('cat\\B', 'catapult', 'cat')
|
||
|
||
// --- Negative Tests (Word Boundaries) ---
|
||
tst_find('\\b\\w+\\b', '... ...', 'none')
|
||
tst_find('\\B', 'a', 'none')
|
||
}
|
||
|
||
fn test_anchors() {
|
||
println('\n--- Testing Anchors (^ and $) ---')
|
||
|
||
// 1. Start of String (^)
|
||
tst_find('^abc', 'abc', 'abc')
|
||
tst_find('^abc', 'abcdef', 'abc')
|
||
tst_find('^abc', 'abc abc', 'abc')
|
||
tst_find('^\\d+', '123 text', '123')
|
||
|
||
// 2. End of String ($)
|
||
tst_find('xyz$', 'xyz', 'xyz')
|
||
tst_find('xyz$', 'abcxyz', 'xyz')
|
||
tst_find('\\d+$', 'text 123', '123')
|
||
|
||
// 3. Both Anchors (^...$)
|
||
tst_find('^hello$', 'hello', 'hello')
|
||
|
||
// 4. Zero-width matches
|
||
tst_find('^', 'abc', '')
|
||
tst_find('$', 'abc', '')
|
||
|
||
// 5. Anchors with Alternation
|
||
tst_find('^a|b$', 'apple', 'a')
|
||
tst_find('^a|b$', 'blob', 'b')
|
||
|
||
// 6. Anchors with Groups
|
||
tst_find('^(abc)+$', 'abcabc', 'abcabc')
|
||
|
||
// --- Negative Tests (Anchors) ---
|
||
tst_find('^abc', 'xyzabc', 'none')
|
||
tst_find('^\\d+', 'text 123', 'none')
|
||
tst_find('xyz$', 'xyzabc', 'none')
|
||
tst_find('\\d+$', '123 text', 'none')
|
||
tst_find('^hello$', 'hello world', 'none')
|
||
tst_find('^hello$', 'say hello', 'none')
|
||
tst_find('^a|b$', 'cba', 'none')
|
||
tst_find('^(abc)+$', 'abcabcx', 'none')
|
||
tst_find('^$', 'a', 'none')
|
||
}
|
||
|
||
fn test_regex() {
|
||
println('\n--- Testing Basic Features ---')
|
||
tst_find('a?b', 'ab', 'ab')
|
||
tst_find('a?b', 'b', 'b')
|
||
tst_find('a+b', 'aaab', 'aaab')
|
||
tst_find('a*b', 'b', 'b')
|
||
tst_find('\\d+', '123 abc', '123')
|
||
|
||
println('\n--- Testing Character Classes ---')
|
||
tst_find('\\w+', 'word1_ and', 'word1_')
|
||
tst_find('\\W+', ' and', ' ')
|
||
tst_find('\\s+', ' start', ' ')
|
||
tst_find('\\d{3}-\\d{4}', 'call 555-1234 now', '555-1234')
|
||
tst_find('\\D+', 'call 555', 'call ')
|
||
tst_find('\\a+', 'lowercase', 'lowercase')
|
||
tst_find('\\A+', 'UPPER', 'UPPER')
|
||
|
||
println('\n--- Testing Alternation (|) ---')
|
||
tst_find('cat|dog', 'the dog says meow', 'dog')
|
||
tst_find('a(b|c)d', 'acd', 'acd')
|
||
tst_find('apple|apply', 'I want to apply', 'apply')
|
||
|
||
println('\n--- Testing Custom Character Classes ([...]) ---')
|
||
tst_find('[aeiou]', 'hello world', 'e')
|
||
tst_find('gr[ae]y', 'the color grey', 'grey')
|
||
tst_find('[^aeiou]+', 'rhythm', 'rhythm')
|
||
tst_find('[a-z]+', 'lowercase123', 'lowercase')
|
||
tst_find('[a-zA-Z0-9_]+', 'word_1_with_everything', 'word_1_with_everything')
|
||
|
||
println('\n--- Testing Unicode ---')
|
||
tst_find('日本語', 'Text containing 日本語.', '日本語')
|
||
tst_find('h.llo', 'héllo wørld', 'héllo')
|
||
tst_find('(é)+', 'cafééé', 'ééé')
|
||
tst_find('😀+', 'Happy 😀😀 day', '😀😀')
|
||
|
||
println('\n--- Testing fullmatch() ---')
|
||
tst_fullmatch(r'\d+', '12345', '12345')
|
||
tst_fullmatch('(?s).*', 'Any content including 😀', 'Any content including 😀')
|
||
|
||
// --- Negative Tests (Basic) ---
|
||
tst_find('abc', 'ab', 'none')
|
||
tst_find('abc', 'acb', 'none')
|
||
tst_find('a+b', 'b', 'none')
|
||
tst_find('\\d+', 'abc', 'none')
|
||
tst_find('\\D+', '123', 'none')
|
||
tst_find('\\w+', '@#$', 'none')
|
||
tst_find('\\s+', 'Text', 'none')
|
||
tst_find('\\a+', 'UPPERCASE', 'none')
|
||
tst_find('\\A+', 'lowercase', 'none')
|
||
tst_find('cat|dog', 'bird', 'none')
|
||
tst_find('[0-9]', 'a', 'none')
|
||
tst_find('[^0-9]', '1', 'none')
|
||
tst_fullmatch(r'\d+', '12345abc', 'none')
|
||
tst_fullmatch(r'\d+', 'abc12345', 'none')
|
||
|
||
println('\n--- Testing Compilation Errors ---')
|
||
tst_compile_error('a++')
|
||
tst_compile_error('[a-z')
|
||
tst_compile_error('a|')
|
||
}
|
||
|
||
fn test_complex_quantifiers() {
|
||
println('\n--- Testing Complex Quantifiers (+, *, ?) ---')
|
||
|
||
tst_find('a+', 'aaaaa', 'aaaaa')
|
||
tst_find('a+b', 'aaaaab', 'aaaaab')
|
||
|
||
tst_find('x*y', 'y', 'y')
|
||
tst_find('x*y', 'xy', 'xy')
|
||
tst_find('x*y', 'xxxy', 'xxxy')
|
||
|
||
tst_find('colou?r', 'color', 'color')
|
||
tst_find('colou?r', 'colour', 'colour')
|
||
tst_find('x?y', 'xy', 'xy')
|
||
tst_find('x?y', 'y', 'y')
|
||
|
||
tst_find('(ab)+', 'ababab', 'ababab')
|
||
tst_find('(ha)+', 'hahaha!', 'hahaha')
|
||
|
||
tst_find('(cat|dog)+', 'catdogcat', 'catdogcat')
|
||
tst_find('(a|b)+', 'abaabbba', 'abaabbba')
|
||
|
||
tst_find('[0-9]+', 'Order 12345', '12345')
|
||
tst_find('[a-z]*', '123', '')
|
||
|
||
// --- Negative Tests (Complex Quantifiers) ---
|
||
tst_find('a+', '', 'none')
|
||
tst_find('a+', 'b', 'none')
|
||
tst_find('a+b', 'aaac', 'none')
|
||
tst_find('x?y', 'x', 'none')
|
||
tst_find('(ab)+', 'ac', 'none')
|
||
tst_find('[0-9]+', 'abc', 'none')
|
||
}
|
||
|
||
fn test_range_quantifiers() {
|
||
println('\n--- Testing Range Quantifiers {m,n} ---')
|
||
|
||
tst_find('a{3}', 'aaa', 'aaa')
|
||
tst_find('a{3}', 'aaaa', 'aaa')
|
||
|
||
tst_find('a{2,}', 'aa', 'aa')
|
||
tst_find('a{2,}', 'aaaaa', 'aaaaa')
|
||
|
||
tst_find('a{,3}', 'aaaa', 'aaa')
|
||
tst_find('a{,3}', 'aa', 'aa')
|
||
tst_find('a{,3}', '', '')
|
||
|
||
tst_find('a{2,4}', 'aa', 'aa')
|
||
tst_find('a{2,4}', 'aaa', 'aaa')
|
||
tst_find('a{2,4}', 'aaaa', 'aaaa')
|
||
tst_find('a{2,4}', 'aaaaa', 'aaaa')
|
||
|
||
tst_find(r'\d{2,4}-\w{2}', '123-ab', '123-ab')
|
||
tst_find(r'\d{2,4}-\w{2}', '12345-ab', '2345-ab')
|
||
|
||
// --- Negative Tests (Range Quantifiers) ---
|
||
tst_find('a{3}', 'aa', 'none')
|
||
tst_find('a{2,}', 'a', 'none')
|
||
tst_find('a{2,4}', 'a', 'none')
|
||
tst_find(r'\d{2,4}-\w{2}', '1-ab', 'none')
|
||
tst_find(r'\d{2,4}-\w{2}', '123-a', 'none')
|
||
}
|
||
|
||
fn test_named_groups() {
|
||
println('\n--- Testing Named Groups ---')
|
||
|
||
pattern := '(?P<year>\\d{4})-(?P<month>\\d{2})'
|
||
text := 'Date: 2025-01'
|
||
r := pcre.compile(pattern) or { panic(err) }
|
||
m := r.find(text) or { panic('Match not found') }
|
||
|
||
assert m.groups[0] == '2025'
|
||
assert m.groups[1] == '01'
|
||
|
||
assert r.group_by_name(m, 'year') == '2025'
|
||
assert r.group_by_name(m, 'month') == '01'
|
||
assert r.group_by_name(m, 'missing') == ''
|
||
|
||
nested_pat := '(?P<entry>key: (?P<val>\\d+))'
|
||
nested_txt := 'List [ key: 99 ]'
|
||
r_nested := pcre.compile(nested_pat) or { panic(err) }
|
||
m_nested := r_nested.find(nested_txt) or { panic('Match not found') }
|
||
|
||
println('Nested: entry="${r_nested.group_by_name(m_nested, 'entry')}", val="${r_nested.group_by_name(m_nested,
|
||
'val')}"')
|
||
assert r_nested.group_by_name(m_nested, 'entry') == 'key: 99'
|
||
assert r_nested.group_by_name(m_nested, 'val') == '99'
|
||
|
||
pattern_mixed := '(?P<key>\\w+): (\\d+)'
|
||
text_mixed := 'Price: 100'
|
||
r_mixed := pcre.compile(pattern_mixed) or { panic(err) }
|
||
m_mixed := r_mixed.find(text_mixed) or { panic('Match not found') }
|
||
|
||
assert m_mixed.groups[0] == 'Price'
|
||
assert m_mixed.groups[1] == '100'
|
||
assert r_mixed.group_by_name(m_mixed, 'key') == 'Price'
|
||
|
||
p_seq := '(?P<a>a)(?P<b>b)(?P<c>c)'
|
||
t_seq := 'abc'
|
||
r_seq := pcre.compile(p_seq) or { panic(err) }
|
||
m_seq := r_seq.find(t_seq) or { panic('Match not found') }
|
||
assert r_seq.group_by_name(m_seq, 'a') == 'a'
|
||
assert r_seq.group_by_name(m_seq, 'b') == 'b'
|
||
assert r_seq.group_by_name(m_seq, 'c') == 'c'
|
||
|
||
// --- Negative Tests (Named Groups) ---
|
||
if _ := r.find('Date: 99-01') {
|
||
assert false, 'Should not match'
|
||
} else {
|
||
println('Found: none (Expected: none)')
|
||
}
|
||
tst_find('(?P<id>\\d+)', 'abc', 'none')
|
||
}
|
||
|
||
fn test_non_capturing_groups() {
|
||
println('\n--- Testing Non-Capturing Groups ---')
|
||
|
||
tst_find_with_groups('(?:a|b)c', 'ac', 'ac', [])
|
||
|
||
tst_find_with_groups('(a)(?:b)(c)', 'abc', 'abc', ['a', 'c'])
|
||
|
||
tst_find_with_groups('(a(?:b)c)', 'abc', 'abc', ['abc'])
|
||
|
||
tst_find_with_groups('(?:header): (\\d+)', 'header: 123', 'header: 123', ['123'])
|
||
|
||
// --- Negative Tests (Non-Capturing Groups) ---
|
||
tst_find('(?:a|b)c', 'dc', 'none')
|
||
tst_find('(?:a)b', 'c', 'none')
|
||
}
|
||
|
||
// --- Helper Functions ---
|
||
|
||
fn tst_find(pattern string, text string, expected string) {
|
||
print('[find] Pattern: "${pattern}", Text: "${text}" -> ')
|
||
r := pcre.compile(pattern) or {
|
||
println('Compile error: ${err}')
|
||
assert false, 'Unexpected compile error: ${err}'
|
||
return
|
||
}
|
||
match_res := r.find(text)
|
||
check_result(match_res, expected)
|
||
}
|
||
|
||
fn tst_find_all(pattern string, text string, expected []string) {
|
||
print('[find_all] Pattern: "${pattern}", Text: "${text}" -> ')
|
||
r := pcre.compile(pattern) or { panic(err) }
|
||
matches := r.find_all(text)
|
||
|
||
mut res_strs := []string{}
|
||
for m in matches {
|
||
res_strs << m.text
|
||
}
|
||
|
||
println('Found: ${res_strs}')
|
||
assert res_strs == expected
|
||
}
|
||
|
||
fn tst_find_from(pattern string, text string, start int, expected_pos int, expected_text string) {
|
||
print('[find_from] Pattern: "${pattern}", Start: ${start} -> ')
|
||
r := pcre.compile(pattern) or { panic(err) }
|
||
match_res := r.find_from(text, start)
|
||
|
||
if match_res != none {
|
||
println('Found: "${match_res.text}" at ${match_res.start}')
|
||
assert match_res.text == expected_text
|
||
assert match_res.start == expected_pos
|
||
} else {
|
||
println('Found: none')
|
||
assert expected_text == 'none'
|
||
}
|
||
}
|
||
|
||
fn tst_replace(pattern string, text string, repl string, expected string) {
|
||
print('[replace] Pattern: "${pattern}", Repl: "${repl}" -> ')
|
||
r := pcre.compile(pattern) or { panic(err) }
|
||
res := r.replace(text, repl)
|
||
println('Result: "${res}"')
|
||
assert res == expected
|
||
}
|
||
|
||
fn tst_fullmatch(pattern string, text string, expected string) {
|
||
print('[fullmatch] Pattern: "${pattern}", Text: "${text}" -> ')
|
||
r := pcre.compile(pattern) or {
|
||
println('Compile error: ${err}')
|
||
assert false, 'Unexpected compile error: ${err}'
|
||
return
|
||
}
|
||
match_res := r.fullmatch(text)
|
||
check_result(match_res, expected)
|
||
}
|
||
|
||
fn check_result(match_res ?pcre.Match, expected string) {
|
||
if match_res != none {
|
||
println('Found: "${match_res.text}" (Expected: "${expected}")')
|
||
assert match_res.text == expected
|
||
} else {
|
||
println('Found: none (Expected: "${expected}")')
|
||
assert expected == 'none'
|
||
}
|
||
}
|
||
|
||
fn tst_find_with_groups(pattern string, text string, expected_match string, expected_groups []string) {
|
||
print('[find+groups] Pattern: "${pattern}", Text: "${text}" -> ')
|
||
r := pcre.compile(pattern) or {
|
||
println('Compile error: ${err}')
|
||
assert false, 'Unexpected compile error: ${err}'
|
||
return
|
||
}
|
||
match_res := r.find(text)
|
||
if match_res != none {
|
||
println('Found: "${match_res.text}", Groups: ${match_res.groups}')
|
||
assert match_res.text == expected_match
|
||
assert match_res.groups == expected_groups
|
||
} else {
|
||
println('Found: none')
|
||
assert false // Should have found a match_res
|
||
}
|
||
}
|
||
|
||
fn tst_compile_error(pattern string) {
|
||
print('[compile_error] Pattern: "${pattern}" -> ')
|
||
_ := pcre.compile(pattern) or {
|
||
println('Caught expected error: ${err}')
|
||
return
|
||
}
|
||
println('Error: Did not get a compilation error!')
|
||
assert false
|
||
}
|
||
|
||
fn test_non_greedy_quantifiers() {
|
||
println('\n--- Testing Non-Greedy Quantifiers (*?, +?, ??, {m,n}?) ---')
|
||
|
||
// 1. Lazy Star (*?)
|
||
// Should stop at the first closing '>' (minimal match)
|
||
tst_find(r'<.*?>', '<div>content</div>', '<div>')
|
||
// Contrast with greedy (default) which consumes until the last '>'
|
||
tst_find(r'<.*>', '<div>content</div>', '<div>content</div>')
|
||
|
||
// 2. Lazy Plus (+?)
|
||
// Should match minimal characters (1 'a') to satisfy the constraint
|
||
tst_find(r'a+?', 'aaaaa', 'a')
|
||
// Forced expansion: Must match all 'a's to finally match 'b' (backtracking test)
|
||
tst_find(r'a+?b', 'aaab', 'aaab')
|
||
|
||
// 3. Lazy Question Mark (??)
|
||
// Should match empty string (prefers 0 occurrences over 1)
|
||
tst_find(r'a??', 'a', '')
|
||
// Contextual: 'u' is lazy (prefers skip), matches 'color' immediately
|
||
tst_find(r'colou??r', 'color', 'color')
|
||
// Contextual: 'u' is lazy, tries skip, fails to match 'r', backtracks to match 'u'
|
||
tst_find(r'colou??r', 'colour', 'colour')
|
||
|
||
// 4. Lazy Range ({m,n}?)
|
||
// Should match minimum required (2 digits)
|
||
tst_find(r'\d{2,5}?', '123456789', '12')
|
||
// Contrast with greedy which matches maximum (5 digits)
|
||
tst_find(r'\d{2,5}', '123456789', '12345')
|
||
|
||
// 5. Complex/Real-world Case (User report)
|
||
// Escaped characters + lazy capture group
|
||
// Should match only '$t(common.hello)', not the span to the second ')'
|
||
tst_find(r'\$t\((.*?)\)', r'$t(common.hello) dear $t(common.name)', r'$t(common.hello)')
|
||
|
||
// --- Negative / Edge Cases ---
|
||
|
||
// Lazy quantifier with no termination in string should match nothing/min if possible,
|
||
// but since it's "find", it grabs the first valid match.
|
||
tst_find(r'x.*?y', 'x123y456y', 'x123y') // Stops at first y
|
||
|
||
// Anchor interaction: ^.*?b
|
||
// Matches from start, .*? expands lazily until it hits 'b'
|
||
tst_find(r'^.*?b', '123b', '123b')
|
||
|
||
// Ensure lazy doesn't cause failure when a greedy match would succeed (correct backtracking)
|
||
// Pattern wants to match "a" lazily, but must consume "a" to satisfy the final "a"
|
||
tst_find(r'a?a', 'a', 'a')
|
||
tst_find(r'a??a', 'a', 'a')
|
||
}
|
||
|
||
fn test_compatibility_layer() {
|
||
// Test new_regex (alias for compile)
|
||
// Passing '0' as the second argument to simulate the ignored C-flag argument
|
||
pattern := r'(\w+)\s+(\d+)'
|
||
re := pcre.new_regex(pattern, 0) or {
|
||
assert false, 'new_regex failed to compile: ${err}'
|
||
return
|
||
}
|
||
|
||
text := 'item 42 ignored item 99'
|
||
|
||
// Test match_str (alias for find_from)
|
||
// We start searching from index 0. The third argument '0' is the ignored option flag.
|
||
// This should match "item 42"
|
||
m1 := re.match_str(text, 0, 0) or {
|
||
assert false, 'match_str failed to find match'
|
||
return
|
||
}
|
||
|
||
// Test get()
|
||
// Index 0 should be the full text of the match
|
||
full_match := m1.get(0) or { '' }
|
||
assert full_match == 'item 42'
|
||
|
||
// Index 1 should be the first capture group (\w+)
|
||
group_1 := m1.get(1) or { '' }
|
||
assert group_1 == 'item'
|
||
|
||
// Index 2 should be the second capture group (\d+)
|
||
group_2 := m1.get(2) or { '' }
|
||
assert group_2 == '42'
|
||
|
||
// Index 3 should be none (out of bounds)
|
||
if _ := m1.get(3) {
|
||
assert false, 'get(3) should return none for 2 groups'
|
||
}
|
||
|
||
// Test get_all()
|
||
// Should return ['item 42', 'item', '42']
|
||
all_captures := m1.get_all()
|
||
assert all_captures.len == 3
|
||
assert all_captures[0] == 'item 42'
|
||
assert all_captures[1] == 'item'
|
||
assert all_captures[2] == '42'
|
||
|
||
// Test match_str with a specific start index
|
||
// Start searching after "item 42" (length is 7)
|
||
// This should match "item 99"
|
||
m2 := re.match_str(text, 7, 0) or {
|
||
assert false, 'match_str failed to find second match from offset'
|
||
return
|
||
}
|
||
|
||
assert m2.get(0) or { '' } == 'item 99'
|
||
assert m2.get(2) or { '' } == '99'
|
||
|
||
// Test match_str failure case
|
||
// Start searching at the very end of string
|
||
no_match := re.match_str(text, text.len, 0)
|
||
if _ := no_match {
|
||
assert false, 'match_str should return none when no match is found'
|
||
}
|
||
}
|
||
|
||
fn test_hex_escapes() {
|
||
// \xHH — two hex digits
|
||
tst_find(r'\x41', 'ABC', 'A') // 0x41 = 'A'
|
||
tst_find(r'\x61', 'abc', 'a') // 0x61 = 'a'
|
||
tst_find(r'\x41+', 'AAAB', 'AAA')
|
||
tst_find(r'\x20\x41', ' A test', ' A') // space + 'A'
|
||
|
||
// \XHHHH — four hex digits (Unicode codepoint)
|
||
tst_find(r'\X0041', 'ABC', 'A') // U+0041 = 'A'
|
||
tst_find(r'\X0061', 'abc', 'a') // U+0061 = 'a'
|
||
tst_find(r'\X03B1', 'αβγ', 'α') // U+03B1 = 'α'
|
||
|
||
// Mix with other escapes
|
||
tst_find(r'\x48\x65\x6C\x6C\x6F', 'Hello World', 'Hello') // \x48\x65\x6C\x6C\x6F = "Hello"
|
||
|
||
// Invalid hex escape compile errors
|
||
tst_compile_error(r'\x4') // only 1 digit
|
||
tst_compile_error(r'\xGG') // invalid hex chars
|
||
tst_compile_error(r'\X004') // only 3 digits
|
||
}
|
||
|
||
fn test_duplicate_named_groups() {
|
||
// Compile error: same name used twice
|
||
tst_compile_error(r'(?P<id>\d+)-(?P<id>\w+)')
|
||
// Different names are fine
|
||
r := pcre.compile(r'(?P<a>\d+)-(?P<b>\w+)') or {
|
||
assert false, 'Should compile: ${err}'
|
||
return
|
||
}
|
||
m := r.find('12-abc') or {
|
||
assert false, 'Should match'
|
||
return
|
||
}
|
||
assert r.group_by_name(m, 'a') == '12'
|
||
assert r.group_by_name(m, 'b') == 'abc'
|
||
}
|
||
|
||
fn test_invalid_quantifier_ranges() {
|
||
// min > max is an error
|
||
tst_compile_error(r'a{3,1}')
|
||
tst_compile_error(r'a{5,2}')
|
||
// negative min-like patterns (parsed as 0)
|
||
// {0,0} should compile and match empty string
|
||
r := pcre.compile(r'a{0,0}b') or {
|
||
assert false, 'Should compile: ${err}'
|
||
return
|
||
}
|
||
m := r.find('b') or {
|
||
assert false, 'Should match'
|
||
return
|
||
}
|
||
assert m.text == 'b'
|
||
}
|
||
|
||
fn test_find_all_utf8_safety() {
|
||
// find_all with an empty-matching pattern must not get stuck inside a multi-byte rune
|
||
r := pcre.compile(r'x*') or { panic(err) }
|
||
matches := r.find_all('aé') // 'é' is 2 bytes (0xC3 0xA9)
|
||
// Every result start/end must align on a rune boundary
|
||
for m in matches {
|
||
text_bytes := 'aé'.bytes()
|
||
if m.start < text_bytes.len {
|
||
// byte at start must not be a UTF-8 continuation byte
|
||
assert (text_bytes[m.start] & 0xC0) != 0x80, 'Misaligned match start at ${m.start}'
|
||
}
|
||
}
|
||
// find_all should not infinite-loop on emoji
|
||
r2 := pcre.compile(r'y*') or { panic(err) }
|
||
matches2 := r2.find_all('😀!')
|
||
assert matches2.len > 0
|
||
}
|