OLD | NEW |
| (Empty) |
1 library petitparser.test.smalltalk_test; | |
2 | |
3 import 'package:test/test.dart'; | |
4 | |
5 import 'package:petitparser/smalltalk.dart'; | |
6 | |
7 var definition = new SmalltalkGrammarDefinition(); | |
8 | |
9 dynamic validate(String source, Function production) { | |
10 var parser = definition.build(start: production).end(); | |
11 var result = parser.parse(source); | |
12 return result.value; | |
13 } | |
14 | |
15 void main() { | |
16 test('testArray1', () { | |
17 return validate('{}', definition.array); | |
18 }); | |
19 test('testArray2', () { | |
20 return validate('{self foo}', definition.array); | |
21 }); | |
22 test('testArray3', () { | |
23 return validate('{self foo. self bar}', definition.array); | |
24 }); | |
25 test('testArray4', () { | |
26 return validate('{self foo. self bar.}', definition.array); | |
27 }); | |
28 test('testAssignment1', () { | |
29 return validate('1', definition.expression); | |
30 }); | |
31 test('testAssignment2', () { | |
32 return validate('a := 1', definition.expression); | |
33 }); | |
34 test('testAssignment3', () { | |
35 return validate('a := b := 1', definition.expression); | |
36 }); | |
37 test('testAssignment6', () { | |
38 return validate('a := (b := c)', definition.expression); | |
39 }); | |
40 test('testComment1', () { | |
41 return validate('1"one"+2', definition.expression); | |
42 }); | |
43 test('testComment2', () { | |
44 return validate('1 "one" +2', definition.expression); | |
45 }); | |
46 test('testComment3', () { | |
47 return validate('1"one"+"two"2', definition.expression); | |
48 }); | |
49 test('testComment4', () { | |
50 return validate('1"one""two"+2', definition.expression); | |
51 }); | |
52 test('testComment5', () { | |
53 return validate('1"one" "two"+2', definition.expression); | |
54 }); | |
55 test('testMethod1', () { | |
56 return validate('negated ^ 0 - self', definition.method); | |
57 }); | |
58 test('testMethod2', () { | |
59 return validate(' negated ^ 0 - self', definition.method); | |
60 }); | |
61 test('testMethod3', () { | |
62 return validate(' negated ^ 0 - self ', definition.method); | |
63 }); | |
64 test('testSequence1', () { | |
65 return validate('| a | 1 . 2', definition.sequence); | |
66 }); | |
67 test('testStatements1', () { | |
68 return validate('1', definition.sequence); | |
69 }); | |
70 test('testStatements2', () { | |
71 return validate('1 . 2', definition.sequence); | |
72 }); | |
73 test('testStatements3', () { | |
74 return validate('1 . 2 . 3', definition.sequence); | |
75 }); | |
76 test('testStatements4', () { | |
77 return validate('1 . 2 . 3 .', definition.sequence); | |
78 }); | |
79 test('testStatements5', () { | |
80 return validate('1 . . 2', definition.sequence); | |
81 }); | |
82 test('testStatements6', () { | |
83 return validate('1. 2', definition.sequence); | |
84 }); | |
85 test('testStatements7', () { | |
86 return validate('. 1', definition.sequence); | |
87 }); | |
88 test('testStatements8', () { | |
89 return validate('.1', definition.sequence); | |
90 }); | |
91 test('testTemporaries1', () { | |
92 return validate('| a |', definition.sequence); | |
93 }); | |
94 test('testTemporaries2', () { | |
95 return validate('| a b |', definition.sequence); | |
96 }); | |
97 test('testTemporaries3', () { | |
98 return validate('| a b c |', definition.sequence); | |
99 }); | |
100 test('testVariable1', () { | |
101 return validate('trueBinding', definition.primary); | |
102 }); | |
103 test('testVariable2', () { | |
104 return validate('falseBinding', definition.primary); | |
105 }); | |
106 test('testVariable3', () { | |
107 return validate('nilly', definition.primary); | |
108 }); | |
109 test('testVariable4', () { | |
110 return validate('selfish', definition.primary); | |
111 }); | |
112 test('testVariable5', () { | |
113 return validate('supernanny', definition.primary); | |
114 }); | |
115 test('testVariable6', () { | |
116 return validate('super_nanny', definition.primary); | |
117 }); | |
118 test('testVariable7', () { | |
119 return validate('__gen_var_123__', definition.primary); | |
120 }); | |
121 test('testArgumentsBlock1', () { | |
122 return validate('[ :a | ]', definition.block); | |
123 }); | |
124 test('testArgumentsBlock2', () { | |
125 return validate('[ :a :b | ]', definition.block); | |
126 }); | |
127 test('testArgumentsBlock3', () { | |
128 return validate('[ :a :b :c | ]', definition.block); | |
129 }); | |
130 test('testComplexBlock1', () { | |
131 return validate('[ :a | | b | c ]', definition.block); | |
132 }); | |
133 test('testComplexBlock2', () { | |
134 return validate('[:a||b|c]', definition.block); | |
135 }); | |
136 test('testSimpleBlock1', () { | |
137 return validate('[ ]', definition.block); | |
138 }); | |
139 test('testSimpleBlock2', () { | |
140 return validate('[ nil ]', definition.block); | |
141 }); | |
142 test('testSimpleBlock3', () { | |
143 return validate('[ :a ]', definition.block); | |
144 }); | |
145 test('testStatementBlock1', () { | |
146 return validate('[ nil ]', definition.block); | |
147 }); | |
148 test('testStatementBlock2', () { | |
149 return validate('[ | a | nil ]', definition.block); | |
150 }); | |
151 test('testStatementBlock3', () { | |
152 return validate('[ | a b | nil ]', definition.block); | |
153 }); | |
154 test('testArrayLiteral1', () { | |
155 return validate('#()', definition.arrayLiteral); | |
156 }); | |
157 test('testArrayLiteral10', () { | |
158 return validate('#((1 2) #(1 2 3))', definition.arrayLiteral); | |
159 }); | |
160 test('testArrayLiteral11', () { | |
161 return validate('#([1 2] #[1 2 3])', definition.arrayLiteral); | |
162 }); | |
163 test('testArrayLiteral2', () { | |
164 return validate('#(1)', definition.arrayLiteral); | |
165 }); | |
166 test('testArrayLiteral3', () { | |
167 return validate('#(1 2)', definition.arrayLiteral); | |
168 }); | |
169 test('testArrayLiteral4', () { | |
170 return validate('#(true false nil)', definition.arrayLiteral); | |
171 }); | |
172 test('testArrayLiteral5', () { | |
173 return validate('#(\$a)', definition.arrayLiteral); | |
174 }); | |
175 test('testArrayLiteral6', () { | |
176 return validate('#(1.2)', definition.arrayLiteral); | |
177 }); | |
178 test('testArrayLiteral7', () { | |
179 return validate('#(size #at: at:put: #' '==' ')', definition.arrayLiteral); | |
180 }); | |
181 test('testArrayLiteral8', () { | |
182 return validate('#(' 'baz' ')', definition.arrayLiteral); | |
183 }); | |
184 test('testArrayLiteral9', () { | |
185 return validate('#((1) 2)', definition.arrayLiteral); | |
186 }); | |
187 test('testByteLiteral1', () { | |
188 return validate('#[]', definition.byteLiteral); | |
189 }); | |
190 test('testByteLiteral2', () { | |
191 return validate('#[0]', definition.byteLiteral); | |
192 }); | |
193 test('testByteLiteral3', () { | |
194 return validate('#[255]', definition.byteLiteral); | |
195 }); | |
196 test('testByteLiteral4', () { | |
197 return validate('#[ 1 2 ]', definition.byteLiteral); | |
198 }); | |
199 test('testByteLiteral5', () { | |
200 return validate('#[ 2r1010 8r77 16rFF ]', definition.byteLiteral); | |
201 }); | |
202 test('testCharLiteral1', () { | |
203 return validate('\$a', definition.characterLiteral); | |
204 }); | |
205 test('testCharLiteral2', () { | |
206 return validate('\$ ', definition.characterLiteral); | |
207 }); | |
208 test('testCharLiteral3', () { | |
209 return validate('\$\$', definition.characterLiteral); | |
210 }); | |
211 test('testNumberLiteral1', () { | |
212 return validate('0', definition.numberLiteral); | |
213 }); | |
214 test('testNumberLiteral10', () { | |
215 return validate('10r10', definition.numberLiteral); | |
216 }); | |
217 test('testNumberLiteral11', () { | |
218 return validate('8r777', definition.numberLiteral); | |
219 }); | |
220 test('testNumberLiteral12', () { | |
221 return validate('16rAF', definition.numberLiteral); | |
222 }); | |
223 test('testNumberLiteral2', () { | |
224 return validate('0.1', definition.numberLiteral); | |
225 }); | |
226 test('testNumberLiteral3', () { | |
227 return validate('123', definition.numberLiteral); | |
228 }); | |
229 test('testNumberLiteral4', () { | |
230 return validate('123.456', definition.numberLiteral); | |
231 }); | |
232 test('testNumberLiteral5', () { | |
233 return validate('-0', definition.numberLiteral); | |
234 }); | |
235 test('testNumberLiteral6', () { | |
236 return validate('-0.1', definition.numberLiteral); | |
237 }); | |
238 test('testNumberLiteral7', () { | |
239 return validate('-123', definition.numberLiteral); | |
240 }); | |
241 test('testNumberLiteral8', () { | |
242 return validate('-123', definition.numberLiteral); | |
243 }); | |
244 test('testNumberLiteral9', () { | |
245 return validate('-123.456', definition.numberLiteral); | |
246 }); | |
247 test('testSpecialLiteral1', () { | |
248 return validate('true', definition.trueLiteral); | |
249 }); | |
250 test('testSpecialLiteral2', () { | |
251 return validate('false', definition.falseLiteral); | |
252 }); | |
253 test('testSpecialLiteral3', () { | |
254 return validate('nil', definition.nilLiteral); | |
255 }); | |
256 test('testStringLiteral1', () { | |
257 return validate('\'\'', definition.stringLiteral); | |
258 }); | |
259 test('testStringLiteral2', () { | |
260 return validate('\'ab\'', definition.stringLiteral); | |
261 }); | |
262 test('testStringLiteral3', () { | |
263 return validate('\'ab\'\'cd\'', definition.stringLiteral); | |
264 }); | |
265 test('testSymbolLiteral1', () { | |
266 return validate('#foo', definition.symbolLiteral); | |
267 }); | |
268 test('testSymbolLiteral2', () { | |
269 return validate('#+', definition.symbolLiteral); | |
270 }); | |
271 test('testSymbolLiteral3', () { | |
272 return validate('#key:', definition.symbolLiteral); | |
273 }); | |
274 test('testSymbolLiteral4', () { | |
275 return validate('#key:value:', definition.symbolLiteral); | |
276 }); | |
277 test('testSymbolLiteral5', () { | |
278 return validate('#\'testing-result\'', definition.symbolLiteral); | |
279 }); | |
280 test('testSymbolLiteral6', () { | |
281 return validate('#__gen__binding', definition.symbolLiteral); | |
282 }); | |
283 test('testSymbolLiteral7', () { | |
284 return validate('# fucker', definition.symbolLiteral); | |
285 }); | |
286 test('testSymbolLiteral8', () { | |
287 return validate('##fucker', definition.symbolLiteral); | |
288 }); | |
289 test('testSymbolLiteral9', () { | |
290 return validate('## fucker', definition.symbolLiteral); | |
291 }); | |
292 test('testBinaryExpression1', () { | |
293 return validate('1 + 2', definition.expression); | |
294 }); | |
295 test('testBinaryExpression2', () { | |
296 return validate('1 + 2 + 3', definition.expression); | |
297 }); | |
298 test('testBinaryExpression3', () { | |
299 return validate('1 // 2', definition.expression); | |
300 }); | |
301 test('testBinaryExpression4', () { | |
302 return validate('1 -- 2', definition.expression); | |
303 }); | |
304 test('testBinaryExpression5', () { | |
305 return validate('1 ==> 2', definition.expression); | |
306 }); | |
307 test('testBinaryMethod1', () { | |
308 return validate('+ a', definition.method); | |
309 }); | |
310 test('testBinaryMethod2', () { | |
311 return validate('+ a | b |', definition.method); | |
312 }); | |
313 test('testBinaryMethod3', () { | |
314 return validate('+ a b', definition.method); | |
315 }); | |
316 test('testBinaryMethod4', () { | |
317 return validate('+ a | b | c', definition.method); | |
318 }); | |
319 test('testBinaryMethod5', () { | |
320 return validate('-- a', definition.method); | |
321 }); | |
322 test('testCascadeExpression1', () { | |
323 return validate('1 abs; negated', definition.expression); | |
324 }); | |
325 test('testCascadeExpression2', () { | |
326 return validate( | |
327 '1 abs negated; raisedTo: 12; negated', definition.expression); | |
328 }); | |
329 test('testCascadeExpression3', () { | |
330 return validate('1 + 2; - 3', definition.expression); | |
331 }); | |
332 test('testKeywordExpression1', () { | |
333 return validate('1 to: 2', definition.expression); | |
334 }); | |
335 test('testKeywordExpression2', () { | |
336 return validate('1 to: 2 by: 3', definition.expression); | |
337 }); | |
338 test('testKeywordExpression3', () { | |
339 return validate('1 to: 2 by: 3 do: 4', definition.expression); | |
340 }); | |
341 test('testKeywordMethod1', () { | |
342 return validate('to: a', definition.method); | |
343 }); | |
344 test('testKeywordMethod2', () { | |
345 return validate('to: a do: b | c |', definition.method); | |
346 }); | |
347 test('testKeywordMethod3', () { | |
348 return validate('to: a do: b by: c d', definition.method); | |
349 }); | |
350 test('testKeywordMethod4', () { | |
351 return validate('to: a do: b by: c | d | e', definition.method); | |
352 }); | |
353 test('testUnaryExpression1', () { | |
354 return validate('1 abs', definition.expression); | |
355 }); | |
356 test('testUnaryExpression2', () { | |
357 return validate('1 abs negated', definition.expression); | |
358 }); | |
359 test('testUnaryMethod1', () { | |
360 return validate('abs', definition.method); | |
361 }); | |
362 test('testUnaryMethod2', () { | |
363 return validate('abs | a |', definition.method); | |
364 }); | |
365 test('testUnaryMethod3', () { | |
366 return validate('abs a', definition.method); | |
367 }); | |
368 test('testUnaryMethod4', () { | |
369 return validate('abs | a | b', definition.method); | |
370 }); | |
371 test('testUnaryMethod5', () { | |
372 return validate('abs | a |', definition.method); | |
373 }); | |
374 test('testPragma1', () { | |
375 return validate('method <foo>', definition.method); | |
376 }); | |
377 test('testPragma10', () { | |
378 return validate('method <foo: bar>', definition.method); | |
379 }); | |
380 test('testPragma11', () { | |
381 return validate('method <foo: true>', definition.method); | |
382 }); | |
383 test('testPragma12', () { | |
384 return validate('method <foo: false>', definition.method); | |
385 }); | |
386 test('testPragma13', () { | |
387 return validate('method <foo: nil>', definition.method); | |
388 }); | |
389 test('testPragma14', () { | |
390 return validate('method <foo: ()>', definition.method); | |
391 }); | |
392 test('testPragma15', () { | |
393 return validate('method <foo: #()>', definition.method); | |
394 }); | |
395 test('testPragma16', () { | |
396 return validate('method < + 1 >', definition.method); | |
397 }); | |
398 test('testPragma2', () { | |
399 return validate('method <foo> <bar>', definition.method); | |
400 }); | |
401 test('testPragma3', () { | |
402 return validate('method | a | <foo>', definition.method); | |
403 }); | |
404 test('testPragma4', () { | |
405 return validate('method <foo> | a |', definition.method); | |
406 }); | |
407 test('testPragma5', () { | |
408 return validate('method <foo> | a | <bar>', definition.method); | |
409 }); | |
410 test('testPragma6', () { | |
411 return validate('method <foo: 1>', definition.method); | |
412 }); | |
413 test('testPragma7', () { | |
414 return validate('method <foo: 1.2>', definition.method); | |
415 }); | |
416 test('testPragma8', () { | |
417 return validate('method <foo: ' 'bar' '>', definition.method); | |
418 }); | |
419 test('testPragma9', () { | |
420 return validate('method <foo: #' 'bar' '>', definition.method); | |
421 }); | |
422 } | |
OLD | NEW |