regexr 0.1.2

A high-performance regex engine built from scratch with JIT compilation and SIMD acceleration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Backreference tests (\1, \2, etc.).
//!
//! When the `jit` feature is enabled, these tests use JIT compilation.
//! Backreferences require PikeVM fallback for JIT (DFA can't handle them).

// Using local mod.rs

use super::regex;

use regexr::Regex;

#[test]
fn test_backref_basic() {
    let re = regex(r"(a)\1");
    assert!(re.is_match("aa"));
    assert!(!re.is_match("ab"));
    assert!(!re.is_match("a"));
}

#[test]
fn test_backref_word() {
    let re = regex(r"(\w+)\s+\1");
    assert!(re.is_match("hello hello"));
    assert!(re.is_match("the the"));
    assert!(!re.is_match("hello world"));
}

#[test]
fn test_backref_multiple_groups() {
    let re = regex(r"(a)(b)\2\1");
    assert!(re.is_match("abba"));
    assert!(!re.is_match("abab"));
    assert!(!re.is_match("aabb"));
}

#[test]
fn test_backref_nested_groups() {
    let re = regex(r"((a)b)\1");
    assert!(re.is_match("abab"));
    assert!(!re.is_match("abaa"));
}

#[test]
fn test_backref_with_quantifier() {
    let re = regex(r"(a+)\1");
    assert!(re.is_match("aa"));
    assert!(re.is_match("aaaa"));
    assert!(re.is_match("aaaaaa"));
    assert!(re.is_match("aaa"));

    let m = re.find("aaa").unwrap();
    assert_eq!(m.as_str(), "aa");
}

#[test]
fn test_backref_empty_capture() {
    let re = regex(r"(a?)\1");
    assert!(re.is_match(""));
    assert!(re.is_match("aa"));
}

#[test]
fn test_backref_in_alternation() {
    let re = regex(r"(a)\1|bb");
    assert!(re.is_match("aa"));
    assert!(re.is_match("bb"));
    assert!(!re.is_match("ab"));
}

#[test]
fn test_backref_find() {
    let re = regex(r"(\w)\1");
    let m = re.find("abccde").unwrap();
    assert_eq!(m.as_str(), "cc");
    assert_eq!(m.start(), 2);
}

#[test]
fn test_backref_captures() {
    let re = regex(r"(\w+) and \1");
    let caps = re.captures("cats and cats").unwrap();
    assert_eq!(&caps[0], "cats and cats");
    assert_eq!(&caps[1], "cats");
}

#[test]
fn test_backref_invalid_group() {
    let result = Regex::new(r"\1");
    assert!(result.is_err());

    let result = Regex::new(r"(a)\2");
    assert!(result.is_err());

    let result = Regex::new(r"(a)(b)\3");
    assert!(result.is_err());

    let result = Regex::new(r"(a)\1");
    assert!(result.is_ok());

    let result = Regex::new(r"(a)(b)\1\2");
    assert!(result.is_ok());
}