pattern-3 0.5.0

Needle API (née Pattern API 3.0), generalization of `std::str::pattern`
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

extern crate pattern_3;

use pattern_3::Wtf8;
use pattern_3::ext::*;

#[test]
fn test_trim_start_low_surrogate() {
    unsafe {
        let pat = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80");
        let a = Wtf8::from_bytes_unchecked(b"\x90\x80\x80aaa");
        assert_eq!(trim_start(a, pat), Wtf8::from_str("aaa"));

        let b = Wtf8::from_bytes_unchecked(b"\x90\x80\x80\xed\xb0\x80bbb");
        assert_eq!(trim_start(b, pat), Wtf8::from_str("bbb"));

        let c = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80\xed\xb0\x80ccc");
        assert_eq!(trim_start(c, pat), Wtf8::from_str("ccc"));

        let d = Wtf8::from_bytes_unchecked(b"\xbf\xb0\x80ddd");
        assert_eq!(trim_start(d, pat), Wtf8::from_str("ddd"));

        let e = Wtf8::from_bytes_unchecked(b"\xe3\xb0\x80eee");
        assert_eq!(trim_start(e, pat), Wtf8::from_str("㰀eee"));
    }
}

#[test]
fn test_trim_start_high_surrogate() {
    unsafe {
        let pat = Wtf8::from_bytes_unchecked(b"\xed\xa0\x80");
        let a = Wtf8::from_bytes_unchecked(b"\xf0\x90\x80\x80");
        assert_eq!(trim_start(a, pat), Wtf8::from_bytes_unchecked(b"\x90\x80\x80"));

        let b = Wtf8::from_bytes_unchecked(b"\xed\xa0\x80bbb");
        assert_eq!(trim_start(b, pat), Wtf8::from_str("bbb"));

        let c = Wtf8::from_bytes_unchecked(b"\xed\xa0\x80\xf0\x90\x8f\xbfccc");
        assert_eq!(trim_start(c, pat), Wtf8::from_bytes_unchecked(b"\x90\x8f\xbfccc"));
    }
}

#[test]
fn test_trim_end_high_surrogate() {
    unsafe {
        let pat = Wtf8::from_bytes_unchecked(b"\xed\xa0\x80");
        let a = Wtf8::from_bytes_unchecked(b"aaa\xf0\x90\x80");
        assert_eq!(trim_end(a, pat), Wtf8::from_str("aaa"));

        let b = Wtf8::from_bytes_unchecked(b"bbb\xed\xa0\x80\xf0\x90\x80");
        assert_eq!(trim_end(b, pat), Wtf8::from_str("bbb"));

        let c = Wtf8::from_bytes_unchecked(b"ccc\xed\xa0\x80\xed\xa0\x80");
        assert_eq!(trim_end(c, pat), Wtf8::from_str("ccc"));

        let d = Wtf8::from_bytes_unchecked(b"ddd\xf0\x90\x8f");
        assert_eq!(trim_end(d, pat), Wtf8::from_str("ddd"));

        let e = Wtf8::from_bytes_unchecked(b"eee\xf0\x91\x80");
        assert_eq!(trim_end(e, pat), e);

        let f = Wtf8::from_bytes_unchecked(b"fff\xed\xb0\x80");
        assert_eq!(trim_end(f, pat), f);
    }
}

#[test]
fn test_trim_end_low_surrogate() {
    unsafe {
        let pat = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80");
        let a = Wtf8::from_bytes_unchecked(b"\xf0\x90\x80\x80");
        assert_eq!(trim_end(a, pat), Wtf8::from_bytes_unchecked(b"\xf0\x90\x80"));

        let b = Wtf8::from_bytes_unchecked(b"bbb\xed\xb0\x80");
        assert_eq!(trim_end(b, pat), Wtf8::from_str("bbb"));

        let c = Wtf8::from_bytes_unchecked(b"ccc\xf4\x8f\xb0\x80\xed\xb0\x80");
        assert_eq!(trim_end(c, pat), Wtf8::from_bytes_unchecked(b"ccc\xf4\x8f\xb0"));
    }
}

#[test]
fn test_match_string_with_surrogates() {
    unsafe {
        let haystack = &Wtf8::from_str("\u{10000}a\u{10000}a\u{10000}\u{10000}")[2..16];
        // 0..3 = U+DC00
        // 3..4 = 'a'
        // 4..6 = U+D800
        // 6..8 = U+DC00
        // 8..9 = 'a'
        // 9..11 = U+D800
        // 11..13 = U+DC00
        // 13..16 = U+D800

        let pat = "a";
        let matched_pat = Wtf8::from_str(pat);
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (3..4, matched_pat),
            (8..9, matched_pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (8..9, matched_pat),
            (3..4, matched_pat),
        ]);

        let pat = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80a");
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (0..4, pat),
            (6..9, pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (6..9, pat),
            (0..4, pat),
        ]);

        let pat = Wtf8::from_bytes_unchecked(b"a\xed\xa0\x80");
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (3..6, pat),
            (8..11, pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (8..11, pat),
            (3..6, pat),
        ]);

        let pat = "\u{10000}";
        let matched_pat = Wtf8::from_str(pat);
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (4..8, matched_pat),
            (9..13, matched_pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (9..13, matched_pat),
            (4..8, matched_pat),
        ]);

        let pat = Wtf8::from_bytes_unchecked(b"\xed\xa0\x80");
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (4..6, pat),
            (9..11, pat),
            (13..16, pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (13..16, pat),
            (9..11, pat),
            (4..6, pat),
        ]);

        let pat = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80");
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (0..3, pat),
            (6..8, pat),
            (11..13, pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (11..13, pat),
            (6..8, pat),
            (0..3, pat),
        ]);

        let pat = Wtf8::from_bytes_unchecked(b"\xed\xb0\x80\xed\xa0\x80");
        assert_eq!(match_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (11..16, pat),
        ]);
        assert_eq!(rmatch_ranges(haystack, pat).collect::<Vec<_>>(), vec![
            (11..16, pat),
        ]);
    }
}