match - structure_test.go
1 package match
2
3 import (
4 "errors"
5 "reflect"
6 "testing"
7
8 "vimagination.zapto.org/parser"
9 )
10
11 func TestStructure(t *testing.T) {
12 for n, test := range [...]struct {
13 Input string
14 Tokeniser parser.TokenFunc
15 Err error
16 Output *or[byte]
17 }{
18 { // 1
19 Input: "",
20 Tokeniser: simpleStart,
21 Output: &or[byte]{
22 sequences: []sequence[byte]{
23 {
24 parts: []part[byte]{
25 {
26 partType: partStart,
27 },
28 {
29 partType: partEnd,
30 },
31 },
32 },
33 },
34 },
35 },
36 { // 2
37 Input: "a",
38 Tokeniser: simpleStart,
39 Output: &or[byte]{
40 sequences: []sequence[byte]{
41 {
42 parts: []part[byte]{
43 {
44 partType: partStart,
45 },
46 {
47 char: &char[byte]{
48 char: [256]bool{'a': true},
49 },
50 },
51 {
52 partType: partEnd,
53 },
54 },
55 },
56 },
57 },
58 },
59 { // 3
60 Input: "abc",
61 Tokeniser: simpleStart,
62 Output: &or[byte]{
63 sequences: []sequence[byte]{
64 {
65 parts: []part[byte]{
66 {
67 partType: partStart,
68 },
69 {
70 char: &char[byte]{
71 char: [256]bool{'a': true},
72 },
73 },
74 {
75 char: &char[byte]{
76 char: [256]bool{'b': true},
77 },
78 },
79 {
80 char: &char[byte]{
81 char: [256]bool{'c': true},
82 },
83 },
84 {
85 partType: partEnd,
86 },
87 },
88 },
89 },
90 },
91 },
92 { // 4
93 Input: "",
94 Tokeniser: partialStringStart,
95 Output: &or[byte]{
96 sequences: []sequence[byte]{
97 {
98 parts: []part[byte]{
99 {
100 partType: partStart,
101 },
102 {
103 partType: partEnd,
104 },
105 },
106 },
107 },
108 },
109 },
110 { // 5
111 Input: "a",
112 Tokeniser: partialStringStart,
113 Output: &or[byte]{
114 sequences: []sequence[byte]{
115 {
116 parts: []part[byte]{
117 {
118 partType: partStart,
119 },
120 {
121 char: &char[byte]{
122 char: [256]bool{'a': true},
123 },
124 },
125 {
126 partType: partEnd,
127 },
128 },
129 },
130 },
131 },
132 },
133 { // 6
134 Input: "abc",
135 Tokeniser: partialStringStart,
136 Output: &or[byte]{
137 sequences: []sequence[byte]{
138 {
139 parts: []part[byte]{
140 {
141 partType: partStart,
142 },
143 {
144 char: &char[byte]{
145 char: [256]bool{'a': true},
146 },
147 },
148 {
149 char: &char[byte]{
150 char: [256]bool{'b': true},
151 },
152 },
153 {
154 char: &char[byte]{
155 char: [256]bool{'c': true},
156 },
157 },
158 {
159 partType: partEnd,
160 },
161 },
162 },
163 },
164 },
165 },
166 { // 7
167 Input: "*",
168 Tokeniser: partialStringStart,
169 Output: &or[byte]{
170 sequences: []sequence[byte]{
171 {
172 parts: []part[byte]{
173 {
174 partType: partStart,
175 },
176 {
177 partType: partMany,
178 char: &char[byte]{
179 invert: true,
180 },
181 },
182 {
183 partType: partEnd,
184 },
185 },
186 },
187 },
188 },
189 },
190 { // 8
191 Input: "*abc",
192 Tokeniser: partialStringStart,
193 Output: &or[byte]{
194 sequences: []sequence[byte]{
195 {
196 parts: []part[byte]{
197 {
198 partType: partStart,
199 },
200 {
201 partType: partMany,
202 char: &char[byte]{
203 invert: true,
204 },
205 },
206 {
207 char: &char[byte]{
208 char: [256]bool{'a': true},
209 },
210 },
211 {
212 char: &char[byte]{
213 char: [256]bool{'b': true},
214 },
215 },
216 {
217 char: &char[byte]{
218 char: [256]bool{'c': true},
219 },
220 },
221 {
222 partType: partEnd,
223 },
224 },
225 },
226 },
227 },
228 },
229 { // 9
230 Input: "*a*b*c*",
231 Tokeniser: partialStringStart,
232 Output: &or[byte]{
233 sequences: []sequence[byte]{
234 {
235 parts: []part[byte]{
236 {
237 partType: partStart,
238 },
239 {
240 partType: partMany,
241 char: &char[byte]{
242 invert: true,
243 },
244 },
245 {
246 char: &char[byte]{
247 char: [256]bool{'a': true},
248 },
249 },
250 {
251 partType: partMany,
252 char: &char[byte]{
253 invert: true,
254 },
255 },
256 {
257 char: &char[byte]{
258 char: [256]bool{'b': true},
259 },
260 },
261 {
262 partType: partMany,
263 char: &char[byte]{
264 invert: true,
265 },
266 },
267 {
268 char: &char[byte]{
269 char: [256]bool{'c': true},
270 },
271 },
272 {
273 partType: partMany,
274 char: &char[byte]{
275 invert: true,
276 },
277 },
278 {
279 partType: partEnd,
280 },
281 },
282 },
283 },
284 },
285 },
286 } {
287 o, err := parse[byte](test.Input, test.Tokeniser)
288 if !errors.Is(err, test.Err) {
289 t.Errorf("test %d: expecting error %v, got %v", n+1, test.Err, err)
290 } else if !reflect.DeepEqual(o, test.Output) {
291 t.Errorf("test %d: expecting output %v, got %v", n+1, test.Output, o)
292 }
293 }
294 }
295