Skip to content

Commit cdcdb81

Browse files
author
Steve Ramage
committed
feat: Add support for Token Based validators (WIP #2)
1 parent 52412e7 commit cdcdb81

File tree

1 file changed

+82
-7
lines changed
  • src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar

1 file changed

+82
-7
lines changed

‎src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/Grammar.kt‎

Lines changed: 82 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -29,18 +29,30 @@ class GrammarTest : TestCase() {
2929
* Execute SUT & Verification
3030
*/
3131
assertEquals(semValid.length, regexTerminal.SemanticMatch(semValid, 0).matchResult)
32+
assertEquals(listOf("1K"), regexTerminal.SemanticMatch(semValid, 0).tokens)
33+
3234
assertEquals(semValid.length, regexTerminal.SyntacticMatch(semValid, 0).matchResult)
35+
assertEquals(listOf("1K"), regexTerminal.SyntacticMatch(semValid, 0).tokens)
36+
3337
assertEquals(NoMatch, regexTerminal.SemanticMatch(synValid, 0))
38+
3439
assertEquals(synValid.length, regexTerminal.SyntacticMatch(synValid, 0).matchResult)
40+
assertEquals(listOf("-2Z"), regexTerminal.SyntacticMatch(synValid, 0).tokens)
41+
3542
assertEquals(NoMatch, regexTerminal.SemanticMatch(invalid, 0))
3643
assertEquals(NoMatch, regexTerminal.SyntacticMatch(invalid, 0))
3744

3845
assertEquals(semValidFromOffset.length, regexTerminal.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
46+
assertEquals(listOf("1K"), regexTerminal.SemanticMatch(semValidFromOffset, garbage.length).tokens)
47+
3948
assertEquals(semValidFromOffset.length, regexTerminal.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
49+
assertEquals(listOf("1K"), regexTerminal.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
4050

4151
assertEquals(synValidFromOffset.length, regexTerminal.SyntacticMatch(synValidFromOffset, garbage.length).matchResult)
42-
assertEquals(NoMatch, regexTerminal.SemanticMatch(synValidFromOffset, garbage.length))
52+
assertEquals(listOf("-2Z"), regexTerminal.SyntacticMatch(synValidFromOffset, garbage.length).tokens)
53+
4354

55+
assertEquals(NoMatch, regexTerminal.SemanticMatch(synValidFromOffset, garbage.length))
4456
assertEquals(NoMatch, regexTerminal.SyntacticMatch(invalidFromOffset, garbage.length))
4557
assertEquals(NoMatch, regexTerminal.SemanticMatch(invalidFromOffset, garbage.length))
4658

@@ -70,13 +82,19 @@ class GrammarTest : TestCase() {
7082
* Execute SUT & Verification
7183
*/
7284
assertEquals(semValid.length, literalChoiceTerminal.SemanticMatch(semValid, 0).matchResult)
85+
assertEquals(listOf("foo"), literalChoiceTerminal.SemanticMatch(semValid, 0).tokens)
86+
7387
assertEquals(semValid.length, literalChoiceTerminal.SyntacticMatch(semValid, 0).matchResult)
88+
assertEquals(listOf("foo"), literalChoiceTerminal.SyntacticMatch(semValid, 0).tokens)
7489

7590
assertEquals(NoMatch, literalChoiceTerminal.SemanticMatch(invalid, 0))
7691
assertEquals(NoMatch, literalChoiceTerminal.SyntacticMatch(invalid, 0))
7792

7893
assertEquals(semValidFromOffset.length, literalChoiceTerminal.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
94+
assertEquals(listOf("foo"), literalChoiceTerminal.SemanticMatch(semValidFromOffset, garbage.length).tokens)
95+
7996
assertEquals(semValidFromOffset.length, literalChoiceTerminal.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
97+
assertEquals(listOf("foo"), literalChoiceTerminal.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
8098

8199
assertEquals(NoMatch, literalChoiceTerminal.SemanticMatch(invalidFromOffset, garbage.length))
82100
assertEquals(NoMatch, literalChoiceTerminal.SyntacticMatch(invalidFromOffset, garbage.length))
@@ -115,12 +133,16 @@ class GrammarTest : TestCase() {
115133
* Execute SUT & Verification
116134
*/
117135
assertEquals(semValid.length, sequenceCombinator.SyntacticMatch(semValid, 0).matchResult)
136+
assertEquals(listOf("1", "K"), sequenceCombinator.SyntacticMatch(semValid, 0).tokens)
137+
118138
assertEquals(semValid.length, sequenceCombinator.SemanticMatch(semValid, 0).matchResult)
139+
assertEquals(listOf("1", "K"), sequenceCombinator.SemanticMatch(semValid, 0).tokens)
119140

120141

121142
assertEquals(synValid.length, sequenceCombinator.SyntacticMatch(synValid, 0).matchResult)
122-
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(synValid, 0))
143+
assertEquals(listOf("-0", "B"), sequenceCombinator.SyntacticMatch(synValid, 0).tokens)
123144

145+
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(synValid, 0))
124146

125147
assertEquals(NoMatch, sequenceCombinator.SyntacticMatch(semPrefix, 0))
126148
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(semPrefix, 0))
@@ -132,14 +154,17 @@ class GrammarTest : TestCase() {
132154
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(invalid, 0))
133155

134156
assertEquals(semValidFromOffset.length, sequenceCombinator.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
157+
assertEquals(listOf("1", "K"), sequenceCombinator.SemanticMatch(semValidFromOffset, garbage.length).tokens)
158+
135159
assertEquals(semValidFromOffset.length, sequenceCombinator.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
160+
assertEquals(listOf("1", "K"), sequenceCombinator.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
136161

137162
assertEquals(synValidFromOffset.length, sequenceCombinator.SyntacticMatch(synValidFromOffset, garbage.length).matchResult)
138-
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(synValidFromOffset, garbage.length))
163+
assertEquals(listOf("-0", "B"), sequenceCombinator.SyntacticMatch(synValidFromOffset, garbage.length).tokens)
139164

165+
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(synValidFromOffset, garbage.length))
140166
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(semPrefixFromOffset, garbage.length))
141167
assertEquals(NoMatch, sequenceCombinator.SyntacticMatch(semPrefixFromOffset, garbage.length))
142-
143168
assertEquals(NoMatch, sequenceCombinator.SemanticMatch(synPrefixFromOffset, garbage.length))
144169
assertEquals(NoMatch, sequenceCombinator.SyntacticMatch(synPrefixFromOffset, garbage.length))
145170

@@ -174,19 +199,31 @@ class GrammarTest : TestCase() {
174199
* Execute SUT & Verification
175200
*/
176201
assertEquals(semValid.length, alternativeCombinator.SyntacticMatch(semValid, 0).matchResult)
202+
assertEquals(listOf("on"), alternativeCombinator.SyntacticMatch(semValid, 0).tokens)
203+
177204
assertEquals(semValid.length, alternativeCombinator.SemanticMatch(semValid, 0).matchResult)
205+
assertEquals(listOf("on"), alternativeCombinator.SemanticMatch(semValid, 0).tokens)
178206

179207
assertEquals(semValid2.length, alternativeCombinator.SyntacticMatch(semValid2, 0).matchResult)
208+
assertEquals(listOf("off"), alternativeCombinator.SyntacticMatch(semValid2, 0).tokens)
209+
180210
assertEquals(semValid2.length, alternativeCombinator.SemanticMatch(semValid2, 0).matchResult)
211+
assertEquals(listOf("off"), alternativeCombinator.SemanticMatch(semValid2, 0).tokens)
181212

182213
assertEquals(NoMatch, alternativeCombinator.SyntacticMatch(invalid, 0))
183214
assertEquals(NoMatch, alternativeCombinator.SemanticMatch(invalid, 0))
184215

185216
assertEquals(semValidFromOffset.length, alternativeCombinator.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
217+
assertEquals(listOf("on"), alternativeCombinator.SemanticMatch(semValidFromOffset, garbage.length).tokens)
218+
186219
assertEquals(semValidFromOffset.length, alternativeCombinator.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
220+
assertEquals(listOf("on"), alternativeCombinator.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
187221

188222
assertEquals(semValid2FromOffset.length, alternativeCombinator.SemanticMatch(semValid2FromOffset, garbage.length).matchResult)
223+
assertEquals(listOf("off"), alternativeCombinator.SemanticMatch(semValid2FromOffset, garbage.length).tokens)
224+
189225
assertEquals(semValid2FromOffset.length, alternativeCombinator.SyntacticMatch(semValid2FromOffset, garbage.length).matchResult)
226+
assertEquals(listOf("off"), alternativeCombinator.SyntacticMatch(semValid2FromOffset, garbage.length).tokens)
190227

191228
assertEquals(NoMatch, alternativeCombinator.SemanticMatch(invalidFromOffset, garbage.length))
192229
assertEquals(NoMatch, alternativeCombinator.SyntacticMatch(invalidFromOffset, garbage.length))
@@ -215,19 +252,28 @@ class GrammarTest : TestCase() {
215252
* Execute SUT & Verification
216253
*/
217254
assertEquals(semValid.length, oneOrMoreCombinator.SyntacticMatch(semValid, 0).matchResult)
255+
assertEquals(listOf("fizz", "buzz", "fizz"), oneOrMoreCombinator.SyntacticMatch(semValid, 0).tokens)
256+
218257
assertEquals(semValid.length, oneOrMoreCombinator.SemanticMatch(semValid, 0).matchResult)
258+
assertEquals(listOf("fizz", "buzz", "fizz"), oneOrMoreCombinator.SemanticMatch(semValid, 0).tokens)
219259

220260
assertEquals(synValid.length, oneOrMoreCombinator.SyntacticMatch(synValid, 0).matchResult)
261+
assertEquals(listOf("bleh", "bleh", "bleh"), oneOrMoreCombinator.SyntacticMatch(synValid, 0).tokens)
262+
221263
assertEquals(NoMatch, oneOrMoreCombinator.SemanticMatch(synValid, 0))
222264

223265
assertEquals(NoMatch, oneOrMoreCombinator.SyntacticMatch(invalid, 0))
224266
assertEquals(NoMatch, oneOrMoreCombinator.SemanticMatch(invalid, 0))
225267

226268
assertEquals(semValidFromOffset.length, oneOrMoreCombinator.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
227-
assertEquals(semValidFromOffset.length, oneOrMoreCombinator.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
269+
assertEquals(listOf("fizz", "buzz", "fizz"), oneOrMoreCombinator.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
228270

271+
assertEquals(semValidFromOffset.length, oneOrMoreCombinator.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
272+
assertEquals(listOf("fizz", "buzz", "fizz"), oneOrMoreCombinator.SemanticMatch(semValidFromOffset, garbage.length).tokens)
229273

230274
assertEquals(synValidFromOffset.length, oneOrMoreCombinator.SyntacticMatch(synValidFromOffset, garbage.length).matchResult)
275+
assertEquals(listOf("bleh", "bleh", "bleh"), oneOrMoreCombinator.SyntacticMatch(synValidFromOffset, garbage.length).tokens)
276+
231277
assertEquals(NoMatch, oneOrMoreCombinator.SemanticMatch(synValidFromOffset, garbage.length))
232278

233279
assertEquals(NoMatch, oneOrMoreCombinator.SyntacticMatch(invalidFromOffset, garbage.length))
@@ -260,29 +306,53 @@ class GrammarTest : TestCase() {
260306
* Execute SUT & Verification
261307
*/
262308
assertEquals(semValid.length, zeroOrMoreCombinator.SyntacticMatch(semValid, 0).matchResult)
309+
assertEquals(listOf("fizz", "buzz", "fizz"), zeroOrMoreCombinator.SyntacticMatch(semValid, 0).tokens)
310+
263311
assertEquals(semValid.length, zeroOrMoreCombinator.SemanticMatch(semValid, 0).matchResult)
312+
assertEquals(listOf("fizz", "buzz", "fizz"), zeroOrMoreCombinator.SemanticMatch(semValid, 0).tokens)
264313

265314
assertEquals(synValid.length, zeroOrMoreCombinator.SyntacticMatch(synValid, 0).matchResult)
315+
assertEquals(listOf("bleh", "bleh", "bleh"), zeroOrMoreCombinator.SyntacticMatch(synValid, 0).tokens)
316+
266317
assertEquals(0, zeroOrMoreCombinator.SemanticMatch(synValid, 0).matchResult)
318+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(synValid, 0).tokens)
267319

268320
assertEquals(semValidEmpty.length, zeroOrMoreCombinator.SyntacticMatch(semValidEmpty, 0).matchResult)
321+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SyntacticMatch(semValidEmpty, 0).tokens)
322+
269323
assertEquals(semValidEmpty.length, zeroOrMoreCombinator.SemanticMatch(semValidEmpty, 0).matchResult)
324+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(semValidEmpty, 0).tokens)
325+
270326

271327
assertEquals(0, zeroOrMoreCombinator.SyntacticMatch(invalid, 0).matchResult)
328+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SyntacticMatch(invalid, 0).tokens)
329+
272330
assertEquals(0, zeroOrMoreCombinator.SemanticMatch(invalid, 0).matchResult)
331+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(invalid, 0).tokens)
273332

274333
assertEquals(semValidFromOffset.length, zeroOrMoreCombinator.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
334+
assertEquals(listOf("fizz", "buzz", "fizz"), zeroOrMoreCombinator.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
335+
275336
assertEquals(semValidFromOffset.length, zeroOrMoreCombinator.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
337+
assertEquals(listOf("fizz", "buzz", "fizz"), zeroOrMoreCombinator.SemanticMatch(semValidFromOffset, garbage.length).tokens)
276338

277339
assertEquals(synValidFromOffset.length, zeroOrMoreCombinator.SyntacticMatch(synValidFromOffset, garbage.length).matchResult)
340+
assertEquals(listOf("bleh", "bleh", "bleh"), zeroOrMoreCombinator.SyntacticMatch(synValidFromOffset, garbage.length).tokens)
341+
278342
assertEquals(garbage.length, zeroOrMoreCombinator.SemanticMatch(synValidFromOffset, garbage.length).matchResult)
343+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(synValidFromOffset, garbage.length).tokens)
279344

280345
assertEquals(garbage.length, zeroOrMoreCombinator.SyntacticMatch(semValidEmptyFromOffset, garbage.length).matchResult)
346+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SyntacticMatch(semValidEmptyFromOffset, garbage.length).tokens)
347+
281348
assertEquals(garbage.length, zeroOrMoreCombinator.SemanticMatch(semValidEmptyFromOffset, garbage.length).matchResult)
349+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(semValidEmptyFromOffset, garbage.length).tokens)
282350

283351
assertEquals(garbage.length, zeroOrMoreCombinator.SyntacticMatch(invalidFromOffset, garbage.length).matchResult)
284-
assertEquals(garbage.length, zeroOrMoreCombinator.SemanticMatch(invalidFromOffset, garbage.length).matchResult)
352+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SyntacticMatch(invalidFromOffset, garbage.length).tokens)
285353

354+
assertEquals(garbage.length, zeroOrMoreCombinator.SemanticMatch(invalidFromOffset, garbage.length).matchResult)
355+
assertEquals(listOf<String>(), zeroOrMoreCombinator.SemanticMatch(invalidFromOffset, garbage.length).tokens)
286356
}
287357

288358
fun testEOFCombinatorMatches() {
@@ -305,17 +375,22 @@ class GrammarTest : TestCase() {
305375
* Execute SUT & Verification
306376
*/
307377
assertEquals(semValid.length, eof.SyntacticMatch(semValid, 0).matchResult)
378+
assertEquals(listOf<String>(), eof.SyntacticMatch(semValid, 0).tokens)
379+
308380
assertEquals(semValid.length, eof.SemanticMatch(semValid, 0).matchResult)
381+
assertEquals(listOf<String>(), eof.SemanticMatch(semValid, 0).tokens)
309382

310383
assertEquals(NoMatch, eof.SyntacticMatch(invalid, 0))
311384
assertEquals(NoMatch, eof.SyntacticMatch(invalid, 0))
312385

313386
assertEquals(semValidFromOffset.length, eof.SyntacticMatch(semValidFromOffset, garbage.length).matchResult)
387+
assertEquals(listOf<String>(), eof.SyntacticMatch(semValidFromOffset, garbage.length).tokens)
388+
314389
assertEquals(semValidFromOffset.length, eof.SemanticMatch(semValidFromOffset, garbage.length).matchResult)
390+
assertEquals(listOf<String>(), eof.SemanticMatch(semValidFromOffset, garbage.length).tokens)
315391

316392
assertEquals(NoMatch, eof.SyntacticMatch(invalidFromOffset, garbage.length))
317393
assertEquals(NoMatch, eof.SemanticMatch(invalidFromOffset, garbage.length))
318-
319394
}
320395

321396
}

0 commit comments

Comments
 (0)