r - ast_expression_test.go
1 package r
2
3 import "testing"
4
5 func TestExpression(t *testing.T) {
6 doTests(t, []sourceFn{
7 {"if(a)b", func(t *test, tk Tokens) { // 1
8 t.Output = Expression{
9 FlowControl: &FlowControl{
10 IfControl: &IfControl{
11 Cond: WrapQuery(&SimpleExpression{
12 Identifier: &tk[2],
13 Tokens: tk[2:3],
14 }).AssignmentExpression.FormulaeExpression,
15 Expr: Expression{
16 QueryExpression: WrapQuery(&SimpleExpression{
17 Identifier: &tk[4],
18 Tokens: tk[4:5],
19 }),
20 Tokens: tk[4:5],
21 },
22 Tokens: tk[:5],
23 },
24 Tokens: tk[:5],
25 },
26 Tokens: tk[:5],
27 }
28 }},
29 {"function()a", func(t *test, tk Tokens) { // 2
30 t.Output = Expression{
31 FunctionDefinition: &FunctionDefinition{
32 ArgList: ArgList{
33 Tokens: tk[2:2],
34 },
35 Body: Expression{
36 QueryExpression: WrapQuery(&SimpleExpression{
37 Identifier: &tk[3],
38 Tokens: tk[3:4],
39 }),
40 Tokens: tk[3:4],
41 },
42 Tokens: tk[:4],
43 },
44 Tokens: tk[:4],
45 }
46 }},
47 {"a", func(t *test, tk Tokens) { // 3
48 t.Output = Expression{
49 QueryExpression: WrapQuery(&SimpleExpression{
50 Identifier: &tk[0],
51 Tokens: tk[:1],
52 }),
53 Tokens: tk[:1],
54 }
55 }},
56 {"if a", func(t *test, tk Tokens) { // 4
57 t.Err = Error{
58 Err: Error{
59 Err: Error{
60 Err: ErrMissingOpeningParen,
61 Parsing: "IfControl",
62 Token: tk[2],
63 },
64 Parsing: "FlowControl",
65 Token: tk[0],
66 },
67 Parsing: "Expression",
68 Token: tk[0],
69 }
70 }},
71 {"function a", func(t *test, tk Tokens) { // 5
72 t.Err = Error{
73 Err: Error{
74 Err: ErrMissingOpeningParen,
75 Parsing: "FunctionDefinition",
76 Token: tk[2],
77 },
78 Parsing: "Expression",
79 Token: tk[0],
80 }
81 }},
82 {"in", func(t *test, tk Tokens) { // 6
83 t.Err = Error{
84 Err: wrapQueryExpressionError(Error{
85 Err: ErrInvalidSimpleExpression,
86 Parsing: "SimpleExpression",
87 Token: tk[0],
88 }),
89 Parsing: "Expression",
90 Token: tk[0],
91 }
92 }},
93 {"#a comment\na", func(t *test, tk Tokens) { // 7
94 t.Output = Expression{
95 QueryExpression: WrapQuery(&SimpleExpression{
96 Identifier: &tk[2],
97 Tokens: tk[2:3],
98 }),
99 Comments: [2]Comments{{tk[0]}, nil},
100 Tokens: tk[:3],
101 }
102 }},
103 {"#a comment\n# Another Comment\na", func(t *test, tk Tokens) { // 8
104 t.Output = Expression{
105 QueryExpression: WrapQuery(&SimpleExpression{
106 Identifier: &tk[4],
107 Tokens: tk[4:5],
108 }),
109 Comments: [2]Comments{{tk[0], tk[2]}, nil},
110 Tokens: tk[:5],
111 }
112 }},
113 {"#a comment\na # attached comment\n#another attached", func(t *test, tk Tokens) { // 9
114 t.Output = Expression{
115 QueryExpression: WrapQuery(&SimpleExpression{
116 Identifier: &tk[2],
117 Tokens: tk[2:3],
118 }),
119 Comments: [2]Comments{{tk[0]}, {tk[4], tk[6]}},
120 Tokens: tk[:7],
121 }
122 }},
123 {"#a comment\n# Another Comment\na\n\n# not parsed", func(t *test, tk Tokens) { // 10
124 t.Output = Expression{
125 QueryExpression: WrapQuery(&SimpleExpression{
126 Identifier: &tk[4],
127 Tokens: tk[4:5],
128 }),
129 Comments: [2]Comments{{tk[0], tk[2]}, nil},
130 Tokens: tk[:5],
131 }
132 }},
133 }, func(t *test) (Type, error) {
134 var e Expression
135
136 err := e.parse(&t.Tokens)
137
138 return e, err
139 })
140 }
141
142 func TestCompoundExpression(t *testing.T) {
143 doTests(t, []sourceFn{
144 {"{a}", func(t *test, tk Tokens) { // 1
145 t.Output = CompoundExpression{
146 Expressions: []Expression{
147 {
148 QueryExpression: WrapQuery(&SimpleExpression{
149 Identifier: &tk[1],
150 Tokens: tk[1:2],
151 }),
152 Tokens: tk[1:2],
153 },
154 },
155 Tokens: tk[:3],
156 }
157 }},
158 {"{ a }", func(t *test, tk Tokens) { // 2
159 t.Output = CompoundExpression{
160 Expressions: []Expression{
161 {
162 QueryExpression: WrapQuery(&SimpleExpression{
163 Identifier: &tk[2],
164 Tokens: tk[2:3],
165 }),
166 Tokens: tk[2:3],
167 },
168 },
169 Tokens: tk[:5],
170 }
171 }},
172 {"{a;b}", func(t *test, tk Tokens) { // 3
173 t.Output = CompoundExpression{
174 Expressions: []Expression{
175 {
176 QueryExpression: WrapQuery(&SimpleExpression{
177 Identifier: &tk[1],
178 Tokens: tk[1:2],
179 }),
180 Tokens: tk[1:2],
181 },
182 {
183 QueryExpression: WrapQuery(&SimpleExpression{
184 Identifier: &tk[3],
185 Tokens: tk[3:4],
186 }),
187 Tokens: tk[3:4],
188 },
189 },
190 Tokens: tk[:5],
191 }
192 }},
193 {"{ a ; b }", func(t *test, tk Tokens) { // 4
194 t.Output = CompoundExpression{
195 Expressions: []Expression{
196 {
197 QueryExpression: WrapQuery(&SimpleExpression{
198 Identifier: &tk[2],
199 Tokens: tk[2:3],
200 }),
201 Tokens: tk[2:3],
202 },
203 {
204 QueryExpression: WrapQuery(&SimpleExpression{
205 Identifier: &tk[6],
206 Tokens: tk[6:7],
207 }),
208 Tokens: tk[6:7],
209 },
210 },
211 Tokens: tk[:9],
212 }
213 }},
214 {"{a\nb}", func(t *test, tk Tokens) { // 5
215 t.Output = CompoundExpression{
216 Expressions: []Expression{
217 {
218 QueryExpression: WrapQuery(&SimpleExpression{
219 Identifier: &tk[1],
220 Tokens: tk[1:2],
221 }),
222 Tokens: tk[1:2],
223 },
224 {
225 QueryExpression: WrapQuery(&SimpleExpression{
226 Identifier: &tk[3],
227 Tokens: tk[3:4],
228 }),
229 Tokens: tk[3:4],
230 },
231 },
232 Tokens: tk[:5],
233 }
234 }},
235 {"{\n\ta\n\tb\n}", func(t *test, tk Tokens) { // 6
236 t.Output = CompoundExpression{
237 Expressions: []Expression{
238 {
239 QueryExpression: WrapQuery(&SimpleExpression{
240 Identifier: &tk[3],
241 Tokens: tk[3:4],
242 }),
243 Tokens: tk[3:4],
244 },
245 {
246 QueryExpression: WrapQuery(&SimpleExpression{
247 Identifier: &tk[6],
248 Tokens: tk[6:7],
249 }),
250 Tokens: tk[6:7],
251 },
252 },
253 Tokens: tk[:9],
254 }
255 }},
256 {"{in}", func(t *test, tk Tokens) { // 7
257 t.Err = wrapQueryExpressionError(Error{
258 Err: ErrInvalidSimpleExpression,
259 Parsing: "SimpleExpression",
260 Token: tk[1],
261 })
262 }},
263 {"{a a}", func(t *test, tk Tokens) { // 8
264 t.Err = Error{
265 Err: ErrMissingTerminator,
266 Parsing: "CompoundExpression",
267 Token: tk[3],
268 }
269 }},
270 {"{# abc\na #def\n\n#ghi\n}", func(t *test, tk Tokens) { // 9
271 t.Output = CompoundExpression{
272 Expressions: []Expression{
273 {
274 QueryExpression: WrapQuery(&SimpleExpression{
275 Identifier: &tk[3],
276 Tokens: tk[3:4],
277 }),
278 Comments: [2]Comments{{tk[1]}, {tk[5]}},
279 Tokens: tk[1:6],
280 },
281 },
282 Comments: Comments{tk[8]},
283 Tokens: tk[:11],
284 }
285 }},
286 }, func(t *test) (Type, error) {
287 var ce CompoundExpression
288
289 err := ce.parse(&t.Tokens)
290
291 return ce, err
292 })
293 }
294
295 func TestFlowControl(t *testing.T) {
296 doTests(t, []sourceFn{
297 {"if(a)b", func(t *test, tk Tokens) { // 1
298 t.Output = FlowControl{
299 IfControl: &IfControl{
300 Cond: WrapQuery(&SimpleExpression{
301 Identifier: &tk[2],
302 Tokens: tk[2:3],
303 }).AssignmentExpression.FormulaeExpression,
304 Expr: Expression{
305 QueryExpression: WrapQuery(&SimpleExpression{
306 Identifier: &tk[4],
307 Tokens: tk[4:5],
308 }),
309 Tokens: tk[4:5],
310 },
311 Tokens: tk[:5],
312 },
313 Tokens: tk[:5],
314 }
315 }},
316 {"while(a)b", func(t *test, tk Tokens) { // 2
317 t.Output = FlowControl{
318 WhileControl: &WhileControl{
319 Cond: WrapQuery(&SimpleExpression{
320 Identifier: &tk[2],
321 Tokens: tk[2:3],
322 }).AssignmentExpression.FormulaeExpression,
323 Expr: Expression{
324 QueryExpression: WrapQuery(&SimpleExpression{
325 Identifier: &tk[4],
326 Tokens: tk[4:5],
327 }),
328 Tokens: tk[4:5],
329 },
330 Tokens: tk[:5],
331 },
332 Tokens: tk[:5],
333 }
334 }},
335 {"repeat a", func(t *test, tk Tokens) { // 3
336 t.Output = FlowControl{
337 RepeatControl: &RepeatControl{
338 Expr: Expression{
339 QueryExpression: WrapQuery(&SimpleExpression{
340 Identifier: &tk[2],
341 Tokens: tk[2:3],
342 }),
343 Tokens: tk[2:3],
344 },
345 Tokens: tk[:3],
346 },
347 Tokens: tk[:3],
348 }
349 }},
350 {"for(a in b)c", func(t *test, tk Tokens) { // 4
351 t.Output = FlowControl{
352 ForControl: &ForControl{
353 Var: &tk[2],
354 List: WrapQuery(&SimpleExpression{
355 Identifier: &tk[6],
356 Tokens: tk[6:7],
357 }).AssignmentExpression.FormulaeExpression,
358 Expr: Expression{
359 QueryExpression: WrapQuery(&SimpleExpression{
360 Identifier: &tk[8],
361 Tokens: tk[8:9],
362 }),
363 Tokens: tk[8:9],
364 },
365 Tokens: tk[:9],
366 },
367 Tokens: tk[:9],
368 }
369 }},
370 {"if a", func(t *test, tk Tokens) { // 5
371 t.Err = Error{
372 Err: Error{
373 Err: ErrMissingOpeningParen,
374 Parsing: "IfControl",
375 Token: tk[2],
376 },
377 Parsing: "FlowControl",
378 Token: tk[0],
379 }
380 }},
381 {"while a", func(t *test, tk Tokens) { // 6
382 t.Err = Error{
383 Err: Error{
384 Err: ErrMissingOpeningParen,
385 Parsing: "WhileControl",
386 Token: tk[2],
387 },
388 Parsing: "FlowControl",
389 Token: tk[0],
390 }
391 }},
392 {"repeat in", func(t *test, tk Tokens) { // 7
393 t.Err = Error{
394 Err: Error{
395 Err: Error{
396 Err: wrapQueryExpressionError(Error{
397 Err: ErrInvalidSimpleExpression,
398 Parsing: "SimpleExpression",
399 Token: tk[2],
400 }),
401 Parsing: "Expression",
402 Token: tk[2],
403 },
404 Parsing: "RepeatControl",
405 Token: tk[2],
406 },
407 Parsing: "FlowControl",
408 Token: tk[0],
409 }
410 }},
411 {"for a", func(t *test, tk Tokens) { // 8
412 t.Err = Error{
413 Err: Error{
414 Err: ErrMissingOpeningParen,
415 Parsing: "ForControl",
416 Token: tk[2],
417 },
418 Parsing: "FlowControl",
419 Token: tk[0],
420 }
421 }},
422 }, func(t *test) (Type, error) {
423 var fc FlowControl
424
425 err := fc.parse(&t.Tokens)
426
427 return fc, err
428 })
429 }
430
431 func TestIfControl(t *testing.T) {
432 doTests(t, []sourceFn{
433 {"if(a)b", func(t *test, tk Tokens) { // 1
434 t.Output = IfControl{
435 Cond: WrapQuery(&SimpleExpression{
436 Identifier: &tk[2],
437 Tokens: tk[2:3],
438 }).AssignmentExpression.FormulaeExpression,
439 Expr: Expression{
440 QueryExpression: WrapQuery(&SimpleExpression{
441 Identifier: &tk[4],
442 Tokens: tk[4:5],
443 }),
444 Tokens: tk[4:5],
445 },
446 Tokens: tk[:5],
447 }
448 }},
449 {"if ( a ) b", func(t *test, tk Tokens) { // 2
450 t.Output = IfControl{
451 Cond: WrapQuery(&SimpleExpression{
452 Identifier: &tk[4],
453 Tokens: tk[4:5],
454 }).AssignmentExpression.FormulaeExpression,
455 Expr: Expression{
456 QueryExpression: WrapQuery(&SimpleExpression{
457 Identifier: &tk[8],
458 Tokens: tk[8:9],
459 }),
460 Tokens: tk[8:9],
461 },
462 Tokens: tk[:9],
463 }
464 }},
465 {"if ( a ) b else c", func(t *test, tk Tokens) { // 3
466 t.Output = IfControl{
467 Cond: WrapQuery(&SimpleExpression{
468 Identifier: &tk[4],
469 Tokens: tk[4:5],
470 }).AssignmentExpression.FormulaeExpression,
471 Expr: Expression{
472 QueryExpression: WrapQuery(&SimpleExpression{
473 Identifier: &tk[8],
474 Tokens: tk[8:9],
475 }),
476 Tokens: tk[8:9],
477 },
478 Else: &Expression{
479 QueryExpression: WrapQuery(&SimpleExpression{
480 Identifier: &tk[12],
481 Tokens: tk[12:13],
482 }),
483 Tokens: tk[12:13],
484 },
485 Tokens: tk[:13],
486 }
487 }},
488 {"if a", func(t *test, tk Tokens) { // 4
489 t.Err = Error{
490 Err: ErrMissingOpeningParen,
491 Parsing: "IfControl",
492 Token: tk[2],
493 }
494 }},
495 {"if(in)", func(t *test, tk Tokens) { // 5
496 t.Err = Error{
497 Err: wrapQueryExpressionError(Error{
498 Err: ErrInvalidSimpleExpression,
499 Parsing: "SimpleExpression",
500 Token: tk[2],
501 }).Err.(Error).Err,
502 Parsing: "IfControl",
503 Token: tk[2],
504 }
505 }},
506 {"if(a b)", func(t *test, tk Tokens) { // 6
507 t.Err = Error{
508 Err: ErrMissingClosingParen,
509 Parsing: "IfControl",
510 Token: tk[4],
511 }
512 }},
513 {"if(a)in", func(t *test, tk Tokens) { // 7
514 t.Err = Error{
515 Err: Error{
516 Err: wrapQueryExpressionError(Error{
517 Err: ErrInvalidSimpleExpression,
518 Parsing: "SimpleExpression",
519 Token: tk[4],
520 }),
521 Parsing: "Expression",
522 Token: tk[4],
523 },
524 Parsing: "IfControl",
525 Token: tk[4],
526 }
527 }},
528 {"if(a)b else in", func(t *test, tk Tokens) { // 8
529 t.Err = Error{
530 Err: Error{
531 Err: wrapQueryExpressionError(Error{
532 Err: ErrInvalidSimpleExpression,
533 Parsing: "SimpleExpression",
534 Token: tk[8],
535 }),
536 Parsing: "Expression",
537 Token: tk[8],
538 },
539 Parsing: "IfControl",
540 Token: tk[8],
541 }
542 }},
543 {"if #abc\n(#def\na #ghi\n)#jkl\nb#mno", func(t *test, tk Tokens) { // 9
544 t.Output = IfControl{
545 Cond: WrapQuery(&SimpleExpression{
546 Identifier: &tk[7],
547 Tokens: tk[7:8],
548 }).AssignmentExpression.FormulaeExpression,
549 Expr: Expression{
550 QueryExpression: WrapQuery(&SimpleExpression{
551 Identifier: &tk[14],
552 Tokens: tk[14:15],
553 }),
554 Comments: [2]Comments{{tk[12]}, {tk[15]}},
555 Tokens: tk[12:16],
556 },
557 Comments: [4]Comments{{tk[2]}, {tk[5]}, {tk[9]}},
558 Tokens: tk[:16],
559 }
560 }},
561 {"if #abc\n(#def\na #ghi\n)#jkl\nb#mno\n\n#pqr\nelse#stu\nc#vwx", func(t *test, tk Tokens) { // 10
562 t.Output = IfControl{
563 Cond: WrapQuery(&SimpleExpression{
564 Identifier: &tk[7],
565 Tokens: tk[7:8],
566 }).AssignmentExpression.FormulaeExpression,
567 Expr: Expression{
568 QueryExpression: WrapQuery(&SimpleExpression{
569 Identifier: &tk[14],
570 Tokens: tk[14:15],
571 }),
572 Comments: [2]Comments{{tk[12]}, {tk[15]}},
573 Tokens: tk[12:16],
574 },
575 Else: &Expression{
576 QueryExpression: WrapQuery(&SimpleExpression{
577 Identifier: &tk[23],
578 Tokens: tk[23:24],
579 }),
580 Comments: [2]Comments{{tk[21]}, {tk[24]}},
581 Tokens: tk[21:25],
582 },
583 Comments: [4]Comments{{tk[2]}, {tk[5]}, {tk[9]}, {tk[18]}},
584 Tokens: tk[:25],
585 }
586 }},
587 }, func(t *test) (Type, error) {
588 var ic IfControl
589
590 err := ic.parse(&t.Tokens)
591
592 return ic, err
593 })
594 }
595
596 func TestWhileControl(t *testing.T) {
597 doTests(t, []sourceFn{
598 {"while(a)b", func(t *test, tk Tokens) { // 1
599 t.Output = WhileControl{
600 Cond: WrapQuery(&SimpleExpression{
601 Identifier: &tk[2],
602 Tokens: tk[2:3],
603 }).AssignmentExpression.FormulaeExpression,
604 Expr: Expression{
605 QueryExpression: WrapQuery(&SimpleExpression{
606 Identifier: &tk[4],
607 Tokens: tk[4:5],
608 }),
609 Tokens: tk[4:5],
610 },
611 Tokens: tk[:5],
612 }
613 }},
614 {"while ( a ) b", func(t *test, tk Tokens) { // 2
615 t.Output = WhileControl{
616 Cond: WrapQuery(&SimpleExpression{
617 Identifier: &tk[4],
618 Tokens: tk[4:5],
619 }).AssignmentExpression.FormulaeExpression,
620 Expr: Expression{
621 QueryExpression: WrapQuery(&SimpleExpression{
622 Identifier: &tk[8],
623 Tokens: tk[8:9],
624 }),
625 Tokens: tk[8:9],
626 },
627 Tokens: tk[:9],
628 }
629 }},
630 {"while a", func(t *test, tk Tokens) { // 3
631 t.Err = Error{
632 Err: ErrMissingOpeningParen,
633 Parsing: "WhileControl",
634 Token: tk[2],
635 }
636 }},
637 {"while(in)", func(t *test, tk Tokens) { // 4
638 t.Err = Error{
639 Err: wrapQueryExpressionError(Error{
640 Err: ErrInvalidSimpleExpression,
641 Parsing: "SimpleExpression",
642 Token: tk[2],
643 }).Err.(Error).Err,
644 Parsing: "WhileControl",
645 Token: tk[2],
646 }
647 }},
648 {"while(a b)", func(t *test, tk Tokens) { // 5
649 t.Err = Error{
650 Err: ErrMissingClosingParen,
651 Parsing: "WhileControl",
652 Token: tk[4],
653 }
654 }},
655 {"while(a)in", func(t *test, tk Tokens) { // 6
656 t.Err = Error{
657 Err: Error{
658 Err: wrapQueryExpressionError(Error{
659 Err: ErrInvalidSimpleExpression,
660 Parsing: "SimpleExpression",
661 Token: tk[4],
662 }),
663 Parsing: "Expression",
664 Token: tk[4],
665 },
666 Parsing: "WhileControl",
667 Token: tk[4],
668 }
669 }},
670 {"while#abc\n(#def\na#ghi\n)#jkl\nb#mno", func(t *test, tk Tokens) { // 7
671 t.Output = WhileControl{
672 Cond: WrapQuery(&SimpleExpression{
673 Identifier: &tk[6],
674 Tokens: tk[6:7],
675 }).AssignmentExpression.FormulaeExpression,
676 Expr: Expression{
677 QueryExpression: WrapQuery(&SimpleExpression{
678 Identifier: &tk[12],
679 Tokens: tk[12:13],
680 }),
681 Comments: [2]Comments{{tk[10]}, {tk[13]}},
682 Tokens: tk[10:14],
683 },
684 Comments: [3]Comments{{tk[1]}, {tk[4]}, {tk[7]}},
685 Tokens: tk[:14],
686 }
687 }},
688 }, func(t *test) (Type, error) {
689 var wc WhileControl
690
691 err := wc.parse(&t.Tokens)
692
693 return wc, err
694 })
695 }
696
697 func TestRepeatControl(t *testing.T) {
698 doTests(t, []sourceFn{
699 {"repeat a", func(t *test, tk Tokens) { // 1
700 t.Output = RepeatControl{
701 Expr: Expression{
702 QueryExpression: WrapQuery(&SimpleExpression{
703 Identifier: &tk[2],
704 Tokens: tk[2:3],
705 }),
706 Tokens: tk[2:3],
707 },
708 Tokens: tk[:3],
709 }
710 }},
711 {"repeat in", func(t *test, tk Tokens) { // 2
712 t.Err = Error{
713 Err: Error{
714 Err: wrapQueryExpressionError(Error{
715 Err: ErrInvalidSimpleExpression,
716 Parsing: "SimpleExpression",
717 Token: tk[2],
718 }),
719 Parsing: "Expression",
720 Token: tk[2],
721 },
722 Parsing: "RepeatControl",
723 Token: tk[2],
724 }
725 }},
726 {"repeat #abc\na#def", func(t *test, tk Tokens) { // 3
727 t.Output = RepeatControl{
728 Expr: Expression{
729 QueryExpression: WrapQuery(&SimpleExpression{
730 Identifier: &tk[4],
731 Tokens: tk[4:5],
732 }),
733 Comments: [2]Comments{{tk[2]}, {tk[5]}},
734 Tokens: tk[2:6],
735 },
736 Tokens: tk[:6],
737 }
738 }},
739 }, func(t *test) (Type, error) {
740 var rc RepeatControl
741
742 err := rc.parse(&t.Tokens)
743
744 return rc, err
745 })
746 }
747
748 func TestForControl(t *testing.T) {
749 doTests(t, []sourceFn{
750 {"for(a in b)c", func(t *test, tk Tokens) { // 1
751 t.Output = ForControl{
752 Var: &tk[2],
753 List: WrapQuery(&SimpleExpression{
754 Identifier: &tk[6],
755 Tokens: tk[6:7],
756 }).AssignmentExpression.FormulaeExpression,
757 Expr: Expression{
758 QueryExpression: WrapQuery(&SimpleExpression{
759 Identifier: &tk[8],
760 Tokens: tk[8:9],
761 }),
762 Tokens: tk[8:9],
763 },
764 Tokens: tk[:9],
765 }
766 }},
767 {"for(a in b) c", func(t *test, tk Tokens) { // 2
768 t.Output = ForControl{
769 Var: &tk[2],
770 List: WrapQuery(&SimpleExpression{
771 Identifier: &tk[6],
772 Tokens: tk[6:7],
773 }).AssignmentExpression.FormulaeExpression,
774 Expr: Expression{
775 QueryExpression: WrapQuery(&SimpleExpression{
776 Identifier: &tk[9],
777 Tokens: tk[9:10],
778 }),
779 Tokens: tk[9:10],
780 },
781 Tokens: tk[:10],
782 }
783 }},
784 {"for a", func(t *test, tk Tokens) { // 3
785 t.Err = Error{
786 Err: ErrMissingOpeningParen,
787 Parsing: "ForControl",
788 Token: tk[2],
789 }
790 }},
791 {"for(1)", func(t *test, tk Tokens) { // 4
792 t.Err = Error{
793 Err: ErrMissingIdentifier,
794 Parsing: "ForControl",
795 Token: tk[2],
796 }
797 }},
798 {"for(a b)", func(t *test, tk Tokens) { // 5
799 t.Err = Error{
800 Err: ErrMissingIn,
801 Parsing: "ForControl",
802 Token: tk[4],
803 }
804 }},
805 {"for(a in in)", func(t *test, tk Tokens) { // 6
806 t.Err = Error{
807 Err: wrapQueryExpressionError(Error{
808 Err: ErrInvalidSimpleExpression,
809 Parsing: "SimpleExpression",
810 Token: tk[6],
811 }).Err.(Error).Err,
812 Parsing: "ForControl",
813 Token: tk[6],
814 }
815 }},
816 {"for(a in b c)", func(t *test, tk Tokens) { // 7
817 t.Err = Error{
818 Err: ErrMissingClosingParen,
819 Parsing: "ForControl",
820 Token: tk[8],
821 }
822 }},
823 {"for(a in b)in", func(t *test, tk Tokens) { // 8
824 t.Err = Error{
825 Err: Error{
826 Err: wrapQueryExpressionError(Error{
827 Err: ErrInvalidSimpleExpression,
828 Parsing: "SimpleExpression",
829 Token: tk[8],
830 }),
831 Parsing: "Expression",
832 Token: tk[8],
833 },
834 Parsing: "ForControl",
835 Token: tk[8],
836 }
837 }},
838 {"for#abc\n(#def\na#ghi\nin#jkl\nb#mno\n)#pqr\nc#stu", func(t *test, tk Tokens) { // 9
839 t.Output = ForControl{
840 Var: &tk[6],
841 List: WrapQuery(&SimpleExpression{
842 Identifier: &tk[12],
843 Tokens: tk[12:13],
844 }).AssignmentExpression.FormulaeExpression,
845 Expr: Expression{
846 QueryExpression: WrapQuery(&SimpleExpression{
847 Identifier: &tk[18],
848 Tokens: tk[18:19],
849 }),
850 Comments: [2]Comments{{tk[16]}, {tk[19]}},
851 Tokens: tk[16:20],
852 },
853 Comments: [5]Comments{{tk[1]}, {tk[4]}, {tk[7]}, {tk[10]}, {tk[13]}},
854 Tokens: tk[:20],
855 }
856 }},
857 }, func(t *test) (Type, error) {
858 var fc ForControl
859
860 err := fc.parse(&t.Tokens)
861
862 return fc, err
863 })
864 }
865
866 func TestFunctionDefinition(t *testing.T) {
867 doTests(t, []sourceFn{
868 {"function()a", func(t *test, tk Tokens) { // 1
869 t.Output = FunctionDefinition{
870 ArgList: ArgList{
871 Tokens: tk[2:2],
872 },
873 Body: Expression{
874 QueryExpression: WrapQuery(&SimpleExpression{
875 Identifier: &tk[3],
876 Tokens: tk[3:4],
877 }),
878 Tokens: tk[3:4],
879 },
880 Tokens: tk[:4],
881 }
882 }},
883 {"function ( ) a", func(t *test, tk Tokens) { // 2
884 t.Output = FunctionDefinition{
885 ArgList: ArgList{
886 Tokens: tk[3:3],
887 },
888 Body: Expression{
889 QueryExpression: WrapQuery(&SimpleExpression{
890 Identifier: &tk[6],
891 Tokens: tk[6:7],
892 }),
893 Tokens: tk[6:7],
894 },
895 Tokens: tk[:7],
896 }
897 }},
898 {"function(a)b", func(t *test, tk Tokens) { // 3
899 t.Output = FunctionDefinition{
900 ArgList: ArgList{
901 Args: []Argument{
902 {
903 Identifier: &tk[2],
904 Tokens: tk[2:3],
905 },
906 },
907 Tokens: tk[2:3],
908 },
909 Body: Expression{
910 QueryExpression: WrapQuery(&SimpleExpression{
911 Identifier: &tk[4],
912 Tokens: tk[4:5],
913 }),
914 Tokens: tk[4:5],
915 },
916 Tokens: tk[:5],
917 }
918 }},
919 {"function(a, b){}", func(t *test, tk Tokens) { // 4
920 t.Output = FunctionDefinition{
921 ArgList: ArgList{
922 Args: []Argument{
923 {
924 Identifier: &tk[2],
925 Tokens: tk[2:3],
926 },
927 {
928 Identifier: &tk[5],
929 Tokens: tk[5:6],
930 },
931 },
932 Tokens: tk[2:6],
933 },
934 Body: Expression{
935 QueryExpression: WrapQuery(&CompoundExpression{
936 Tokens: tk[7:9],
937 }),
938 Tokens: tk[7:9],
939 },
940 Tokens: tk[:9],
941 }
942 }},
943 {"function a", func(t *test, tk Tokens) { // 5
944 t.Err = Error{
945 Err: ErrMissingOpeningParen,
946 Parsing: "FunctionDefinition",
947 Token: tk[2],
948 }
949 }},
950 {"function(in)a", func(t *test, tk Tokens) { // 6
951 t.Err = Error{
952 Err: Error{
953 Err: Error{
954 Err: ErrMissingIdentifier,
955 Parsing: "Argument",
956 Token: tk[2],
957 },
958 Parsing: "ArgList",
959 Token: tk[2],
960 },
961 Parsing: "FunctionDefinition",
962 Token: tk[2],
963 }
964 }},
965 {"function()in", func(t *test, tk Tokens) { // 7
966 t.Err = Error{
967 Err: Error{
968 Err: wrapQueryExpressionError(Error{
969 Err: ErrInvalidSimpleExpression,
970 Parsing: "SimpleExpression",
971 Token: tk[3],
972 }),
973 Parsing: "Expression",
974 Token: tk[3],
975 },
976 Parsing: "FunctionDefinition",
977 Token: tk[3],
978 }
979 }},
980 {"function(#abc\n)a", func(t *test, tk Tokens) { // 8
981 t.Output = FunctionDefinition{
982 ArgList: ArgList{
983 Comments: Comments{tk[2]},
984 Tokens: tk[2:3],
985 },
986 Body: Expression{
987 QueryExpression: WrapQuery(&SimpleExpression{
988 Identifier: &tk[5],
989 Tokens: tk[5:6],
990 }),
991 Tokens: tk[5:6],
992 },
993 Tokens: tk[:6],
994 }
995 }},
996 {"function(#abc\na #def\n)b", func(t *test, tk Tokens) { // 9
997 t.Output = FunctionDefinition{
998 ArgList: ArgList{
999 Args: []Argument{
1000 {
1001 Identifier: &tk[4],
1002 Comments: [2]Comments{{tk[2]}, {tk[6]}},
1003 Tokens: tk[2:7],
1004 },
1005 },
1006 Tokens: tk[2:7],
1007 },
1008 Body: Expression{
1009 QueryExpression: WrapQuery(&SimpleExpression{
1010 Identifier: &tk[9],
1011 Tokens: tk[9:10],
1012 }),
1013 Tokens: tk[9:10],
1014 },
1015 Tokens: tk[:10],
1016 }
1017 }},
1018 {"function(#abc\na #def\n, #ghi\nb #jkl\n)c", func(t *test, tk Tokens) { // 10
1019 t.Output = FunctionDefinition{
1020 ArgList: ArgList{
1021 Args: []Argument{
1022 {
1023 Identifier: &tk[4],
1024 Comments: [2]Comments{{tk[2]}, {tk[6]}},
1025 Tokens: tk[2:7],
1026 },
1027 {
1028 Identifier: &tk[12],
1029 Comments: [2]Comments{{tk[10]}, {tk[14]}},
1030 Tokens: tk[10:15],
1031 },
1032 },
1033 Tokens: tk[2:15],
1034 },
1035 Body: Expression{
1036 QueryExpression: WrapQuery(&SimpleExpression{
1037 Identifier: &tk[17],
1038 Tokens: tk[17:18],
1039 }),
1040 Tokens: tk[17:18],
1041 },
1042 Tokens: tk[:18],
1043 }
1044 }},
1045 {"function(#abc\na #def\n = #ghi\nb#jkl\n)c", func(t *test, tk Tokens) { // 11
1046 t.Output = FunctionDefinition{
1047 ArgList: ArgList{
1048 Args: []Argument{
1049 {
1050 Identifier: &tk[4],
1051 Default: &Expression{
1052 QueryExpression: WrapQuery(&SimpleExpression{
1053 Identifier: &tk[13],
1054 Tokens: tk[13:14],
1055 }),
1056 Comments: [2]Comments{{tk[11]}, {tk[14]}},
1057 Tokens: tk[11:15],
1058 },
1059 Comments: [2]Comments{{tk[2]}, {tk[6]}},
1060 Tokens: tk[2:15],
1061 },
1062 },
1063 Tokens: tk[2:15],
1064 },
1065 Body: Expression{
1066 QueryExpression: WrapQuery(&SimpleExpression{
1067 Identifier: &tk[17],
1068 Tokens: tk[17:18],
1069 }),
1070 Tokens: tk[17:18],
1071 },
1072 Tokens: tk[:18],
1073 }
1074 }},
1075 {"function #abc\n()a", func(t *test, tk Tokens) { // 12
1076 t.Output = FunctionDefinition{
1077 ArgList: ArgList{
1078 Tokens: tk[5:5],
1079 },
1080 Body: Expression{
1081 QueryExpression: WrapQuery(&SimpleExpression{
1082 Identifier: &tk[6],
1083 Tokens: tk[6:7],
1084 }),
1085 Tokens: tk[6:7],
1086 },
1087 Comments: Comments{tk[2]},
1088 Tokens: tk[:7],
1089 }
1090 }},
1091 }, func(t *test) (Type, error) {
1092 var fd FunctionDefinition
1093
1094 err := fd.parse(&t.Tokens)
1095
1096 return fd, err
1097 })
1098 }
1099
1100 func TestArgList(t *testing.T) {
1101 doTests(t, []sourceFn{
1102 {"a", func(t *test, tk Tokens) { // 1
1103 t.Output = ArgList{
1104 Args: []Argument{
1105 {
1106 Identifier: &tk[0],
1107 Tokens: tk[:1],
1108 },
1109 },
1110 Tokens: tk[:1],
1111 }
1112 }},
1113 {"a,b", func(t *test, tk Tokens) { // 2
1114 t.Output = ArgList{
1115 Args: []Argument{
1116 {
1117 Identifier: &tk[0],
1118 Tokens: tk[:1],
1119 },
1120 {
1121 Identifier: &tk[2],
1122 Tokens: tk[2:3],
1123 },
1124 },
1125 Tokens: tk[:3],
1126 }
1127 }},
1128 {"a , b", func(t *test, tk Tokens) { // 3
1129 t.Output = ArgList{
1130 Args: []Argument{
1131 {
1132 Identifier: &tk[0],
1133 Tokens: tk[:1],
1134 },
1135 {
1136 Identifier: &tk[4],
1137 Tokens: tk[4:5],
1138 },
1139 },
1140 Tokens: tk[:5],
1141 }
1142 }},
1143 {"a, b, c", func(t *test, tk Tokens) { // 4
1144 t.Output = ArgList{
1145 Args: []Argument{
1146 {
1147 Identifier: &tk[0],
1148 Tokens: tk[:1],
1149 },
1150 {
1151 Identifier: &tk[3],
1152 Tokens: tk[3:4],
1153 },
1154 {
1155 Identifier: &tk[6],
1156 Tokens: tk[6:7],
1157 },
1158 },
1159 Tokens: tk[:7],
1160 }
1161 }},
1162 {"", func(t *test, tk Tokens) { // 5
1163 t.Output = ArgList{
1164 Tokens: tk[:0],
1165 }
1166 }},
1167 {"in", func(t *test, tk Tokens) { // 6
1168 t.Err = Error{
1169 Err: Error{
1170 Err: ErrMissingIdentifier,
1171 Parsing: "Argument",
1172 Token: tk[0],
1173 },
1174 Parsing: "ArgList",
1175 Token: tk[0],
1176 }
1177 }},
1178 {"a b", func(t *test, tk Tokens) { // 7
1179 t.Err = Error{
1180 Err: ErrMissingTerminator,
1181 Parsing: "ArgList",
1182 Token: tk[2],
1183 }
1184 }},
1185 {"#abc", func(t *test, tk Tokens) { // 8
1186 t.Output = ArgList{
1187 Comments: Comments{tk[0]},
1188 Tokens: tk[:1],
1189 }
1190 }},
1191 {"#abc\n\n#def", func(t *test, tk Tokens) { // 9
1192 t.Output = ArgList{
1193 Comments: Comments{tk[0], tk[3]},
1194 Tokens: tk[:4],
1195 }
1196 }},
1197 }, func(t *test) (Type, error) {
1198 var al ArgList
1199
1200 err := al.parse(&t.Tokens)
1201
1202 return al, err
1203 })
1204 }
1205
1206 func TestArgument(t *testing.T) {
1207 doTests(t, []sourceFn{
1208 {"a", func(t *test, tk Tokens) { // 1
1209 t.Output = Argument{
1210 Identifier: &tk[0],
1211 Tokens: tk[:1],
1212 }
1213 }},
1214 {"a=b", func(t *test, tk Tokens) { // 2
1215 t.Output = Argument{
1216 Identifier: &tk[0],
1217 Default: &Expression{
1218 QueryExpression: WrapQuery(&SimpleExpression{
1219 Identifier: &tk[2],
1220 Tokens: tk[2:3],
1221 }),
1222 Tokens: tk[2:3],
1223 },
1224 Tokens: tk[:3],
1225 }
1226 }},
1227 {"a = b", func(t *test, tk Tokens) { // 3
1228 t.Output = Argument{
1229 Identifier: &tk[0],
1230 Default: &Expression{
1231 QueryExpression: WrapQuery(&SimpleExpression{
1232 Identifier: &tk[4],
1233 Tokens: tk[4:5],
1234 }),
1235 Tokens: tk[4:5],
1236 },
1237 Tokens: tk[:5],
1238 }
1239 }},
1240 {"...", func(t *test, tk Tokens) { // 4
1241 t.Output = Argument{
1242 Identifier: &tk[0],
1243 Tokens: tk[:1],
1244 }
1245 }},
1246 {"in", func(t *test, tk Tokens) { // 5
1247 t.Err = Error{
1248 Err: ErrMissingIdentifier,
1249 Parsing: "Argument",
1250 Token: tk[0],
1251 }
1252 }},
1253 {"a=in", func(t *test, tk Tokens) { // 6
1254 t.Err = Error{
1255 Err: Error{
1256 Err: wrapQueryExpressionError(Error{
1257 Err: ErrInvalidSimpleExpression,
1258 Parsing: "SimpleExpression",
1259 Token: tk[2],
1260 }),
1261 Parsing: "Expression",
1262 Token: tk[2],
1263 },
1264 Parsing: "Argument",
1265 Token: tk[2],
1266 }
1267 }},
1268 {"#abc\na\n#def", func(t *test, tk Tokens) { // 7
1269 t.Output = Argument{
1270 Identifier: &tk[2],
1271 Comments: [2]Comments{{tk[0]}, {tk[4]}},
1272 Tokens: tk[:5],
1273 }
1274 }},
1275 {"#abc\na #def\n#ghi\n= #jkl\nb #mno", func(t *test, tk Tokens) { // 8
1276 t.Output = Argument{
1277 Identifier: &tk[2],
1278 Default: &Expression{
1279 QueryExpression: WrapQuery(&SimpleExpression{
1280 Identifier: &tk[12],
1281 Tokens: tk[12:13],
1282 }),
1283 Comments: [2]Comments{{tk[10]}, {tk[14]}},
1284 Tokens: tk[10:15],
1285 },
1286 Comments: [2]Comments{{tk[0]}, {tk[4], tk[6]}},
1287 Tokens: tk[:15],
1288 }
1289 }},
1290 }, func(t *test) (Type, error) {
1291 var a Argument
1292
1293 err := a.parse(&t.Tokens)
1294
1295 return a, err
1296 })
1297 }
1298
1299 func TestQueryExpression(t *testing.T) {
1300 doTests(t, []sourceFn{
1301 {"a", func(t *test, tk Tokens) { // 1
1302 t.Output = QueryExpression{
1303 AssignmentExpression: &AssignmentExpression{
1304 FormulaeExpression: FormulaeExpression{
1305 OrExpression: &OrExpression{
1306 AndExpression: AndExpression{
1307 NotExpression: NotExpression{
1308 RelationalExpression: RelationalExpression{
1309 AdditionExpression: AdditionExpression{
1310 MultiplicationExpression: MultiplicationExpression{
1311 PipeOrSpecialExpression: PipeOrSpecialExpression{
1312 SequenceExpression: SequenceExpression{
1313 UnaryExpression: UnaryExpression{
1314 ExponentiationExpression: ExponentiationExpression{
1315 SubsetExpression: SubsetExpression{
1316 ScopeExpression: ScopeExpression{
1317 IndexOrCallExpression: IndexOrCallExpression{
1318 SimpleExpression: &SimpleExpression{
1319 Identifier: &tk[0],
1320 Tokens: tk[:1],
1321 },
1322 Tokens: tk[:1],
1323 },
1324 Tokens: tk[:1],
1325 },
1326 Tokens: tk[:1],
1327 },
1328 Tokens: tk[:1],
1329 },
1330 Tokens: tk[:1],
1331 },
1332 Tokens: tk[:1],
1333 },
1334 Tokens: tk[:1],
1335 },
1336 Tokens: tk[:1],
1337 },
1338 Tokens: tk[:1],
1339 },
1340 Tokens: tk[:1],
1341 },
1342 Tokens: tk[:1],
1343 },
1344 Tokens: tk[:1],
1345 },
1346 Tokens: tk[:1],
1347 },
1348 Tokens: tk[:1],
1349 },
1350 Tokens: tk[:1],
1351 },
1352 Tokens: tk[:1],
1353 }
1354 }},
1355 {"?a", func(t *test, tk Tokens) { // 2
1356 t.Output = QueryExpression{
1357 QueryExpression: &QueryExpression{
1358 AssignmentExpression: &AssignmentExpression{
1359 FormulaeExpression: FormulaeExpression{
1360 OrExpression: &OrExpression{
1361 AndExpression: AndExpression{
1362 NotExpression: NotExpression{
1363 RelationalExpression: RelationalExpression{
1364 AdditionExpression: AdditionExpression{
1365 MultiplicationExpression: MultiplicationExpression{
1366 PipeOrSpecialExpression: PipeOrSpecialExpression{
1367 SequenceExpression: SequenceExpression{
1368 UnaryExpression: UnaryExpression{
1369 ExponentiationExpression: ExponentiationExpression{
1370 SubsetExpression: SubsetExpression{
1371 ScopeExpression: ScopeExpression{
1372 IndexOrCallExpression: IndexOrCallExpression{
1373 SimpleExpression: &SimpleExpression{
1374 Identifier: &tk[1],
1375 Tokens: tk[1:2],
1376 },
1377 Tokens: tk[1:2],
1378 },
1379 Tokens: tk[1:2],
1380 },
1381 Tokens: tk[1:2],
1382 },
1383 Tokens: tk[1:2],
1384 },
1385 Tokens: tk[1:2],
1386 },
1387 Tokens: tk[1:2],
1388 },
1389 Tokens: tk[1:2],
1390 },
1391 Tokens: tk[1:2],
1392 },
1393 Tokens: tk[1:2],
1394 },
1395 Tokens: tk[1:2],
1396 },
1397 Tokens: tk[1:2],
1398 },
1399 Tokens: tk[1:2],
1400 },
1401 Tokens: tk[1:2],
1402 },
1403 Tokens: tk[1:2],
1404 },
1405 Tokens: tk[1:2],
1406 },
1407 Tokens: tk[1:2],
1408 },
1409 Tokens: tk[:2],
1410 }
1411 }},
1412 {"? a", func(t *test, tk Tokens) { // 3
1413 t.Output = QueryExpression{
1414 QueryExpression: &QueryExpression{
1415 AssignmentExpression: &AssignmentExpression{
1416 FormulaeExpression: FormulaeExpression{
1417 OrExpression: &OrExpression{
1418 AndExpression: AndExpression{
1419 NotExpression: NotExpression{
1420 RelationalExpression: RelationalExpression{
1421 AdditionExpression: AdditionExpression{
1422 MultiplicationExpression: MultiplicationExpression{
1423 PipeOrSpecialExpression: PipeOrSpecialExpression{
1424 SequenceExpression: SequenceExpression{
1425 UnaryExpression: UnaryExpression{
1426 ExponentiationExpression: ExponentiationExpression{
1427 SubsetExpression: SubsetExpression{
1428 ScopeExpression: ScopeExpression{
1429 IndexOrCallExpression: IndexOrCallExpression{
1430 SimpleExpression: &SimpleExpression{
1431 Identifier: &tk[2],
1432 Tokens: tk[2:3],
1433 },
1434 Tokens: tk[2:3],
1435 },
1436 Tokens: tk[2:3],
1437 },
1438 Tokens: tk[2:3],
1439 },
1440 Tokens: tk[2:3],
1441 },
1442 Tokens: tk[2:3],
1443 },
1444 Tokens: tk[2:3],
1445 },
1446 Tokens: tk[2:3],
1447 },
1448 Tokens: tk[2:3],
1449 },
1450 Tokens: tk[2:3],
1451 },
1452 Tokens: tk[2:3],
1453 },
1454 Tokens: tk[2:3],
1455 },
1456 Tokens: tk[2:3],
1457 },
1458 Tokens: tk[2:3],
1459 },
1460 Tokens: tk[2:3],
1461 },
1462 Tokens: tk[2:3],
1463 },
1464 Tokens: tk[2:3],
1465 },
1466 Tokens: tk[:3],
1467 }
1468 }},
1469 {"a?b", func(t *test, tk Tokens) { // 4
1470 t.Output = QueryExpression{
1471 AssignmentExpression: &AssignmentExpression{
1472 FormulaeExpression: FormulaeExpression{
1473 OrExpression: &OrExpression{
1474 AndExpression: AndExpression{
1475 NotExpression: NotExpression{
1476 RelationalExpression: RelationalExpression{
1477 AdditionExpression: AdditionExpression{
1478 MultiplicationExpression: MultiplicationExpression{
1479 PipeOrSpecialExpression: PipeOrSpecialExpression{
1480 SequenceExpression: SequenceExpression{
1481 UnaryExpression: UnaryExpression{
1482 ExponentiationExpression: ExponentiationExpression{
1483 SubsetExpression: SubsetExpression{
1484 ScopeExpression: ScopeExpression{
1485 IndexOrCallExpression: IndexOrCallExpression{
1486 SimpleExpression: &SimpleExpression{
1487 Identifier: &tk[0],
1488 Tokens: tk[:1],
1489 },
1490 Tokens: tk[:1],
1491 },
1492 Tokens: tk[:1],
1493 },
1494 Tokens: tk[:1],
1495 },
1496 Tokens: tk[:1],
1497 },
1498 Tokens: tk[:1],
1499 },
1500 Tokens: tk[:1],
1501 },
1502 Tokens: tk[:1],
1503 },
1504 Tokens: tk[:1],
1505 },
1506 Tokens: tk[:1],
1507 },
1508 Tokens: tk[:1],
1509 },
1510 Tokens: tk[:1],
1511 },
1512 Tokens: tk[:1],
1513 },
1514 Tokens: tk[:1],
1515 },
1516 Tokens: tk[:1],
1517 },
1518 Tokens: tk[:1],
1519 },
1520 QueryExpression: &QueryExpression{
1521 AssignmentExpression: &AssignmentExpression{
1522 FormulaeExpression: FormulaeExpression{
1523 OrExpression: &OrExpression{
1524 AndExpression: AndExpression{
1525 NotExpression: NotExpression{
1526 RelationalExpression: RelationalExpression{
1527 AdditionExpression: AdditionExpression{
1528 MultiplicationExpression: MultiplicationExpression{
1529 PipeOrSpecialExpression: PipeOrSpecialExpression{
1530 SequenceExpression: SequenceExpression{
1531 UnaryExpression: UnaryExpression{
1532 ExponentiationExpression: ExponentiationExpression{
1533 SubsetExpression: SubsetExpression{
1534 ScopeExpression: ScopeExpression{
1535 IndexOrCallExpression: IndexOrCallExpression{
1536 SimpleExpression: &SimpleExpression{
1537 Identifier: &tk[2],
1538 Tokens: tk[2:3],
1539 },
1540 Tokens: tk[2:3],
1541 },
1542 Tokens: tk[2:3],
1543 },
1544 Tokens: tk[2:3],
1545 },
1546 Tokens: tk[2:3],
1547 },
1548 Tokens: tk[2:3],
1549 },
1550 Tokens: tk[2:3],
1551 },
1552 Tokens: tk[2:3],
1553 },
1554 Tokens: tk[2:3],
1555 },
1556 Tokens: tk[2:3],
1557 },
1558 Tokens: tk[2:3],
1559 },
1560 Tokens: tk[2:3],
1561 },
1562 Tokens: tk[2:3],
1563 },
1564 Tokens: tk[2:3],
1565 },
1566 Tokens: tk[2:3],
1567 },
1568 Tokens: tk[2:3],
1569 },
1570 Tokens: tk[2:3],
1571 },
1572 Tokens: tk[:3],
1573 }
1574 }},
1575 {"a ? b", func(t *test, tk Tokens) { // 5
1576 t.Output = QueryExpression{
1577 AssignmentExpression: &AssignmentExpression{
1578 FormulaeExpression: FormulaeExpression{
1579 OrExpression: &OrExpression{
1580 AndExpression: AndExpression{
1581 NotExpression: NotExpression{
1582 RelationalExpression: RelationalExpression{
1583 AdditionExpression: AdditionExpression{
1584 MultiplicationExpression: MultiplicationExpression{
1585 PipeOrSpecialExpression: PipeOrSpecialExpression{
1586 SequenceExpression: SequenceExpression{
1587 UnaryExpression: UnaryExpression{
1588 ExponentiationExpression: ExponentiationExpression{
1589 SubsetExpression: SubsetExpression{
1590 ScopeExpression: ScopeExpression{
1591 IndexOrCallExpression: IndexOrCallExpression{
1592 SimpleExpression: &SimpleExpression{
1593 Identifier: &tk[0],
1594 Tokens: tk[:1],
1595 },
1596 Tokens: tk[:1],
1597 },
1598 Tokens: tk[:1],
1599 },
1600 Tokens: tk[:1],
1601 },
1602 Tokens: tk[:1],
1603 },
1604 Tokens: tk[:1],
1605 },
1606 Tokens: tk[:1],
1607 },
1608 Tokens: tk[:1],
1609 },
1610 Tokens: tk[:1],
1611 },
1612 Tokens: tk[:1],
1613 },
1614 Tokens: tk[:1],
1615 },
1616 Tokens: tk[:1],
1617 },
1618 Tokens: tk[:1],
1619 },
1620 Tokens: tk[:1],
1621 },
1622 Tokens: tk[:1],
1623 },
1624 Tokens: tk[:1],
1625 },
1626 QueryExpression: &QueryExpression{
1627 AssignmentExpression: &AssignmentExpression{
1628 FormulaeExpression: FormulaeExpression{
1629 OrExpression: &OrExpression{
1630 AndExpression: AndExpression{
1631 NotExpression: NotExpression{
1632 RelationalExpression: RelationalExpression{
1633 AdditionExpression: AdditionExpression{
1634 MultiplicationExpression: MultiplicationExpression{
1635 PipeOrSpecialExpression: PipeOrSpecialExpression{
1636 SequenceExpression: SequenceExpression{
1637 UnaryExpression: UnaryExpression{
1638 ExponentiationExpression: ExponentiationExpression{
1639 SubsetExpression: SubsetExpression{
1640 ScopeExpression: ScopeExpression{
1641 IndexOrCallExpression: IndexOrCallExpression{
1642 SimpleExpression: &SimpleExpression{
1643 Identifier: &tk[4],
1644 Tokens: tk[4:5],
1645 },
1646 Tokens: tk[4:5],
1647 },
1648 Tokens: tk[4:5],
1649 },
1650 Tokens: tk[4:5],
1651 },
1652 Tokens: tk[4:5],
1653 },
1654 Tokens: tk[4:5],
1655 },
1656 Tokens: tk[4:5],
1657 },
1658 Tokens: tk[4:5],
1659 },
1660 Tokens: tk[4:5],
1661 },
1662 Tokens: tk[4:5],
1663 },
1664 Tokens: tk[4:5],
1665 },
1666 Tokens: tk[4:5],
1667 },
1668 Tokens: tk[4:5],
1669 },
1670 Tokens: tk[4:5],
1671 },
1672 Tokens: tk[4:5],
1673 },
1674 Tokens: tk[4:5],
1675 },
1676 Tokens: tk[4:5],
1677 },
1678 Tokens: tk[:5],
1679 }
1680 }},
1681 {"in", func(t *test, tk Tokens) { // 6
1682 t.Err = Error{
1683 Err: Error{
1684 Err: Error{
1685 Err: Error{
1686 Err: Error{
1687 Err: Error{
1688 Err: Error{
1689 Err: Error{
1690 Err: Error{
1691 Err: Error{
1692 Err: Error{
1693 Err: Error{
1694 Err: Error{
1695 Err: Error{
1696 Err: Error{
1697 Err: Error{
1698 Err: Error{
1699 Err: ErrInvalidSimpleExpression,
1700 Parsing: "SimpleExpression",
1701 Token: tk[0],
1702 },
1703 Parsing: "IndexOrCallExpression",
1704 Token: tk[0],
1705 },
1706 Parsing: "ScopeExpression",
1707 Token: tk[0],
1708 },
1709 Parsing: "SubsetExpression",
1710 Token: tk[0],
1711 },
1712 Parsing: "ExponentiationExpression",
1713 Token: tk[0],
1714 },
1715 Parsing: "UnaryExpression",
1716 Token: tk[0],
1717 },
1718 Parsing: "SequenceExpression",
1719 Token: tk[0],
1720 },
1721 Parsing: "PipeOrSpecialExpression",
1722 Token: tk[0],
1723 },
1724 Parsing: "MultiplicationExpression",
1725 Token: tk[0],
1726 },
1727 Parsing: "AdditionExpression",
1728 Token: tk[0],
1729 },
1730 Parsing: "RelationalExpression",
1731 Token: tk[0],
1732 },
1733 Parsing: "NotExpression",
1734 Token: tk[0],
1735 },
1736 Parsing: "AndExpression",
1737 Token: tk[0],
1738 },
1739 Parsing: "OrExpression",
1740 Token: tk[0],
1741 },
1742 Parsing: "FormulaeExpression",
1743 Token: tk[0],
1744 },
1745 Parsing: "AssignmentExpression",
1746 Token: tk[0],
1747 },
1748 Parsing: "QueryExpression",
1749 Token: tk[0],
1750 }
1751 }},
1752 {"?in", func(t *test, tk Tokens) { // 7
1753 t.Err = Error{
1754 Err: Error{
1755 Err: Error{
1756 Err: Error{
1757 Err: Error{
1758 Err: Error{
1759 Err: Error{
1760 Err: Error{
1761 Err: Error{
1762 Err: Error{
1763 Err: Error{
1764 Err: Error{
1765 Err: Error{
1766 Err: Error{
1767 Err: Error{
1768 Err: Error{
1769 Err: Error{
1770 Err: ErrInvalidSimpleExpression,
1771 Parsing: "SimpleExpression",
1772 Token: tk[1],
1773 },
1774 Parsing: "IndexOrCallExpression",
1775 Token: tk[1],
1776 },
1777 Parsing: "ScopeExpression",
1778 Token: tk[1],
1779 },
1780 Parsing: "SubsetExpression",
1781 Token: tk[1],
1782 },
1783 Parsing: "ExponentiationExpression",
1784 Token: tk[1],
1785 },
1786 Parsing: "UnaryExpression",
1787 Token: tk[1],
1788 },
1789 Parsing: "SequenceExpression",
1790 Token: tk[1],
1791 },
1792 Parsing: "PipeOrSpecialExpression",
1793 Token: tk[1],
1794 },
1795 Parsing: "MultiplicationExpression",
1796 Token: tk[1],
1797 },
1798 Parsing: "AdditionExpression",
1799 Token: tk[1],
1800 },
1801 Parsing: "RelationalExpression",
1802 Token: tk[1],
1803 },
1804 Parsing: "NotExpression",
1805 Token: tk[1],
1806 },
1807 Parsing: "AndExpression",
1808 Token: tk[1],
1809 },
1810 Parsing: "OrExpression",
1811 Token: tk[1],
1812 },
1813 Parsing: "FormulaeExpression",
1814 Token: tk[1],
1815 },
1816 Parsing: "AssignmentExpression",
1817 Token: tk[1],
1818 },
1819 Parsing: "QueryExpression",
1820 Token: tk[1],
1821 }
1822 }},
1823 {"a?in", func(t *test, tk Tokens) { // 8
1824 t.Err = Error{
1825 Err: Error{
1826 Err: Error{
1827 Err: Error{
1828 Err: Error{
1829 Err: Error{
1830 Err: Error{
1831 Err: Error{
1832 Err: Error{
1833 Err: Error{
1834 Err: Error{
1835 Err: Error{
1836 Err: Error{
1837 Err: Error{
1838 Err: Error{
1839 Err: Error{
1840 Err: Error{
1841 Err: Error{
1842 Err: ErrInvalidSimpleExpression,
1843 Parsing: "SimpleExpression",
1844 Token: tk[2],
1845 },
1846 Parsing: "IndexOrCallExpression",
1847 Token: tk[2],
1848 },
1849 Parsing: "ScopeExpression",
1850 Token: tk[2],
1851 },
1852 Parsing: "SubsetExpression",
1853 Token: tk[2],
1854 },
1855 Parsing: "ExponentiationExpression",
1856 Token: tk[2],
1857 },
1858 Parsing: "UnaryExpression",
1859 Token: tk[2],
1860 },
1861 Parsing: "SequenceExpression",
1862 Token: tk[2],
1863 },
1864 Parsing: "PipeOrSpecialExpression",
1865 Token: tk[2],
1866 },
1867 Parsing: "MultiplicationExpression",
1868 Token: tk[2],
1869 },
1870 Parsing: "AdditionExpression",
1871 Token: tk[2],
1872 },
1873 Parsing: "RelationalExpression",
1874 Token: tk[2],
1875 },
1876 Parsing: "NotExpression",
1877 Token: tk[2],
1878 },
1879 Parsing: "AndExpression",
1880 Token: tk[2],
1881 },
1882 Parsing: "OrExpression",
1883 Token: tk[2],
1884 },
1885 Parsing: "FormulaeExpression",
1886 Token: tk[2],
1887 },
1888 Parsing: "AssignmentExpression",
1889 Token: tk[2],
1890 },
1891 Parsing: "QueryExpression",
1892 Token: tk[2],
1893 },
1894 Parsing: "QueryExpression",
1895 Token: tk[2],
1896 }
1897 }},
1898 {"?#abc\na", func(t *test, tk Tokens) { // 9
1899 t.Output = QueryExpression{
1900 QueryExpression: WrapQuery(&SimpleExpression{
1901 Identifier: &tk[3],
1902 Tokens: tk[3:4],
1903 }),
1904 Comments: [2]Comments{nil, {tk[1]}},
1905 Tokens: tk[:4],
1906 }
1907 }},
1908 {"a?#abc\na", func(t *test, tk Tokens) { // 10
1909 t.Output = QueryExpression{
1910 AssignmentExpression: WrapQuery(&SimpleExpression{
1911 Identifier: &tk[0],
1912 Tokens: tk[:1],
1913 }).AssignmentExpression,
1914 QueryExpression: WrapQuery(&SimpleExpression{
1915 Identifier: &tk[4],
1916 Tokens: tk[4:5],
1917 }),
1918 Comments: [2]Comments{nil, {tk[2]}},
1919 Tokens: tk[:5],
1920 }
1921 }},
1922 {"a#abc\n?#def\na", func(t *test, tk Tokens) { // 11
1923 t.Output = QueryExpression{
1924 AssignmentExpression: WrapQuery(&SimpleExpression{
1925 Identifier: &tk[0],
1926 Tokens: tk[:1],
1927 }).AssignmentExpression,
1928 Tokens: tk[:1],
1929 }
1930 }},
1931 }, func(t *test) (Type, error) {
1932 var qe QueryExpression
1933
1934 err := qe.parse(&t.Tokens)
1935
1936 return qe, err
1937 })
1938 }
1939
1940 func TestAssignmentExpression(t *testing.T) {
1941 doTests(t, []sourceFn{
1942 {"a", func(t *test, tk Tokens) { // 1
1943 t.Output = AssignmentExpression{
1944 FormulaeExpression: FormulaeExpression{
1945 OrExpression: &OrExpression{
1946 AndExpression: AndExpression{
1947 NotExpression: NotExpression{
1948 RelationalExpression: RelationalExpression{
1949 AdditionExpression: AdditionExpression{
1950 MultiplicationExpression: MultiplicationExpression{
1951 PipeOrSpecialExpression: PipeOrSpecialExpression{
1952 SequenceExpression: SequenceExpression{
1953 UnaryExpression: UnaryExpression{
1954 ExponentiationExpression: ExponentiationExpression{
1955 SubsetExpression: SubsetExpression{
1956 ScopeExpression: ScopeExpression{
1957 IndexOrCallExpression: IndexOrCallExpression{
1958 SimpleExpression: &SimpleExpression{
1959 Identifier: &tk[0],
1960 Tokens: tk[:1],
1961 },
1962 Tokens: tk[:1],
1963 },
1964 Tokens: tk[:1],
1965 },
1966 Tokens: tk[:1],
1967 },
1968 Tokens: tk[:1],
1969 },
1970 Tokens: tk[:1],
1971 },
1972 Tokens: tk[:1],
1973 },
1974 Tokens: tk[:1],
1975 },
1976 Tokens: tk[:1],
1977 },
1978 Tokens: tk[:1],
1979 },
1980 Tokens: tk[:1],
1981 },
1982 Tokens: tk[:1],
1983 },
1984 Tokens: tk[:1],
1985 },
1986 Tokens: tk[:1],
1987 },
1988 Tokens: tk[:1],
1989 },
1990 Tokens: tk[:1],
1991 }
1992 }},
1993 {"a=b", func(t *test, tk Tokens) { // 2
1994 t.Output = AssignmentExpression{
1995 FormulaeExpression: FormulaeExpression{
1996 OrExpression: &OrExpression{
1997 AndExpression: AndExpression{
1998 NotExpression: NotExpression{
1999 RelationalExpression: RelationalExpression{
2000 AdditionExpression: AdditionExpression{
2001 MultiplicationExpression: MultiplicationExpression{
2002 PipeOrSpecialExpression: PipeOrSpecialExpression{
2003 SequenceExpression: SequenceExpression{
2004 UnaryExpression: UnaryExpression{
2005 ExponentiationExpression: ExponentiationExpression{
2006 SubsetExpression: SubsetExpression{
2007 ScopeExpression: ScopeExpression{
2008 IndexOrCallExpression: IndexOrCallExpression{
2009 SimpleExpression: &SimpleExpression{
2010 Identifier: &tk[0],
2011 Tokens: tk[:1],
2012 },
2013 Tokens: tk[:1],
2014 },
2015 Tokens: tk[:1],
2016 },
2017 Tokens: tk[:1],
2018 },
2019 Tokens: tk[:1],
2020 },
2021 Tokens: tk[:1],
2022 },
2023 Tokens: tk[:1],
2024 },
2025 Tokens: tk[:1],
2026 },
2027 Tokens: tk[:1],
2028 },
2029 Tokens: tk[:1],
2030 },
2031 Tokens: tk[:1],
2032 },
2033 Tokens: tk[:1],
2034 },
2035 Tokens: tk[:1],
2036 },
2037 Tokens: tk[:1],
2038 },
2039 Tokens: tk[:1],
2040 },
2041 AssignmentType: AssignmentEquals,
2042 AssignmentExpression: &AssignmentExpression{
2043 FormulaeExpression: FormulaeExpression{
2044 OrExpression: &OrExpression{
2045 AndExpression: AndExpression{
2046 NotExpression: NotExpression{
2047 RelationalExpression: RelationalExpression{
2048 AdditionExpression: AdditionExpression{
2049 MultiplicationExpression: MultiplicationExpression{
2050 PipeOrSpecialExpression: PipeOrSpecialExpression{
2051 SequenceExpression: SequenceExpression{
2052 UnaryExpression: UnaryExpression{
2053 ExponentiationExpression: ExponentiationExpression{
2054 SubsetExpression: SubsetExpression{
2055 ScopeExpression: ScopeExpression{
2056 IndexOrCallExpression: IndexOrCallExpression{
2057 SimpleExpression: &SimpleExpression{
2058 Identifier: &tk[2],
2059 Tokens: tk[2:3],
2060 },
2061 Tokens: tk[2:3],
2062 },
2063 Tokens: tk[2:3],
2064 },
2065 Tokens: tk[2:3],
2066 },
2067 Tokens: tk[2:3],
2068 },
2069 Tokens: tk[2:3],
2070 },
2071 Tokens: tk[2:3],
2072 },
2073 Tokens: tk[2:3],
2074 },
2075 Tokens: tk[2:3],
2076 },
2077 Tokens: tk[2:3],
2078 },
2079 Tokens: tk[2:3],
2080 },
2081 Tokens: tk[2:3],
2082 },
2083 Tokens: tk[2:3],
2084 },
2085 Tokens: tk[2:3],
2086 },
2087 Tokens: tk[2:3],
2088 },
2089 Tokens: tk[2:3],
2090 },
2091 Tokens: tk[:3],
2092 }
2093 }},
2094 {"a = b", func(t *test, tk Tokens) { // 3
2095 t.Output = AssignmentExpression{
2096 FormulaeExpression: FormulaeExpression{
2097 OrExpression: &OrExpression{
2098 AndExpression: AndExpression{
2099 NotExpression: NotExpression{
2100 RelationalExpression: RelationalExpression{
2101 AdditionExpression: AdditionExpression{
2102 MultiplicationExpression: MultiplicationExpression{
2103 PipeOrSpecialExpression: PipeOrSpecialExpression{
2104 SequenceExpression: SequenceExpression{
2105 UnaryExpression: UnaryExpression{
2106 ExponentiationExpression: ExponentiationExpression{
2107 SubsetExpression: SubsetExpression{
2108 ScopeExpression: ScopeExpression{
2109 IndexOrCallExpression: IndexOrCallExpression{
2110 SimpleExpression: &SimpleExpression{
2111 Identifier: &tk[0],
2112 Tokens: tk[:1],
2113 },
2114 Tokens: tk[:1],
2115 },
2116 Tokens: tk[:1],
2117 },
2118 Tokens: tk[:1],
2119 },
2120 Tokens: tk[:1],
2121 },
2122 Tokens: tk[:1],
2123 },
2124 Tokens: tk[:1],
2125 },
2126 Tokens: tk[:1],
2127 },
2128 Tokens: tk[:1],
2129 },
2130 Tokens: tk[:1],
2131 },
2132 Tokens: tk[:1],
2133 },
2134 Tokens: tk[:1],
2135 },
2136 Tokens: tk[:1],
2137 },
2138 Tokens: tk[:1],
2139 },
2140 Tokens: tk[:1],
2141 },
2142 AssignmentType: AssignmentEquals,
2143 AssignmentExpression: &AssignmentExpression{
2144 FormulaeExpression: FormulaeExpression{
2145 OrExpression: &OrExpression{
2146 AndExpression: AndExpression{
2147 NotExpression: NotExpression{
2148 RelationalExpression: RelationalExpression{
2149 AdditionExpression: AdditionExpression{
2150 MultiplicationExpression: MultiplicationExpression{
2151 PipeOrSpecialExpression: PipeOrSpecialExpression{
2152 SequenceExpression: SequenceExpression{
2153 UnaryExpression: UnaryExpression{
2154 ExponentiationExpression: ExponentiationExpression{
2155 SubsetExpression: SubsetExpression{
2156 ScopeExpression: ScopeExpression{
2157 IndexOrCallExpression: IndexOrCallExpression{
2158 SimpleExpression: &SimpleExpression{
2159 Identifier: &tk[4],
2160 Tokens: tk[4:5],
2161 },
2162 Tokens: tk[4:5],
2163 },
2164 Tokens: tk[4:5],
2165 },
2166 Tokens: tk[4:5],
2167 },
2168 Tokens: tk[4:5],
2169 },
2170 Tokens: tk[4:5],
2171 },
2172 Tokens: tk[4:5],
2173 },
2174 Tokens: tk[4:5],
2175 },
2176 Tokens: tk[4:5],
2177 },
2178 Tokens: tk[4:5],
2179 },
2180 Tokens: tk[4:5],
2181 },
2182 Tokens: tk[4:5],
2183 },
2184 Tokens: tk[4:5],
2185 },
2186 Tokens: tk[4:5],
2187 },
2188 Tokens: tk[4:5],
2189 },
2190 Tokens: tk[4:5],
2191 },
2192 Tokens: tk[:5],
2193 }
2194 }},
2195 {"a<-b", func(t *test, tk Tokens) { // 4
2196 t.Output = AssignmentExpression{
2197 FormulaeExpression: FormulaeExpression{
2198 OrExpression: &OrExpression{
2199 AndExpression: AndExpression{
2200 NotExpression: NotExpression{
2201 RelationalExpression: RelationalExpression{
2202 AdditionExpression: AdditionExpression{
2203 MultiplicationExpression: MultiplicationExpression{
2204 PipeOrSpecialExpression: PipeOrSpecialExpression{
2205 SequenceExpression: SequenceExpression{
2206 UnaryExpression: UnaryExpression{
2207 ExponentiationExpression: ExponentiationExpression{
2208 SubsetExpression: SubsetExpression{
2209 ScopeExpression: ScopeExpression{
2210 IndexOrCallExpression: IndexOrCallExpression{
2211 SimpleExpression: &SimpleExpression{
2212 Identifier: &tk[0],
2213 Tokens: tk[:1],
2214 },
2215 Tokens: tk[:1],
2216 },
2217 Tokens: tk[:1],
2218 },
2219 Tokens: tk[:1],
2220 },
2221 Tokens: tk[:1],
2222 },
2223 Tokens: tk[:1],
2224 },
2225 Tokens: tk[:1],
2226 },
2227 Tokens: tk[:1],
2228 },
2229 Tokens: tk[:1],
2230 },
2231 Tokens: tk[:1],
2232 },
2233 Tokens: tk[:1],
2234 },
2235 Tokens: tk[:1],
2236 },
2237 Tokens: tk[:1],
2238 },
2239 Tokens: tk[:1],
2240 },
2241 Tokens: tk[:1],
2242 },
2243 AssignmentType: AssignmentLeftAssign,
2244 AssignmentExpression: &AssignmentExpression{
2245 FormulaeExpression: FormulaeExpression{
2246 OrExpression: &OrExpression{
2247 AndExpression: AndExpression{
2248 NotExpression: NotExpression{
2249 RelationalExpression: RelationalExpression{
2250 AdditionExpression: AdditionExpression{
2251 MultiplicationExpression: MultiplicationExpression{
2252 PipeOrSpecialExpression: PipeOrSpecialExpression{
2253 SequenceExpression: SequenceExpression{
2254 UnaryExpression: UnaryExpression{
2255 ExponentiationExpression: ExponentiationExpression{
2256 SubsetExpression: SubsetExpression{
2257 ScopeExpression: ScopeExpression{
2258 IndexOrCallExpression: IndexOrCallExpression{
2259 SimpleExpression: &SimpleExpression{
2260 Identifier: &tk[2],
2261 Tokens: tk[2:3],
2262 },
2263 Tokens: tk[2:3],
2264 },
2265 Tokens: tk[2:3],
2266 },
2267 Tokens: tk[2:3],
2268 },
2269 Tokens: tk[2:3],
2270 },
2271 Tokens: tk[2:3],
2272 },
2273 Tokens: tk[2:3],
2274 },
2275 Tokens: tk[2:3],
2276 },
2277 Tokens: tk[2:3],
2278 },
2279 Tokens: tk[2:3],
2280 },
2281 Tokens: tk[2:3],
2282 },
2283 Tokens: tk[2:3],
2284 },
2285 Tokens: tk[2:3],
2286 },
2287 Tokens: tk[2:3],
2288 },
2289 Tokens: tk[2:3],
2290 },
2291 Tokens: tk[2:3],
2292 },
2293 Tokens: tk[:3],
2294 }
2295 }},
2296 {"a <- b", func(t *test, tk Tokens) { // 5
2297 t.Output = AssignmentExpression{
2298 FormulaeExpression: FormulaeExpression{
2299 OrExpression: &OrExpression{
2300 AndExpression: AndExpression{
2301 NotExpression: NotExpression{
2302 RelationalExpression: RelationalExpression{
2303 AdditionExpression: AdditionExpression{
2304 MultiplicationExpression: MultiplicationExpression{
2305 PipeOrSpecialExpression: PipeOrSpecialExpression{
2306 SequenceExpression: SequenceExpression{
2307 UnaryExpression: UnaryExpression{
2308 ExponentiationExpression: ExponentiationExpression{
2309 SubsetExpression: SubsetExpression{
2310 ScopeExpression: ScopeExpression{
2311 IndexOrCallExpression: IndexOrCallExpression{
2312 SimpleExpression: &SimpleExpression{
2313 Identifier: &tk[0],
2314 Tokens: tk[:1],
2315 },
2316 Tokens: tk[:1],
2317 },
2318 Tokens: tk[:1],
2319 },
2320 Tokens: tk[:1],
2321 },
2322 Tokens: tk[:1],
2323 },
2324 Tokens: tk[:1],
2325 },
2326 Tokens: tk[:1],
2327 },
2328 Tokens: tk[:1],
2329 },
2330 Tokens: tk[:1],
2331 },
2332 Tokens: tk[:1],
2333 },
2334 Tokens: tk[:1],
2335 },
2336 Tokens: tk[:1],
2337 },
2338 Tokens: tk[:1],
2339 },
2340 Tokens: tk[:1],
2341 },
2342 Tokens: tk[:1],
2343 },
2344 AssignmentType: AssignmentLeftAssign,
2345 AssignmentExpression: &AssignmentExpression{
2346 FormulaeExpression: FormulaeExpression{
2347 OrExpression: &OrExpression{
2348 AndExpression: AndExpression{
2349 NotExpression: NotExpression{
2350 RelationalExpression: RelationalExpression{
2351 AdditionExpression: AdditionExpression{
2352 MultiplicationExpression: MultiplicationExpression{
2353 PipeOrSpecialExpression: PipeOrSpecialExpression{
2354 SequenceExpression: SequenceExpression{
2355 UnaryExpression: UnaryExpression{
2356 ExponentiationExpression: ExponentiationExpression{
2357 SubsetExpression: SubsetExpression{
2358 ScopeExpression: ScopeExpression{
2359 IndexOrCallExpression: IndexOrCallExpression{
2360 SimpleExpression: &SimpleExpression{
2361 Identifier: &tk[4],
2362 Tokens: tk[4:5],
2363 },
2364 Tokens: tk[4:5],
2365 },
2366 Tokens: tk[4:5],
2367 },
2368 Tokens: tk[4:5],
2369 },
2370 Tokens: tk[4:5],
2371 },
2372 Tokens: tk[4:5],
2373 },
2374 Tokens: tk[4:5],
2375 },
2376 Tokens: tk[4:5],
2377 },
2378 Tokens: tk[4:5],
2379 },
2380 Tokens: tk[4:5],
2381 },
2382 Tokens: tk[4:5],
2383 },
2384 Tokens: tk[4:5],
2385 },
2386 Tokens: tk[4:5],
2387 },
2388 Tokens: tk[4:5],
2389 },
2390 Tokens: tk[4:5],
2391 },
2392 Tokens: tk[4:5],
2393 },
2394 Tokens: tk[:5],
2395 }
2396 }},
2397 {"a->b", func(t *test, tk Tokens) { // 6
2398 t.Output = AssignmentExpression{
2399 FormulaeExpression: FormulaeExpression{
2400 OrExpression: &OrExpression{
2401 AndExpression: AndExpression{
2402 NotExpression: NotExpression{
2403 RelationalExpression: RelationalExpression{
2404 AdditionExpression: AdditionExpression{
2405 MultiplicationExpression: MultiplicationExpression{
2406 PipeOrSpecialExpression: PipeOrSpecialExpression{
2407 SequenceExpression: SequenceExpression{
2408 UnaryExpression: UnaryExpression{
2409 ExponentiationExpression: ExponentiationExpression{
2410 SubsetExpression: SubsetExpression{
2411 ScopeExpression: ScopeExpression{
2412 IndexOrCallExpression: IndexOrCallExpression{
2413 SimpleExpression: &SimpleExpression{
2414 Identifier: &tk[0],
2415 Tokens: tk[:1],
2416 },
2417 Tokens: tk[:1],
2418 },
2419 Tokens: tk[:1],
2420 },
2421 Tokens: tk[:1],
2422 },
2423 Tokens: tk[:1],
2424 },
2425 Tokens: tk[:1],
2426 },
2427 Tokens: tk[:1],
2428 },
2429 Tokens: tk[:1],
2430 },
2431 Tokens: tk[:1],
2432 },
2433 Tokens: tk[:1],
2434 },
2435 Tokens: tk[:1],
2436 },
2437 Tokens: tk[:1],
2438 },
2439 Tokens: tk[:1],
2440 },
2441 Tokens: tk[:1],
2442 },
2443 Tokens: tk[:1],
2444 },
2445 AssignmentType: AssignmentRightAssign,
2446 AssignmentExpression: &AssignmentExpression{
2447 FormulaeExpression: FormulaeExpression{
2448 OrExpression: &OrExpression{
2449 AndExpression: AndExpression{
2450 NotExpression: NotExpression{
2451 RelationalExpression: RelationalExpression{
2452 AdditionExpression: AdditionExpression{
2453 MultiplicationExpression: MultiplicationExpression{
2454 PipeOrSpecialExpression: PipeOrSpecialExpression{
2455 SequenceExpression: SequenceExpression{
2456 UnaryExpression: UnaryExpression{
2457 ExponentiationExpression: ExponentiationExpression{
2458 SubsetExpression: SubsetExpression{
2459 ScopeExpression: ScopeExpression{
2460 IndexOrCallExpression: IndexOrCallExpression{
2461 SimpleExpression: &SimpleExpression{
2462 Identifier: &tk[2],
2463 Tokens: tk[2:3],
2464 },
2465 Tokens: tk[2:3],
2466 },
2467 Tokens: tk[2:3],
2468 },
2469 Tokens: tk[2:3],
2470 },
2471 Tokens: tk[2:3],
2472 },
2473 Tokens: tk[2:3],
2474 },
2475 Tokens: tk[2:3],
2476 },
2477 Tokens: tk[2:3],
2478 },
2479 Tokens: tk[2:3],
2480 },
2481 Tokens: tk[2:3],
2482 },
2483 Tokens: tk[2:3],
2484 },
2485 Tokens: tk[2:3],
2486 },
2487 Tokens: tk[2:3],
2488 },
2489 Tokens: tk[2:3],
2490 },
2491 Tokens: tk[2:3],
2492 },
2493 Tokens: tk[2:3],
2494 },
2495 Tokens: tk[:3],
2496 }
2497 }},
2498 {"a -> b", func(t *test, tk Tokens) { // 7
2499 t.Output = AssignmentExpression{
2500 FormulaeExpression: FormulaeExpression{
2501 OrExpression: &OrExpression{
2502 AndExpression: AndExpression{
2503 NotExpression: NotExpression{
2504 RelationalExpression: RelationalExpression{
2505 AdditionExpression: AdditionExpression{
2506 MultiplicationExpression: MultiplicationExpression{
2507 PipeOrSpecialExpression: PipeOrSpecialExpression{
2508 SequenceExpression: SequenceExpression{
2509 UnaryExpression: UnaryExpression{
2510 ExponentiationExpression: ExponentiationExpression{
2511 SubsetExpression: SubsetExpression{
2512 ScopeExpression: ScopeExpression{
2513 IndexOrCallExpression: IndexOrCallExpression{
2514 SimpleExpression: &SimpleExpression{
2515 Identifier: &tk[0],
2516 Tokens: tk[:1],
2517 },
2518 Tokens: tk[:1],
2519 },
2520 Tokens: tk[:1],
2521 },
2522 Tokens: tk[:1],
2523 },
2524 Tokens: tk[:1],
2525 },
2526 Tokens: tk[:1],
2527 },
2528 Tokens: tk[:1],
2529 },
2530 Tokens: tk[:1],
2531 },
2532 Tokens: tk[:1],
2533 },
2534 Tokens: tk[:1],
2535 },
2536 Tokens: tk[:1],
2537 },
2538 Tokens: tk[:1],
2539 },
2540 Tokens: tk[:1],
2541 },
2542 Tokens: tk[:1],
2543 },
2544 Tokens: tk[:1],
2545 },
2546 AssignmentType: AssignmentRightAssign,
2547 AssignmentExpression: &AssignmentExpression{
2548 FormulaeExpression: FormulaeExpression{
2549 OrExpression: &OrExpression{
2550 AndExpression: AndExpression{
2551 NotExpression: NotExpression{
2552 RelationalExpression: RelationalExpression{
2553 AdditionExpression: AdditionExpression{
2554 MultiplicationExpression: MultiplicationExpression{
2555 PipeOrSpecialExpression: PipeOrSpecialExpression{
2556 SequenceExpression: SequenceExpression{
2557 UnaryExpression: UnaryExpression{
2558 ExponentiationExpression: ExponentiationExpression{
2559 SubsetExpression: SubsetExpression{
2560 ScopeExpression: ScopeExpression{
2561 IndexOrCallExpression: IndexOrCallExpression{
2562 SimpleExpression: &SimpleExpression{
2563 Identifier: &tk[4],
2564 Tokens: tk[4:5],
2565 },
2566 Tokens: tk[4:5],
2567 },
2568 Tokens: tk[4:5],
2569 },
2570 Tokens: tk[4:5],
2571 },
2572 Tokens: tk[4:5],
2573 },
2574 Tokens: tk[4:5],
2575 },
2576 Tokens: tk[4:5],
2577 },
2578 Tokens: tk[4:5],
2579 },
2580 Tokens: tk[4:5],
2581 },
2582 Tokens: tk[4:5],
2583 },
2584 Tokens: tk[4:5],
2585 },
2586 Tokens: tk[4:5],
2587 },
2588 Tokens: tk[4:5],
2589 },
2590 Tokens: tk[4:5],
2591 },
2592 Tokens: tk[4:5],
2593 },
2594 Tokens: tk[4:5],
2595 },
2596 Tokens: tk[:5],
2597 }
2598 }},
2599 {"a<<-b", func(t *test, tk Tokens) { // 8
2600 t.Output = AssignmentExpression{
2601 FormulaeExpression: FormulaeExpression{
2602 OrExpression: &OrExpression{
2603 AndExpression: AndExpression{
2604 NotExpression: NotExpression{
2605 RelationalExpression: RelationalExpression{
2606 AdditionExpression: AdditionExpression{
2607 MultiplicationExpression: MultiplicationExpression{
2608 PipeOrSpecialExpression: PipeOrSpecialExpression{
2609 SequenceExpression: SequenceExpression{
2610 UnaryExpression: UnaryExpression{
2611 ExponentiationExpression: ExponentiationExpression{
2612 SubsetExpression: SubsetExpression{
2613 ScopeExpression: ScopeExpression{
2614 IndexOrCallExpression: IndexOrCallExpression{
2615 SimpleExpression: &SimpleExpression{
2616 Identifier: &tk[0],
2617 Tokens: tk[:1],
2618 },
2619 Tokens: tk[:1],
2620 },
2621 Tokens: tk[:1],
2622 },
2623 Tokens: tk[:1],
2624 },
2625 Tokens: tk[:1],
2626 },
2627 Tokens: tk[:1],
2628 },
2629 Tokens: tk[:1],
2630 },
2631 Tokens: tk[:1],
2632 },
2633 Tokens: tk[:1],
2634 },
2635 Tokens: tk[:1],
2636 },
2637 Tokens: tk[:1],
2638 },
2639 Tokens: tk[:1],
2640 },
2641 Tokens: tk[:1],
2642 },
2643 Tokens: tk[:1],
2644 },
2645 Tokens: tk[:1],
2646 },
2647 AssignmentType: AssignmentLeftParentAssign,
2648 AssignmentExpression: &AssignmentExpression{
2649 FormulaeExpression: FormulaeExpression{
2650 OrExpression: &OrExpression{
2651 AndExpression: AndExpression{
2652 NotExpression: NotExpression{
2653 RelationalExpression: RelationalExpression{
2654 AdditionExpression: AdditionExpression{
2655 MultiplicationExpression: MultiplicationExpression{
2656 PipeOrSpecialExpression: PipeOrSpecialExpression{
2657 SequenceExpression: SequenceExpression{
2658 UnaryExpression: UnaryExpression{
2659 ExponentiationExpression: ExponentiationExpression{
2660 SubsetExpression: SubsetExpression{
2661 ScopeExpression: ScopeExpression{
2662 IndexOrCallExpression: IndexOrCallExpression{
2663 SimpleExpression: &SimpleExpression{
2664 Identifier: &tk[2],
2665 Tokens: tk[2:3],
2666 },
2667 Tokens: tk[2:3],
2668 },
2669 Tokens: tk[2:3],
2670 },
2671 Tokens: tk[2:3],
2672 },
2673 Tokens: tk[2:3],
2674 },
2675 Tokens: tk[2:3],
2676 },
2677 Tokens: tk[2:3],
2678 },
2679 Tokens: tk[2:3],
2680 },
2681 Tokens: tk[2:3],
2682 },
2683 Tokens: tk[2:3],
2684 },
2685 Tokens: tk[2:3],
2686 },
2687 Tokens: tk[2:3],
2688 },
2689 Tokens: tk[2:3],
2690 },
2691 Tokens: tk[2:3],
2692 },
2693 Tokens: tk[2:3],
2694 },
2695 Tokens: tk[2:3],
2696 },
2697 Tokens: tk[:3],
2698 }
2699 }},
2700 {"a <<- b", func(t *test, tk Tokens) { // 9
2701 t.Output = AssignmentExpression{
2702 FormulaeExpression: FormulaeExpression{
2703 OrExpression: &OrExpression{
2704 AndExpression: AndExpression{
2705 NotExpression: NotExpression{
2706 RelationalExpression: RelationalExpression{
2707 AdditionExpression: AdditionExpression{
2708 MultiplicationExpression: MultiplicationExpression{
2709 PipeOrSpecialExpression: PipeOrSpecialExpression{
2710 SequenceExpression: SequenceExpression{
2711 UnaryExpression: UnaryExpression{
2712 ExponentiationExpression: ExponentiationExpression{
2713 SubsetExpression: SubsetExpression{
2714 ScopeExpression: ScopeExpression{
2715 IndexOrCallExpression: IndexOrCallExpression{
2716 SimpleExpression: &SimpleExpression{
2717 Identifier: &tk[0],
2718 Tokens: tk[:1],
2719 },
2720 Tokens: tk[:1],
2721 },
2722 Tokens: tk[:1],
2723 },
2724 Tokens: tk[:1],
2725 },
2726 Tokens: tk[:1],
2727 },
2728 Tokens: tk[:1],
2729 },
2730 Tokens: tk[:1],
2731 },
2732 Tokens: tk[:1],
2733 },
2734 Tokens: tk[:1],
2735 },
2736 Tokens: tk[:1],
2737 },
2738 Tokens: tk[:1],
2739 },
2740 Tokens: tk[:1],
2741 },
2742 Tokens: tk[:1],
2743 },
2744 Tokens: tk[:1],
2745 },
2746 Tokens: tk[:1],
2747 },
2748 AssignmentType: AssignmentLeftParentAssign,
2749 AssignmentExpression: &AssignmentExpression{
2750 FormulaeExpression: FormulaeExpression{
2751 OrExpression: &OrExpression{
2752 AndExpression: AndExpression{
2753 NotExpression: NotExpression{
2754 RelationalExpression: RelationalExpression{
2755 AdditionExpression: AdditionExpression{
2756 MultiplicationExpression: MultiplicationExpression{
2757 PipeOrSpecialExpression: PipeOrSpecialExpression{
2758 SequenceExpression: SequenceExpression{
2759 UnaryExpression: UnaryExpression{
2760 ExponentiationExpression: ExponentiationExpression{
2761 SubsetExpression: SubsetExpression{
2762 ScopeExpression: ScopeExpression{
2763 IndexOrCallExpression: IndexOrCallExpression{
2764 SimpleExpression: &SimpleExpression{
2765 Identifier: &tk[4],
2766 Tokens: tk[4:5],
2767 },
2768 Tokens: tk[4:5],
2769 },
2770 Tokens: tk[4:5],
2771 },
2772 Tokens: tk[4:5],
2773 },
2774 Tokens: tk[4:5],
2775 },
2776 Tokens: tk[4:5],
2777 },
2778 Tokens: tk[4:5],
2779 },
2780 Tokens: tk[4:5],
2781 },
2782 Tokens: tk[4:5],
2783 },
2784 Tokens: tk[4:5],
2785 },
2786 Tokens: tk[4:5],
2787 },
2788 Tokens: tk[4:5],
2789 },
2790 Tokens: tk[4:5],
2791 },
2792 Tokens: tk[4:5],
2793 },
2794 Tokens: tk[4:5],
2795 },
2796 Tokens: tk[4:5],
2797 },
2798 Tokens: tk[:5],
2799 }
2800 }},
2801 {"a->>b", func(t *test, tk Tokens) { // 10
2802 t.Output = AssignmentExpression{
2803 FormulaeExpression: FormulaeExpression{
2804 OrExpression: &OrExpression{
2805 AndExpression: AndExpression{
2806 NotExpression: NotExpression{
2807 RelationalExpression: RelationalExpression{
2808 AdditionExpression: AdditionExpression{
2809 MultiplicationExpression: MultiplicationExpression{
2810 PipeOrSpecialExpression: PipeOrSpecialExpression{
2811 SequenceExpression: SequenceExpression{
2812 UnaryExpression: UnaryExpression{
2813 ExponentiationExpression: ExponentiationExpression{
2814 SubsetExpression: SubsetExpression{
2815 ScopeExpression: ScopeExpression{
2816 IndexOrCallExpression: IndexOrCallExpression{
2817 SimpleExpression: &SimpleExpression{
2818 Identifier: &tk[0],
2819 Tokens: tk[:1],
2820 },
2821 Tokens: tk[:1],
2822 },
2823 Tokens: tk[:1],
2824 },
2825 Tokens: tk[:1],
2826 },
2827 Tokens: tk[:1],
2828 },
2829 Tokens: tk[:1],
2830 },
2831 Tokens: tk[:1],
2832 },
2833 Tokens: tk[:1],
2834 },
2835 Tokens: tk[:1],
2836 },
2837 Tokens: tk[:1],
2838 },
2839 Tokens: tk[:1],
2840 },
2841 Tokens: tk[:1],
2842 },
2843 Tokens: tk[:1],
2844 },
2845 Tokens: tk[:1],
2846 },
2847 Tokens: tk[:1],
2848 },
2849 AssignmentType: AssignmentRightParentAssign,
2850 AssignmentExpression: &AssignmentExpression{
2851 FormulaeExpression: FormulaeExpression{
2852 OrExpression: &OrExpression{
2853 AndExpression: AndExpression{
2854 NotExpression: NotExpression{
2855 RelationalExpression: RelationalExpression{
2856 AdditionExpression: AdditionExpression{
2857 MultiplicationExpression: MultiplicationExpression{
2858 PipeOrSpecialExpression: PipeOrSpecialExpression{
2859 SequenceExpression: SequenceExpression{
2860 UnaryExpression: UnaryExpression{
2861 ExponentiationExpression: ExponentiationExpression{
2862 SubsetExpression: SubsetExpression{
2863 ScopeExpression: ScopeExpression{
2864 IndexOrCallExpression: IndexOrCallExpression{
2865 SimpleExpression: &SimpleExpression{
2866 Identifier: &tk[2],
2867 Tokens: tk[2:3],
2868 },
2869 Tokens: tk[2:3],
2870 },
2871 Tokens: tk[2:3],
2872 },
2873 Tokens: tk[2:3],
2874 },
2875 Tokens: tk[2:3],
2876 },
2877 Tokens: tk[2:3],
2878 },
2879 Tokens: tk[2:3],
2880 },
2881 Tokens: tk[2:3],
2882 },
2883 Tokens: tk[2:3],
2884 },
2885 Tokens: tk[2:3],
2886 },
2887 Tokens: tk[2:3],
2888 },
2889 Tokens: tk[2:3],
2890 },
2891 Tokens: tk[2:3],
2892 },
2893 Tokens: tk[2:3],
2894 },
2895 Tokens: tk[2:3],
2896 },
2897 Tokens: tk[2:3],
2898 },
2899 Tokens: tk[:3],
2900 }
2901 }},
2902 {"a ->> b", func(t *test, tk Tokens) { // 11
2903 t.Output = AssignmentExpression{
2904 FormulaeExpression: FormulaeExpression{
2905 OrExpression: &OrExpression{
2906 AndExpression: AndExpression{
2907 NotExpression: NotExpression{
2908 RelationalExpression: RelationalExpression{
2909 AdditionExpression: AdditionExpression{
2910 MultiplicationExpression: MultiplicationExpression{
2911 PipeOrSpecialExpression: PipeOrSpecialExpression{
2912 SequenceExpression: SequenceExpression{
2913 UnaryExpression: UnaryExpression{
2914 ExponentiationExpression: ExponentiationExpression{
2915 SubsetExpression: SubsetExpression{
2916 ScopeExpression: ScopeExpression{
2917 IndexOrCallExpression: IndexOrCallExpression{
2918 SimpleExpression: &SimpleExpression{
2919 Identifier: &tk[0],
2920 Tokens: tk[:1],
2921 },
2922 Tokens: tk[:1],
2923 },
2924 Tokens: tk[:1],
2925 },
2926 Tokens: tk[:1],
2927 },
2928 Tokens: tk[:1],
2929 },
2930 Tokens: tk[:1],
2931 },
2932 Tokens: tk[:1],
2933 },
2934 Tokens: tk[:1],
2935 },
2936 Tokens: tk[:1],
2937 },
2938 Tokens: tk[:1],
2939 },
2940 Tokens: tk[:1],
2941 },
2942 Tokens: tk[:1],
2943 },
2944 Tokens: tk[:1],
2945 },
2946 Tokens: tk[:1],
2947 },
2948 Tokens: tk[:1],
2949 },
2950 AssignmentType: AssignmentRightParentAssign,
2951 AssignmentExpression: &AssignmentExpression{
2952 FormulaeExpression: FormulaeExpression{
2953 OrExpression: &OrExpression{
2954 AndExpression: AndExpression{
2955 NotExpression: NotExpression{
2956 RelationalExpression: RelationalExpression{
2957 AdditionExpression: AdditionExpression{
2958 MultiplicationExpression: MultiplicationExpression{
2959 PipeOrSpecialExpression: PipeOrSpecialExpression{
2960 SequenceExpression: SequenceExpression{
2961 UnaryExpression: UnaryExpression{
2962 ExponentiationExpression: ExponentiationExpression{
2963 SubsetExpression: SubsetExpression{
2964 ScopeExpression: ScopeExpression{
2965 IndexOrCallExpression: IndexOrCallExpression{
2966 SimpleExpression: &SimpleExpression{
2967 Identifier: &tk[4],
2968 Tokens: tk[4:5],
2969 },
2970 Tokens: tk[4:5],
2971 },
2972 Tokens: tk[4:5],
2973 },
2974 Tokens: tk[4:5],
2975 },
2976 Tokens: tk[4:5],
2977 },
2978 Tokens: tk[4:5],
2979 },
2980 Tokens: tk[4:5],
2981 },
2982 Tokens: tk[4:5],
2983 },
2984 Tokens: tk[4:5],
2985 },
2986 Tokens: tk[4:5],
2987 },
2988 Tokens: tk[4:5],
2989 },
2990 Tokens: tk[4:5],
2991 },
2992 Tokens: tk[4:5],
2993 },
2994 Tokens: tk[4:5],
2995 },
2996 Tokens: tk[4:5],
2997 },
2998 Tokens: tk[4:5],
2999 },
3000 Tokens: tk[:5],
3001 }
3002 }},
3003 {"in", func(t *test, tk Tokens) { // 12
3004 t.Err = Error{
3005 Err: Error{
3006 Err: Error{
3007 Err: Error{
3008 Err: Error{
3009 Err: Error{
3010 Err: Error{
3011 Err: Error{
3012 Err: Error{
3013 Err: Error{
3014 Err: Error{
3015 Err: Error{
3016 Err: Error{
3017 Err: Error{
3018 Err: Error{
3019 Err: Error{
3020 Err: ErrInvalidSimpleExpression,
3021 Parsing: "SimpleExpression",
3022 Token: tk[0],
3023 },
3024 Parsing: "IndexOrCallExpression",
3025 Token: tk[0],
3026 },
3027 Parsing: "ScopeExpression",
3028 Token: tk[0],
3029 },
3030 Parsing: "SubsetExpression",
3031 Token: tk[0],
3032 },
3033 Parsing: "ExponentiationExpression",
3034 Token: tk[0],
3035 },
3036 Parsing: "UnaryExpression",
3037 Token: tk[0],
3038 },
3039 Parsing: "SequenceExpression",
3040 Token: tk[0],
3041 },
3042 Parsing: "PipeOrSpecialExpression",
3043 Token: tk[0],
3044 },
3045 Parsing: "MultiplicationExpression",
3046 Token: tk[0],
3047 },
3048 Parsing: "AdditionExpression",
3049 Token: tk[0],
3050 },
3051 Parsing: "RelationalExpression",
3052 Token: tk[0],
3053 },
3054 Parsing: "NotExpression",
3055 Token: tk[0],
3056 },
3057 Parsing: "AndExpression",
3058 Token: tk[0],
3059 },
3060 Parsing: "OrExpression",
3061 Token: tk[0],
3062 },
3063 Parsing: "FormulaeExpression",
3064 Token: tk[0],
3065 },
3066 Parsing: "AssignmentExpression",
3067 Token: tk[0],
3068 }
3069 }},
3070 {"a=in", func(t *test, tk Tokens) { // 13
3071 t.Err = Error{
3072 Err: Error{
3073 Err: Error{
3074 Err: Error{
3075 Err: Error{
3076 Err: Error{
3077 Err: Error{
3078 Err: Error{
3079 Err: Error{
3080 Err: Error{
3081 Err: Error{
3082 Err: Error{
3083 Err: Error{
3084 Err: Error{
3085 Err: Error{
3086 Err: Error{
3087 Err: Error{
3088 Err: ErrInvalidSimpleExpression,
3089 Parsing: "SimpleExpression",
3090 Token: tk[2],
3091 },
3092 Parsing: "IndexOrCallExpression",
3093 Token: tk[2],
3094 },
3095 Parsing: "ScopeExpression",
3096 Token: tk[2],
3097 },
3098 Parsing: "SubsetExpression",
3099 Token: tk[2],
3100 },
3101 Parsing: "ExponentiationExpression",
3102 Token: tk[2],
3103 },
3104 Parsing: "UnaryExpression",
3105 Token: tk[2],
3106 },
3107 Parsing: "SequenceExpression",
3108 Token: tk[2],
3109 },
3110 Parsing: "PipeOrSpecialExpression",
3111 Token: tk[2],
3112 },
3113 Parsing: "MultiplicationExpression",
3114 Token: tk[2],
3115 },
3116 Parsing: "AdditionExpression",
3117 Token: tk[2],
3118 },
3119 Parsing: "RelationalExpression",
3120 Token: tk[2],
3121 },
3122 Parsing: "NotExpression",
3123 Token: tk[2],
3124 },
3125 Parsing: "AndExpression",
3126 Token: tk[2],
3127 },
3128 Parsing: "OrExpression",
3129 Token: tk[2],
3130 },
3131 Parsing: "FormulaeExpression",
3132 Token: tk[2],
3133 },
3134 Parsing: "AssignmentExpression",
3135 Token: tk[2],
3136 },
3137 Parsing: "AssignmentExpression",
3138 Token: tk[2],
3139 }
3140 }},
3141 {"a=#abc\nb", func(t *test, tk Tokens) { // 14
3142 t.Output = AssignmentExpression{
3143 FormulaeExpression: WrapQuery(&SimpleExpression{
3144 Identifier: &tk[0],
3145 Tokens: tk[:1],
3146 }).AssignmentExpression.FormulaeExpression,
3147 AssignmentType: AssignmentEquals,
3148 AssignmentExpression: WrapQuery(&SimpleExpression{
3149 Identifier: &tk[4],
3150 Tokens: tk[4:5],
3151 }).AssignmentExpression,
3152 Comments: [2]Comments{nil, {tk[2]}},
3153 Tokens: tk[:5],
3154 }
3155 }},
3156 {"a#abc\n=#def\nb", func(t *test, tk Tokens) { // 15
3157 t.Output = AssignmentExpression{
3158 FormulaeExpression: WrapQuery(&SimpleExpression{
3159 Identifier: &tk[0],
3160 Tokens: tk[:1],
3161 }).AssignmentExpression.FormulaeExpression,
3162 Tokens: tk[:1],
3163 }
3164 }},
3165 }, func(t *test) (Type, error) {
3166 var ae AssignmentExpression
3167
3168 err := ae.parse(&t.Tokens)
3169
3170 return ae, err
3171 })
3172 }
3173
3174 func TestFormulaeExpression(t *testing.T) {
3175 doTests(t, []sourceFn{
3176 {"a", func(t *test, tk Tokens) { // 1
3177 t.Output = FormulaeExpression{
3178 OrExpression: &OrExpression{
3179 AndExpression: AndExpression{
3180 NotExpression: NotExpression{
3181 RelationalExpression: RelationalExpression{
3182 AdditionExpression: AdditionExpression{
3183 MultiplicationExpression: MultiplicationExpression{
3184 PipeOrSpecialExpression: PipeOrSpecialExpression{
3185 SequenceExpression: SequenceExpression{
3186 UnaryExpression: UnaryExpression{
3187 ExponentiationExpression: ExponentiationExpression{
3188 SubsetExpression: SubsetExpression{
3189 ScopeExpression: ScopeExpression{
3190 IndexOrCallExpression: IndexOrCallExpression{
3191 SimpleExpression: &SimpleExpression{
3192 Identifier: &tk[0],
3193 Tokens: tk[:1],
3194 },
3195 Tokens: tk[:1],
3196 },
3197 Tokens: tk[:1],
3198 },
3199 Tokens: tk[:1],
3200 },
3201 Tokens: tk[:1],
3202 },
3203 Tokens: tk[:1],
3204 },
3205 Tokens: tk[:1],
3206 },
3207 Tokens: tk[:1],
3208 },
3209 Tokens: tk[:1],
3210 },
3211 Tokens: tk[:1],
3212 },
3213 Tokens: tk[:1],
3214 },
3215 Tokens: tk[:1],
3216 },
3217 Tokens: tk[:1],
3218 },
3219 Tokens: tk[:1],
3220 },
3221 Tokens: tk[:1],
3222 }
3223 }},
3224 {"~a", func(t *test, tk Tokens) { // 2
3225 t.Output = FormulaeExpression{
3226 FormulaeExpression: &FormulaeExpression{
3227 OrExpression: &OrExpression{
3228 AndExpression: AndExpression{
3229 NotExpression: NotExpression{
3230 RelationalExpression: RelationalExpression{
3231 AdditionExpression: AdditionExpression{
3232 MultiplicationExpression: MultiplicationExpression{
3233 PipeOrSpecialExpression: PipeOrSpecialExpression{
3234 SequenceExpression: SequenceExpression{
3235 UnaryExpression: UnaryExpression{
3236 ExponentiationExpression: ExponentiationExpression{
3237 SubsetExpression: SubsetExpression{
3238 ScopeExpression: ScopeExpression{
3239 IndexOrCallExpression: IndexOrCallExpression{
3240 SimpleExpression: &SimpleExpression{
3241 Identifier: &tk[1],
3242 Tokens: tk[1:2],
3243 },
3244 Tokens: tk[1:2],
3245 },
3246 Tokens: tk[1:2],
3247 },
3248 Tokens: tk[1:2],
3249 },
3250 Tokens: tk[1:2],
3251 },
3252 Tokens: tk[1:2],
3253 },
3254 Tokens: tk[1:2],
3255 },
3256 Tokens: tk[1:2],
3257 },
3258 Tokens: tk[1:2],
3259 },
3260 Tokens: tk[1:2],
3261 },
3262 Tokens: tk[1:2],
3263 },
3264 Tokens: tk[1:2],
3265 },
3266 Tokens: tk[1:2],
3267 },
3268 Tokens: tk[1:2],
3269 },
3270 Tokens: tk[1:2],
3271 },
3272 Tokens: tk[:2],
3273 }
3274 }},
3275 {"~ a", func(t *test, tk Tokens) { // 3
3276 t.Output = FormulaeExpression{
3277 FormulaeExpression: &FormulaeExpression{
3278 OrExpression: &OrExpression{
3279 AndExpression: AndExpression{
3280 NotExpression: NotExpression{
3281 RelationalExpression: RelationalExpression{
3282 AdditionExpression: AdditionExpression{
3283 MultiplicationExpression: MultiplicationExpression{
3284 PipeOrSpecialExpression: PipeOrSpecialExpression{
3285 SequenceExpression: SequenceExpression{
3286 UnaryExpression: UnaryExpression{
3287 ExponentiationExpression: ExponentiationExpression{
3288 SubsetExpression: SubsetExpression{
3289 ScopeExpression: ScopeExpression{
3290 IndexOrCallExpression: IndexOrCallExpression{
3291 SimpleExpression: &SimpleExpression{
3292 Identifier: &tk[2],
3293 Tokens: tk[2:3],
3294 },
3295 Tokens: tk[2:3],
3296 },
3297 Tokens: tk[2:3],
3298 },
3299 Tokens: tk[2:3],
3300 },
3301 Tokens: tk[2:3],
3302 },
3303 Tokens: tk[2:3],
3304 },
3305 Tokens: tk[2:3],
3306 },
3307 Tokens: tk[2:3],
3308 },
3309 Tokens: tk[2:3],
3310 },
3311 Tokens: tk[2:3],
3312 },
3313 Tokens: tk[2:3],
3314 },
3315 Tokens: tk[2:3],
3316 },
3317 Tokens: tk[2:3],
3318 },
3319 Tokens: tk[2:3],
3320 },
3321 Tokens: tk[2:3],
3322 },
3323 Tokens: tk[:3],
3324 }
3325 }},
3326 {"a~b", func(t *test, tk Tokens) { // 4
3327 t.Output = FormulaeExpression{
3328 OrExpression: &OrExpression{
3329 AndExpression: AndExpression{
3330 NotExpression: NotExpression{
3331 RelationalExpression: RelationalExpression{
3332 AdditionExpression: AdditionExpression{
3333 MultiplicationExpression: MultiplicationExpression{
3334 PipeOrSpecialExpression: PipeOrSpecialExpression{
3335 SequenceExpression: SequenceExpression{
3336 UnaryExpression: UnaryExpression{
3337 ExponentiationExpression: ExponentiationExpression{
3338 SubsetExpression: SubsetExpression{
3339 ScopeExpression: ScopeExpression{
3340 IndexOrCallExpression: IndexOrCallExpression{
3341 SimpleExpression: &SimpleExpression{
3342 Identifier: &tk[0],
3343 Tokens: tk[:1],
3344 },
3345 Tokens: tk[:1],
3346 },
3347 Tokens: tk[:1],
3348 },
3349 Tokens: tk[:1],
3350 },
3351 Tokens: tk[:1],
3352 },
3353 Tokens: tk[:1],
3354 },
3355 Tokens: tk[:1],
3356 },
3357 Tokens: tk[:1],
3358 },
3359 Tokens: tk[:1],
3360 },
3361 Tokens: tk[:1],
3362 },
3363 Tokens: tk[:1],
3364 },
3365 Tokens: tk[:1],
3366 },
3367 Tokens: tk[:1],
3368 },
3369 Tokens: tk[:1],
3370 },
3371 FormulaeExpression: &FormulaeExpression{
3372 OrExpression: &OrExpression{
3373 AndExpression: AndExpression{
3374 NotExpression: NotExpression{
3375 RelationalExpression: RelationalExpression{
3376 AdditionExpression: AdditionExpression{
3377 MultiplicationExpression: MultiplicationExpression{
3378 PipeOrSpecialExpression: PipeOrSpecialExpression{
3379 SequenceExpression: SequenceExpression{
3380 UnaryExpression: UnaryExpression{
3381 ExponentiationExpression: ExponentiationExpression{
3382 SubsetExpression: SubsetExpression{
3383 ScopeExpression: ScopeExpression{
3384 IndexOrCallExpression: IndexOrCallExpression{
3385 SimpleExpression: &SimpleExpression{
3386 Identifier: &tk[2],
3387 Tokens: tk[2:3],
3388 },
3389 Tokens: tk[2:3],
3390 },
3391 Tokens: tk[2:3],
3392 },
3393 Tokens: tk[2:3],
3394 },
3395 Tokens: tk[2:3],
3396 },
3397 Tokens: tk[2:3],
3398 },
3399 Tokens: tk[2:3],
3400 },
3401 Tokens: tk[2:3],
3402 },
3403 Tokens: tk[2:3],
3404 },
3405 Tokens: tk[2:3],
3406 },
3407 Tokens: tk[2:3],
3408 },
3409 Tokens: tk[2:3],
3410 },
3411 Tokens: tk[2:3],
3412 },
3413 Tokens: tk[2:3],
3414 },
3415 Tokens: tk[2:3],
3416 },
3417 Tokens: tk[:3],
3418 }
3419 }},
3420 {"in", func(t *test, tk Tokens) { // 5
3421 t.Err = Error{
3422 Err: Error{
3423 Err: Error{
3424 Err: Error{
3425 Err: Error{
3426 Err: Error{
3427 Err: Error{
3428 Err: Error{
3429 Err: Error{
3430 Err: Error{
3431 Err: Error{
3432 Err: Error{
3433 Err: Error{
3434 Err: Error{
3435 Err: Error{
3436 Err: ErrInvalidSimpleExpression,
3437 Parsing: "SimpleExpression",
3438 Token: tk[0],
3439 },
3440 Parsing: "IndexOrCallExpression",
3441 Token: tk[0],
3442 },
3443 Parsing: "ScopeExpression",
3444 Token: tk[0],
3445 },
3446 Parsing: "SubsetExpression",
3447 Token: tk[0],
3448 },
3449 Parsing: "ExponentiationExpression",
3450 Token: tk[0],
3451 },
3452 Parsing: "UnaryExpression",
3453 Token: tk[0],
3454 },
3455 Parsing: "SequenceExpression",
3456 Token: tk[0],
3457 },
3458 Parsing: "PipeOrSpecialExpression",
3459 Token: tk[0],
3460 },
3461 Parsing: "MultiplicationExpression",
3462 Token: tk[0],
3463 },
3464 Parsing: "AdditionExpression",
3465 Token: tk[0],
3466 },
3467 Parsing: "RelationalExpression",
3468 Token: tk[0],
3469 },
3470 Parsing: "NotExpression",
3471 Token: tk[0],
3472 },
3473 Parsing: "AndExpression",
3474 Token: tk[0],
3475 },
3476 Parsing: "OrExpression",
3477 Token: tk[0],
3478 },
3479 Parsing: "FormulaeExpression",
3480 Token: tk[0],
3481 }
3482 }},
3483 {"~in", func(t *test, tk Tokens) { // 6
3484 t.Err = Error{
3485 Err: Error{
3486 Err: Error{
3487 Err: Error{
3488 Err: Error{
3489 Err: Error{
3490 Err: Error{
3491 Err: Error{
3492 Err: Error{
3493 Err: Error{
3494 Err: Error{
3495 Err: Error{
3496 Err: Error{
3497 Err: Error{
3498 Err: Error{
3499 Err: ErrInvalidSimpleExpression,
3500 Parsing: "SimpleExpression",
3501 Token: tk[1],
3502 },
3503 Parsing: "IndexOrCallExpression",
3504 Token: tk[1],
3505 },
3506 Parsing: "ScopeExpression",
3507 Token: tk[1],
3508 },
3509 Parsing: "SubsetExpression",
3510 Token: tk[1],
3511 },
3512 Parsing: "ExponentiationExpression",
3513 Token: tk[1],
3514 },
3515 Parsing: "UnaryExpression",
3516 Token: tk[1],
3517 },
3518 Parsing: "SequenceExpression",
3519 Token: tk[1],
3520 },
3521 Parsing: "PipeOrSpecialExpression",
3522 Token: tk[1],
3523 },
3524 Parsing: "MultiplicationExpression",
3525 Token: tk[1],
3526 },
3527 Parsing: "AdditionExpression",
3528 Token: tk[1],
3529 },
3530 Parsing: "RelationalExpression",
3531 Token: tk[1],
3532 },
3533 Parsing: "NotExpression",
3534 Token: tk[1],
3535 },
3536 Parsing: "AndExpression",
3537 Token: tk[1],
3538 },
3539 Parsing: "OrExpression",
3540 Token: tk[1],
3541 },
3542 Parsing: "FormulaeExpression",
3543 Token: tk[1],
3544 }
3545 }},
3546 {"~#abc\na", func(t *test, tk Tokens) { // 7
3547 t.Output = FormulaeExpression{
3548 FormulaeExpression: &FormulaeExpression{
3549 OrExpression: &OrExpression{
3550 AndExpression: AndExpression{
3551 NotExpression: NotExpression{
3552 RelationalExpression: RelationalExpression{
3553 AdditionExpression: AdditionExpression{
3554 MultiplicationExpression: MultiplicationExpression{
3555 PipeOrSpecialExpression: PipeOrSpecialExpression{
3556 SequenceExpression: SequenceExpression{
3557 UnaryExpression: UnaryExpression{
3558 ExponentiationExpression: ExponentiationExpression{
3559 SubsetExpression: SubsetExpression{
3560 ScopeExpression: ScopeExpression{
3561 IndexOrCallExpression: IndexOrCallExpression{
3562 SimpleExpression: &SimpleExpression{
3563 Identifier: &tk[3],
3564 Tokens: tk[3:4],
3565 },
3566 Tokens: tk[3:4],
3567 },
3568 Tokens: tk[3:4],
3569 },
3570 Tokens: tk[3:4],
3571 },
3572 Tokens: tk[3:4],
3573 },
3574 Tokens: tk[3:4],
3575 },
3576 Tokens: tk[3:4],
3577 },
3578 Tokens: tk[3:4],
3579 },
3580 Tokens: tk[3:4],
3581 },
3582 Tokens: tk[3:4],
3583 },
3584 Tokens: tk[3:4],
3585 },
3586 Tokens: tk[3:4],
3587 },
3588 Tokens: tk[3:4],
3589 },
3590 Tokens: tk[3:4],
3591 },
3592 Tokens: tk[3:4],
3593 },
3594 Comments: Comments{tk[1]},
3595 Tokens: tk[:4],
3596 }
3597 }},
3598 }, func(t *test) (Type, error) {
3599 var fe FormulaeExpression
3600
3601 err := fe.parse(&t.Tokens)
3602
3603 return fe, err
3604 })
3605 }
3606
3607 func TestOrExpression(t *testing.T) {
3608 doTests(t, []sourceFn{
3609 {"a", func(t *test, tk Tokens) { // 1
3610 t.Output = OrExpression{
3611 AndExpression: AndExpression{
3612 NotExpression: NotExpression{
3613 RelationalExpression: RelationalExpression{
3614 AdditionExpression: AdditionExpression{
3615 MultiplicationExpression: MultiplicationExpression{
3616 PipeOrSpecialExpression: PipeOrSpecialExpression{
3617 SequenceExpression: SequenceExpression{
3618 UnaryExpression: UnaryExpression{
3619 ExponentiationExpression: ExponentiationExpression{
3620 SubsetExpression: SubsetExpression{
3621 ScopeExpression: ScopeExpression{
3622 IndexOrCallExpression: IndexOrCallExpression{
3623 SimpleExpression: &SimpleExpression{
3624 Identifier: &tk[0],
3625 Tokens: tk[:1],
3626 },
3627 Tokens: tk[:1],
3628 },
3629 Tokens: tk[:1],
3630 },
3631 Tokens: tk[:1],
3632 },
3633 Tokens: tk[:1],
3634 },
3635 Tokens: tk[:1],
3636 },
3637 Tokens: tk[:1],
3638 },
3639 Tokens: tk[:1],
3640 },
3641 Tokens: tk[:1],
3642 },
3643 Tokens: tk[:1],
3644 },
3645 Tokens: tk[:1],
3646 },
3647 Tokens: tk[:1],
3648 },
3649 Tokens: tk[:1],
3650 },
3651 Tokens: tk[:1],
3652 }
3653 }},
3654 {"a|b", func(t *test, tk Tokens) { // 2
3655 t.Output = OrExpression{
3656 AndExpression: AndExpression{
3657 NotExpression: NotExpression{
3658 RelationalExpression: RelationalExpression{
3659 AdditionExpression: AdditionExpression{
3660 MultiplicationExpression: MultiplicationExpression{
3661 PipeOrSpecialExpression: PipeOrSpecialExpression{
3662 SequenceExpression: SequenceExpression{
3663 UnaryExpression: UnaryExpression{
3664 ExponentiationExpression: ExponentiationExpression{
3665 SubsetExpression: SubsetExpression{
3666 ScopeExpression: ScopeExpression{
3667 IndexOrCallExpression: IndexOrCallExpression{
3668 SimpleExpression: &SimpleExpression{
3669 Identifier: &tk[0],
3670 Tokens: tk[:1],
3671 },
3672 Tokens: tk[:1],
3673 },
3674 Tokens: tk[:1],
3675 },
3676 Tokens: tk[:1],
3677 },
3678 Tokens: tk[:1],
3679 },
3680 Tokens: tk[:1],
3681 },
3682 Tokens: tk[:1],
3683 },
3684 Tokens: tk[:1],
3685 },
3686 Tokens: tk[:1],
3687 },
3688 Tokens: tk[:1],
3689 },
3690 Tokens: tk[:1],
3691 },
3692 Tokens: tk[:1],
3693 },
3694 Tokens: tk[:1],
3695 },
3696 OrType: OrVectorized,
3697 OrExpression: &OrExpression{
3698 AndExpression: AndExpression{
3699 NotExpression: NotExpression{
3700 RelationalExpression: RelationalExpression{
3701 AdditionExpression: AdditionExpression{
3702 MultiplicationExpression: MultiplicationExpression{
3703 PipeOrSpecialExpression: PipeOrSpecialExpression{
3704 SequenceExpression: SequenceExpression{
3705 UnaryExpression: UnaryExpression{
3706 ExponentiationExpression: ExponentiationExpression{
3707 SubsetExpression: SubsetExpression{
3708 ScopeExpression: ScopeExpression{
3709 IndexOrCallExpression: IndexOrCallExpression{
3710 SimpleExpression: &SimpleExpression{
3711 Identifier: &tk[2],
3712 Tokens: tk[2:3],
3713 },
3714 Tokens: tk[2:3],
3715 },
3716 Tokens: tk[2:3],
3717 },
3718 Tokens: tk[2:3],
3719 },
3720 Tokens: tk[2:3],
3721 },
3722 Tokens: tk[2:3],
3723 },
3724 Tokens: tk[2:3],
3725 },
3726 Tokens: tk[2:3],
3727 },
3728 Tokens: tk[2:3],
3729 },
3730 Tokens: tk[2:3],
3731 },
3732 Tokens: tk[2:3],
3733 },
3734 Tokens: tk[2:3],
3735 },
3736 Tokens: tk[2:3],
3737 },
3738 Tokens: tk[2:3],
3739 },
3740 Tokens: tk[:3],
3741 }
3742 }},
3743 {"a | b", func(t *test, tk Tokens) { // 3
3744 t.Output = OrExpression{
3745 AndExpression: AndExpression{
3746 NotExpression: NotExpression{
3747 RelationalExpression: RelationalExpression{
3748 AdditionExpression: AdditionExpression{
3749 MultiplicationExpression: MultiplicationExpression{
3750 PipeOrSpecialExpression: PipeOrSpecialExpression{
3751 SequenceExpression: SequenceExpression{
3752 UnaryExpression: UnaryExpression{
3753 ExponentiationExpression: ExponentiationExpression{
3754 SubsetExpression: SubsetExpression{
3755 ScopeExpression: ScopeExpression{
3756 IndexOrCallExpression: IndexOrCallExpression{
3757 SimpleExpression: &SimpleExpression{
3758 Identifier: &tk[0],
3759 Tokens: tk[:1],
3760 },
3761 Tokens: tk[:1],
3762 },
3763 Tokens: tk[:1],
3764 },
3765 Tokens: tk[:1],
3766 },
3767 Tokens: tk[:1],
3768 },
3769 Tokens: tk[:1],
3770 },
3771 Tokens: tk[:1],
3772 },
3773 Tokens: tk[:1],
3774 },
3775 Tokens: tk[:1],
3776 },
3777 Tokens: tk[:1],
3778 },
3779 Tokens: tk[:1],
3780 },
3781 Tokens: tk[:1],
3782 },
3783 Tokens: tk[:1],
3784 },
3785 OrType: OrVectorized,
3786 OrExpression: &OrExpression{
3787 AndExpression: AndExpression{
3788 NotExpression: NotExpression{
3789 RelationalExpression: RelationalExpression{
3790 AdditionExpression: AdditionExpression{
3791 MultiplicationExpression: MultiplicationExpression{
3792 PipeOrSpecialExpression: PipeOrSpecialExpression{
3793 SequenceExpression: SequenceExpression{
3794 UnaryExpression: UnaryExpression{
3795 ExponentiationExpression: ExponentiationExpression{
3796 SubsetExpression: SubsetExpression{
3797 ScopeExpression: ScopeExpression{
3798 IndexOrCallExpression: IndexOrCallExpression{
3799 SimpleExpression: &SimpleExpression{
3800 Identifier: &tk[4],
3801 Tokens: tk[4:5],
3802 },
3803 Tokens: tk[4:5],
3804 },
3805 Tokens: tk[4:5],
3806 },
3807 Tokens: tk[4:5],
3808 },
3809 Tokens: tk[4:5],
3810 },
3811 Tokens: tk[4:5],
3812 },
3813 Tokens: tk[4:5],
3814 },
3815 Tokens: tk[4:5],
3816 },
3817 Tokens: tk[4:5],
3818 },
3819 Tokens: tk[4:5],
3820 },
3821 Tokens: tk[4:5],
3822 },
3823 Tokens: tk[4:5],
3824 },
3825 Tokens: tk[4:5],
3826 },
3827 Tokens: tk[4:5],
3828 },
3829 Tokens: tk[:5],
3830 }
3831 }},
3832 {"a||b", func(t *test, tk Tokens) { // 4
3833 t.Output = OrExpression{
3834 AndExpression: AndExpression{
3835 NotExpression: NotExpression{
3836 RelationalExpression: RelationalExpression{
3837 AdditionExpression: AdditionExpression{
3838 MultiplicationExpression: MultiplicationExpression{
3839 PipeOrSpecialExpression: PipeOrSpecialExpression{
3840 SequenceExpression: SequenceExpression{
3841 UnaryExpression: UnaryExpression{
3842 ExponentiationExpression: ExponentiationExpression{
3843 SubsetExpression: SubsetExpression{
3844 ScopeExpression: ScopeExpression{
3845 IndexOrCallExpression: IndexOrCallExpression{
3846 SimpleExpression: &SimpleExpression{
3847 Identifier: &tk[0],
3848 Tokens: tk[:1],
3849 },
3850 Tokens: tk[:1],
3851 },
3852 Tokens: tk[:1],
3853 },
3854 Tokens: tk[:1],
3855 },
3856 Tokens: tk[:1],
3857 },
3858 Tokens: tk[:1],
3859 },
3860 Tokens: tk[:1],
3861 },
3862 Tokens: tk[:1],
3863 },
3864 Tokens: tk[:1],
3865 },
3866 Tokens: tk[:1],
3867 },
3868 Tokens: tk[:1],
3869 },
3870 Tokens: tk[:1],
3871 },
3872 Tokens: tk[:1],
3873 },
3874 OrType: OrNotVectorized,
3875 OrExpression: &OrExpression{
3876 AndExpression: AndExpression{
3877 NotExpression: NotExpression{
3878 RelationalExpression: RelationalExpression{
3879 AdditionExpression: AdditionExpression{
3880 MultiplicationExpression: MultiplicationExpression{
3881 PipeOrSpecialExpression: PipeOrSpecialExpression{
3882 SequenceExpression: SequenceExpression{
3883 UnaryExpression: UnaryExpression{
3884 ExponentiationExpression: ExponentiationExpression{
3885 SubsetExpression: SubsetExpression{
3886 ScopeExpression: ScopeExpression{
3887 IndexOrCallExpression: IndexOrCallExpression{
3888 SimpleExpression: &SimpleExpression{
3889 Identifier: &tk[2],
3890 Tokens: tk[2:3],
3891 },
3892 Tokens: tk[2:3],
3893 },
3894 Tokens: tk[2:3],
3895 },
3896 Tokens: tk[2:3],
3897 },
3898 Tokens: tk[2:3],
3899 },
3900 Tokens: tk[2:3],
3901 },
3902 Tokens: tk[2:3],
3903 },
3904 Tokens: tk[2:3],
3905 },
3906 Tokens: tk[2:3],
3907 },
3908 Tokens: tk[2:3],
3909 },
3910 Tokens: tk[2:3],
3911 },
3912 Tokens: tk[2:3],
3913 },
3914 Tokens: tk[2:3],
3915 },
3916 Tokens: tk[2:3],
3917 },
3918 Tokens: tk[:3],
3919 }
3920 }},
3921 {"a || b", func(t *test, tk Tokens) { // 5
3922 t.Output = OrExpression{
3923 AndExpression: AndExpression{
3924 NotExpression: NotExpression{
3925 RelationalExpression: RelationalExpression{
3926 AdditionExpression: AdditionExpression{
3927 MultiplicationExpression: MultiplicationExpression{
3928 PipeOrSpecialExpression: PipeOrSpecialExpression{
3929 SequenceExpression: SequenceExpression{
3930 UnaryExpression: UnaryExpression{
3931 ExponentiationExpression: ExponentiationExpression{
3932 SubsetExpression: SubsetExpression{
3933 ScopeExpression: ScopeExpression{
3934 IndexOrCallExpression: IndexOrCallExpression{
3935 SimpleExpression: &SimpleExpression{
3936 Identifier: &tk[0],
3937 Tokens: tk[:1],
3938 },
3939 Tokens: tk[:1],
3940 },
3941 Tokens: tk[:1],
3942 },
3943 Tokens: tk[:1],
3944 },
3945 Tokens: tk[:1],
3946 },
3947 Tokens: tk[:1],
3948 },
3949 Tokens: tk[:1],
3950 },
3951 Tokens: tk[:1],
3952 },
3953 Tokens: tk[:1],
3954 },
3955 Tokens: tk[:1],
3956 },
3957 Tokens: tk[:1],
3958 },
3959 Tokens: tk[:1],
3960 },
3961 Tokens: tk[:1],
3962 },
3963 OrType: OrNotVectorized,
3964 OrExpression: &OrExpression{
3965 AndExpression: AndExpression{
3966 NotExpression: NotExpression{
3967 RelationalExpression: RelationalExpression{
3968 AdditionExpression: AdditionExpression{
3969 MultiplicationExpression: MultiplicationExpression{
3970 PipeOrSpecialExpression: PipeOrSpecialExpression{
3971 SequenceExpression: SequenceExpression{
3972 UnaryExpression: UnaryExpression{
3973 ExponentiationExpression: ExponentiationExpression{
3974 SubsetExpression: SubsetExpression{
3975 ScopeExpression: ScopeExpression{
3976 IndexOrCallExpression: IndexOrCallExpression{
3977 SimpleExpression: &SimpleExpression{
3978 Identifier: &tk[4],
3979 Tokens: tk[4:5],
3980 },
3981 Tokens: tk[4:5],
3982 },
3983 Tokens: tk[4:5],
3984 },
3985 Tokens: tk[4:5],
3986 },
3987 Tokens: tk[4:5],
3988 },
3989 Tokens: tk[4:5],
3990 },
3991 Tokens: tk[4:5],
3992 },
3993 Tokens: tk[4:5],
3994 },
3995 Tokens: tk[4:5],
3996 },
3997 Tokens: tk[4:5],
3998 },
3999 Tokens: tk[4:5],
4000 },
4001 Tokens: tk[4:5],
4002 },
4003 Tokens: tk[4:5],
4004 },
4005 Tokens: tk[4:5],
4006 },
4007 Tokens: tk[:5],
4008 }
4009 }},
4010 {"in", func(t *test, tk Tokens) { // 6
4011 t.Err = Error{
4012 Err: Error{
4013 Err: Error{
4014 Err: Error{
4015 Err: Error{
4016 Err: Error{
4017 Err: Error{
4018 Err: Error{
4019 Err: Error{
4020 Err: Error{
4021 Err: Error{
4022 Err: Error{
4023 Err: Error{
4024 Err: Error{
4025 Err: ErrInvalidSimpleExpression,
4026 Parsing: "SimpleExpression",
4027 Token: tk[0],
4028 },
4029 Parsing: "IndexOrCallExpression",
4030 Token: tk[0],
4031 },
4032 Parsing: "ScopeExpression",
4033 Token: tk[0],
4034 },
4035 Parsing: "SubsetExpression",
4036 Token: tk[0],
4037 },
4038 Parsing: "ExponentiationExpression",
4039 Token: tk[0],
4040 },
4041 Parsing: "UnaryExpression",
4042 Token: tk[0],
4043 },
4044 Parsing: "SequenceExpression",
4045 Token: tk[0],
4046 },
4047 Parsing: "PipeOrSpecialExpression",
4048 Token: tk[0],
4049 },
4050 Parsing: "MultiplicationExpression",
4051 Token: tk[0],
4052 },
4053 Parsing: "AdditionExpression",
4054 Token: tk[0],
4055 },
4056 Parsing: "RelationalExpression",
4057 Token: tk[0],
4058 },
4059 Parsing: "NotExpression",
4060 Token: tk[0],
4061 },
4062 Parsing: "AndExpression",
4063 Token: tk[0],
4064 },
4065 Parsing: "OrExpression",
4066 Token: tk[0],
4067 }
4068 }},
4069 {"a|in", func(t *test, tk Tokens) { // 7
4070 t.Err = Error{
4071 Err: Error{
4072 Err: Error{
4073 Err: Error{
4074 Err: Error{
4075 Err: Error{
4076 Err: Error{
4077 Err: Error{
4078 Err: Error{
4079 Err: Error{
4080 Err: Error{
4081 Err: Error{
4082 Err: Error{
4083 Err: Error{
4084 Err: Error{
4085 Err: ErrInvalidSimpleExpression,
4086 Parsing: "SimpleExpression",
4087 Token: tk[2],
4088 },
4089 Parsing: "IndexOrCallExpression",
4090 Token: tk[2],
4091 },
4092 Parsing: "ScopeExpression",
4093 Token: tk[2],
4094 },
4095 Parsing: "SubsetExpression",
4096 Token: tk[2],
4097 },
4098 Parsing: "ExponentiationExpression",
4099 Token: tk[2],
4100 },
4101 Parsing: "UnaryExpression",
4102 Token: tk[2],
4103 },
4104 Parsing: "SequenceExpression",
4105 Token: tk[2],
4106 },
4107 Parsing: "PipeOrSpecialExpression",
4108 Token: tk[2],
4109 },
4110 Parsing: "MultiplicationExpression",
4111 Token: tk[2],
4112 },
4113 Parsing: "AdditionExpression",
4114 Token: tk[2],
4115 },
4116 Parsing: "RelationalExpression",
4117 Token: tk[2],
4118 },
4119 Parsing: "NotExpression",
4120 Token: tk[2],
4121 },
4122 Parsing: "AndExpression",
4123 Token: tk[2],
4124 },
4125 Parsing: "OrExpression",
4126 Token: tk[2],
4127 },
4128 Parsing: "OrExpression",
4129 Token: tk[2],
4130 }
4131 }},
4132 {"a | #abc\n b", func(t *test, tk Tokens) { // 8
4133 t.Output = OrExpression{
4134 AndExpression: AndExpression{
4135 NotExpression: NotExpression{
4136 RelationalExpression: RelationalExpression{
4137 AdditionExpression: AdditionExpression{
4138 MultiplicationExpression: MultiplicationExpression{
4139 PipeOrSpecialExpression: PipeOrSpecialExpression{
4140 SequenceExpression: SequenceExpression{
4141 UnaryExpression: UnaryExpression{
4142 ExponentiationExpression: ExponentiationExpression{
4143 SubsetExpression: SubsetExpression{
4144 ScopeExpression: ScopeExpression{
4145 IndexOrCallExpression: IndexOrCallExpression{
4146 SimpleExpression: &SimpleExpression{
4147 Identifier: &tk[0],
4148 Tokens: tk[:1],
4149 },
4150 Tokens: tk[:1],
4151 },
4152 Tokens: tk[:1],
4153 },
4154 Tokens: tk[:1],
4155 },
4156 Tokens: tk[:1],
4157 },
4158 Tokens: tk[:1],
4159 },
4160 Tokens: tk[:1],
4161 },
4162 Tokens: tk[:1],
4163 },
4164 Tokens: tk[:1],
4165 },
4166 Tokens: tk[:1],
4167 },
4168 Tokens: tk[:1],
4169 },
4170 Tokens: tk[:1],
4171 },
4172 Tokens: tk[:1],
4173 },
4174 OrType: OrVectorized,
4175 OrExpression: &OrExpression{
4176 AndExpression: AndExpression{
4177 NotExpression: NotExpression{
4178 RelationalExpression: RelationalExpression{
4179 AdditionExpression: AdditionExpression{
4180 MultiplicationExpression: MultiplicationExpression{
4181 PipeOrSpecialExpression: PipeOrSpecialExpression{
4182 SequenceExpression: SequenceExpression{
4183 UnaryExpression: UnaryExpression{
4184 ExponentiationExpression: ExponentiationExpression{
4185 SubsetExpression: SubsetExpression{
4186 ScopeExpression: ScopeExpression{
4187 IndexOrCallExpression: IndexOrCallExpression{
4188 SimpleExpression: &SimpleExpression{
4189 Identifier: &tk[7],
4190 Tokens: tk[7:8],
4191 },
4192 Tokens: tk[7:8],
4193 },
4194 Tokens: tk[7:8],
4195 },
4196 Tokens: tk[7:8],
4197 },
4198 Tokens: tk[7:8],
4199 },
4200 Tokens: tk[7:8],
4201 },
4202 Tokens: tk[7:8],
4203 },
4204 Tokens: tk[7:8],
4205 },
4206 Tokens: tk[7:8],
4207 },
4208 Tokens: tk[7:8],
4209 },
4210 Tokens: tk[7:8],
4211 },
4212 Tokens: tk[7:8],
4213 },
4214 Tokens: tk[7:8],
4215 },
4216 Tokens: tk[7:8],
4217 },
4218 Comments: [2]Comments{nil, {tk[4]}},
4219 Tokens: tk[:8],
4220 }
4221 }},
4222 }, func(t *test) (Type, error) {
4223 var oe OrExpression
4224
4225 err := oe.parse(&t.Tokens)
4226
4227 return oe, err
4228 })
4229 }
4230
4231 func TestAndExpression(t *testing.T) {
4232 doTests(t, []sourceFn{
4233 {"a", func(t *test, tk Tokens) { // 1
4234 t.Output = AndExpression{
4235 NotExpression: NotExpression{
4236 RelationalExpression: RelationalExpression{
4237 AdditionExpression: AdditionExpression{
4238 MultiplicationExpression: MultiplicationExpression{
4239 PipeOrSpecialExpression: PipeOrSpecialExpression{
4240 SequenceExpression: SequenceExpression{
4241 UnaryExpression: UnaryExpression{
4242 ExponentiationExpression: ExponentiationExpression{
4243 SubsetExpression: SubsetExpression{
4244 ScopeExpression: ScopeExpression{
4245 IndexOrCallExpression: IndexOrCallExpression{
4246 SimpleExpression: &SimpleExpression{
4247 Identifier: &tk[0],
4248 Tokens: tk[:1],
4249 },
4250 Tokens: tk[:1],
4251 },
4252 Tokens: tk[:1],
4253 },
4254 Tokens: tk[:1],
4255 },
4256 Tokens: tk[:1],
4257 },
4258 Tokens: tk[:1],
4259 },
4260 Tokens: tk[:1],
4261 },
4262 Tokens: tk[:1],
4263 },
4264 Tokens: tk[:1],
4265 },
4266 Tokens: tk[:1],
4267 },
4268 Tokens: tk[:1],
4269 },
4270 Tokens: tk[:1],
4271 },
4272 Tokens: tk[:1],
4273 }
4274 }},
4275 {"a&b", func(t *test, tk Tokens) { // 2
4276 t.Output = AndExpression{
4277 NotExpression: NotExpression{
4278 RelationalExpression: RelationalExpression{
4279 AdditionExpression: AdditionExpression{
4280 MultiplicationExpression: MultiplicationExpression{
4281 PipeOrSpecialExpression: PipeOrSpecialExpression{
4282 SequenceExpression: SequenceExpression{
4283 UnaryExpression: UnaryExpression{
4284 ExponentiationExpression: ExponentiationExpression{
4285 SubsetExpression: SubsetExpression{
4286 ScopeExpression: ScopeExpression{
4287 IndexOrCallExpression: IndexOrCallExpression{
4288 SimpleExpression: &SimpleExpression{
4289 Identifier: &tk[0],
4290 Tokens: tk[:1],
4291 },
4292 Tokens: tk[:1],
4293 },
4294 Tokens: tk[:1],
4295 },
4296 Tokens: tk[:1],
4297 },
4298 Tokens: tk[:1],
4299 },
4300 Tokens: tk[:1],
4301 },
4302 Tokens: tk[:1],
4303 },
4304 Tokens: tk[:1],
4305 },
4306 Tokens: tk[:1],
4307 },
4308 Tokens: tk[:1],
4309 },
4310 Tokens: tk[:1],
4311 },
4312 Tokens: tk[:1],
4313 },
4314 AndType: AndVectorized,
4315 AndExpression: &AndExpression{
4316 NotExpression: NotExpression{
4317 RelationalExpression: RelationalExpression{
4318 AdditionExpression: AdditionExpression{
4319 MultiplicationExpression: MultiplicationExpression{
4320 PipeOrSpecialExpression: PipeOrSpecialExpression{
4321 SequenceExpression: SequenceExpression{
4322 UnaryExpression: UnaryExpression{
4323 ExponentiationExpression: ExponentiationExpression{
4324 SubsetExpression: SubsetExpression{
4325 ScopeExpression: ScopeExpression{
4326 IndexOrCallExpression: IndexOrCallExpression{
4327 SimpleExpression: &SimpleExpression{
4328 Identifier: &tk[2],
4329 Tokens: tk[2:3],
4330 },
4331 Tokens: tk[2:3],
4332 },
4333 Tokens: tk[2:3],
4334 },
4335 Tokens: tk[2:3],
4336 },
4337 Tokens: tk[2:3],
4338 },
4339 Tokens: tk[2:3],
4340 },
4341 Tokens: tk[2:3],
4342 },
4343 Tokens: tk[2:3],
4344 },
4345 Tokens: tk[2:3],
4346 },
4347 Tokens: tk[2:3],
4348 },
4349 Tokens: tk[2:3],
4350 },
4351 Tokens: tk[2:3],
4352 },
4353 Tokens: tk[2:3],
4354 },
4355 Tokens: tk[:3],
4356 }
4357 }},
4358 {"a & b", func(t *test, tk Tokens) { // 3
4359 t.Output = AndExpression{
4360 NotExpression: NotExpression{
4361 RelationalExpression: RelationalExpression{
4362 AdditionExpression: AdditionExpression{
4363 MultiplicationExpression: MultiplicationExpression{
4364 PipeOrSpecialExpression: PipeOrSpecialExpression{
4365 SequenceExpression: SequenceExpression{
4366 UnaryExpression: UnaryExpression{
4367 ExponentiationExpression: ExponentiationExpression{
4368 SubsetExpression: SubsetExpression{
4369 ScopeExpression: ScopeExpression{
4370 IndexOrCallExpression: IndexOrCallExpression{
4371 SimpleExpression: &SimpleExpression{
4372 Identifier: &tk[0],
4373 Tokens: tk[:1],
4374 },
4375 Tokens: tk[:1],
4376 },
4377 Tokens: tk[:1],
4378 },
4379 Tokens: tk[:1],
4380 },
4381 Tokens: tk[:1],
4382 },
4383 Tokens: tk[:1],
4384 },
4385 Tokens: tk[:1],
4386 },
4387 Tokens: tk[:1],
4388 },
4389 Tokens: tk[:1],
4390 },
4391 Tokens: tk[:1],
4392 },
4393 Tokens: tk[:1],
4394 },
4395 Tokens: tk[:1],
4396 },
4397 AndType: AndVectorized,
4398 AndExpression: &AndExpression{
4399 NotExpression: NotExpression{
4400 RelationalExpression: RelationalExpression{
4401 AdditionExpression: AdditionExpression{
4402 MultiplicationExpression: MultiplicationExpression{
4403 PipeOrSpecialExpression: PipeOrSpecialExpression{
4404 SequenceExpression: SequenceExpression{
4405 UnaryExpression: UnaryExpression{
4406 ExponentiationExpression: ExponentiationExpression{
4407 SubsetExpression: SubsetExpression{
4408 ScopeExpression: ScopeExpression{
4409 IndexOrCallExpression: IndexOrCallExpression{
4410 SimpleExpression: &SimpleExpression{
4411 Identifier: &tk[4],
4412 Tokens: tk[4:5],
4413 },
4414 Tokens: tk[4:5],
4415 },
4416 Tokens: tk[4:5],
4417 },
4418 Tokens: tk[4:5],
4419 },
4420 Tokens: tk[4:5],
4421 },
4422 Tokens: tk[4:5],
4423 },
4424 Tokens: tk[4:5],
4425 },
4426 Tokens: tk[4:5],
4427 },
4428 Tokens: tk[4:5],
4429 },
4430 Tokens: tk[4:5],
4431 },
4432 Tokens: tk[4:5],
4433 },
4434 Tokens: tk[4:5],
4435 },
4436 Tokens: tk[4:5],
4437 },
4438 Tokens: tk[:5],
4439 }
4440 }},
4441 {"a&&b", func(t *test, tk Tokens) { // 4
4442 t.Output = AndExpression{
4443 NotExpression: NotExpression{
4444 RelationalExpression: RelationalExpression{
4445 AdditionExpression: AdditionExpression{
4446 MultiplicationExpression: MultiplicationExpression{
4447 PipeOrSpecialExpression: PipeOrSpecialExpression{
4448 SequenceExpression: SequenceExpression{
4449 UnaryExpression: UnaryExpression{
4450 ExponentiationExpression: ExponentiationExpression{
4451 SubsetExpression: SubsetExpression{
4452 ScopeExpression: ScopeExpression{
4453 IndexOrCallExpression: IndexOrCallExpression{
4454 SimpleExpression: &SimpleExpression{
4455 Identifier: &tk[0],
4456 Tokens: tk[:1],
4457 },
4458 Tokens: tk[:1],
4459 },
4460 Tokens: tk[:1],
4461 },
4462 Tokens: tk[:1],
4463 },
4464 Tokens: tk[:1],
4465 },
4466 Tokens: tk[:1],
4467 },
4468 Tokens: tk[:1],
4469 },
4470 Tokens: tk[:1],
4471 },
4472 Tokens: tk[:1],
4473 },
4474 Tokens: tk[:1],
4475 },
4476 Tokens: tk[:1],
4477 },
4478 Tokens: tk[:1],
4479 },
4480 AndType: AndNotVectorized,
4481 AndExpression: &AndExpression{
4482 NotExpression: NotExpression{
4483 RelationalExpression: RelationalExpression{
4484 AdditionExpression: AdditionExpression{
4485 MultiplicationExpression: MultiplicationExpression{
4486 PipeOrSpecialExpression: PipeOrSpecialExpression{
4487 SequenceExpression: SequenceExpression{
4488 UnaryExpression: UnaryExpression{
4489 ExponentiationExpression: ExponentiationExpression{
4490 SubsetExpression: SubsetExpression{
4491 ScopeExpression: ScopeExpression{
4492 IndexOrCallExpression: IndexOrCallExpression{
4493 SimpleExpression: &SimpleExpression{
4494 Identifier: &tk[2],
4495 Tokens: tk[2:3],
4496 },
4497 Tokens: tk[2:3],
4498 },
4499 Tokens: tk[2:3],
4500 },
4501 Tokens: tk[2:3],
4502 },
4503 Tokens: tk[2:3],
4504 },
4505 Tokens: tk[2:3],
4506 },
4507 Tokens: tk[2:3],
4508 },
4509 Tokens: tk[2:3],
4510 },
4511 Tokens: tk[2:3],
4512 },
4513 Tokens: tk[2:3],
4514 },
4515 Tokens: tk[2:3],
4516 },
4517 Tokens: tk[2:3],
4518 },
4519 Tokens: tk[2:3],
4520 },
4521 Tokens: tk[:3],
4522 }
4523 }},
4524 {"a && b", func(t *test, tk Tokens) { // 5
4525 t.Output = AndExpression{
4526 NotExpression: NotExpression{
4527 RelationalExpression: RelationalExpression{
4528 AdditionExpression: AdditionExpression{
4529 MultiplicationExpression: MultiplicationExpression{
4530 PipeOrSpecialExpression: PipeOrSpecialExpression{
4531 SequenceExpression: SequenceExpression{
4532 UnaryExpression: UnaryExpression{
4533 ExponentiationExpression: ExponentiationExpression{
4534 SubsetExpression: SubsetExpression{
4535 ScopeExpression: ScopeExpression{
4536 IndexOrCallExpression: IndexOrCallExpression{
4537 SimpleExpression: &SimpleExpression{
4538 Identifier: &tk[0],
4539 Tokens: tk[:1],
4540 },
4541 Tokens: tk[:1],
4542 },
4543 Tokens: tk[:1],
4544 },
4545 Tokens: tk[:1],
4546 },
4547 Tokens: tk[:1],
4548 },
4549 Tokens: tk[:1],
4550 },
4551 Tokens: tk[:1],
4552 },
4553 Tokens: tk[:1],
4554 },
4555 Tokens: tk[:1],
4556 },
4557 Tokens: tk[:1],
4558 },
4559 Tokens: tk[:1],
4560 },
4561 Tokens: tk[:1],
4562 },
4563 AndType: AndNotVectorized,
4564 AndExpression: &AndExpression{
4565 NotExpression: NotExpression{
4566 RelationalExpression: RelationalExpression{
4567 AdditionExpression: AdditionExpression{
4568 MultiplicationExpression: MultiplicationExpression{
4569 PipeOrSpecialExpression: PipeOrSpecialExpression{
4570 SequenceExpression: SequenceExpression{
4571 UnaryExpression: UnaryExpression{
4572 ExponentiationExpression: ExponentiationExpression{
4573 SubsetExpression: SubsetExpression{
4574 ScopeExpression: ScopeExpression{
4575 IndexOrCallExpression: IndexOrCallExpression{
4576 SimpleExpression: &SimpleExpression{
4577 Identifier: &tk[4],
4578 Tokens: tk[4:5],
4579 },
4580 Tokens: tk[4:5],
4581 },
4582 Tokens: tk[4:5],
4583 },
4584 Tokens: tk[4:5],
4585 },
4586 Tokens: tk[4:5],
4587 },
4588 Tokens: tk[4:5],
4589 },
4590 Tokens: tk[4:5],
4591 },
4592 Tokens: tk[4:5],
4593 },
4594 Tokens: tk[4:5],
4595 },
4596 Tokens: tk[4:5],
4597 },
4598 Tokens: tk[4:5],
4599 },
4600 Tokens: tk[4:5],
4601 },
4602 Tokens: tk[4:5],
4603 },
4604 Tokens: tk[:5],
4605 }
4606 }},
4607 {"in", func(t *test, tk Tokens) { // 6
4608 t.Err = Error{
4609 Err: Error{
4610 Err: Error{
4611 Err: Error{
4612 Err: Error{
4613 Err: Error{
4614 Err: Error{
4615 Err: Error{
4616 Err: Error{
4617 Err: Error{
4618 Err: Error{
4619 Err: Error{
4620 Err: Error{
4621 Err: ErrInvalidSimpleExpression,
4622 Parsing: "SimpleExpression",
4623 Token: tk[0],
4624 },
4625 Parsing: "IndexOrCallExpression",
4626 Token: tk[0],
4627 },
4628 Parsing: "ScopeExpression",
4629 Token: tk[0],
4630 },
4631 Parsing: "SubsetExpression",
4632 Token: tk[0],
4633 },
4634 Parsing: "ExponentiationExpression",
4635 Token: tk[0],
4636 },
4637 Parsing: "UnaryExpression",
4638 Token: tk[0],
4639 },
4640 Parsing: "SequenceExpression",
4641 Token: tk[0],
4642 },
4643 Parsing: "PipeOrSpecialExpression",
4644 Token: tk[0],
4645 },
4646 Parsing: "MultiplicationExpression",
4647 Token: tk[0],
4648 },
4649 Parsing: "AdditionExpression",
4650 Token: tk[0],
4651 },
4652 Parsing: "RelationalExpression",
4653 Token: tk[0],
4654 },
4655 Parsing: "NotExpression",
4656 Token: tk[0],
4657 },
4658 Parsing: "AndExpression",
4659 Token: tk[0],
4660 }
4661 }},
4662 {"a&in", func(t *test, tk Tokens) { // 7
4663 t.Err = Error{
4664 Err: Error{
4665 Err: Error{
4666 Err: Error{
4667 Err: Error{
4668 Err: Error{
4669 Err: Error{
4670 Err: Error{
4671 Err: Error{
4672 Err: Error{
4673 Err: Error{
4674 Err: Error{
4675 Err: Error{
4676 Err: Error{
4677 Err: ErrInvalidSimpleExpression,
4678 Parsing: "SimpleExpression",
4679 Token: tk[2],
4680 },
4681 Parsing: "IndexOrCallExpression",
4682 Token: tk[2],
4683 },
4684 Parsing: "ScopeExpression",
4685 Token: tk[2],
4686 },
4687 Parsing: "SubsetExpression",
4688 Token: tk[2],
4689 },
4690 Parsing: "ExponentiationExpression",
4691 Token: tk[2],
4692 },
4693 Parsing: "UnaryExpression",
4694 Token: tk[2],
4695 },
4696 Parsing: "SequenceExpression",
4697 Token: tk[2],
4698 },
4699 Parsing: "PipeOrSpecialExpression",
4700 Token: tk[2],
4701 },
4702 Parsing: "MultiplicationExpression",
4703 Token: tk[2],
4704 },
4705 Parsing: "AdditionExpression",
4706 Token: tk[2],
4707 },
4708 Parsing: "RelationalExpression",
4709 Token: tk[2],
4710 },
4711 Parsing: "NotExpression",
4712 Token: tk[2],
4713 },
4714 Parsing: "AndExpression",
4715 Token: tk[2],
4716 },
4717 Parsing: "AndExpression",
4718 Token: tk[2],
4719 }
4720 }},
4721 {"a & #abc\n b", func(t *test, tk Tokens) { // 8
4722 t.Output = AndExpression{
4723 NotExpression: NotExpression{
4724 RelationalExpression: RelationalExpression{
4725 AdditionExpression: AdditionExpression{
4726 MultiplicationExpression: MultiplicationExpression{
4727 PipeOrSpecialExpression: PipeOrSpecialExpression{
4728 SequenceExpression: SequenceExpression{
4729 UnaryExpression: UnaryExpression{
4730 ExponentiationExpression: ExponentiationExpression{
4731 SubsetExpression: SubsetExpression{
4732 ScopeExpression: ScopeExpression{
4733 IndexOrCallExpression: IndexOrCallExpression{
4734 SimpleExpression: &SimpleExpression{
4735 Identifier: &tk[0],
4736 Tokens: tk[:1],
4737 },
4738 Tokens: tk[:1],
4739 },
4740 Tokens: tk[:1],
4741 },
4742 Tokens: tk[:1],
4743 },
4744 Tokens: tk[:1],
4745 },
4746 Tokens: tk[:1],
4747 },
4748 Tokens: tk[:1],
4749 },
4750 Tokens: tk[:1],
4751 },
4752 Tokens: tk[:1],
4753 },
4754 Tokens: tk[:1],
4755 },
4756 Tokens: tk[:1],
4757 },
4758 Tokens: tk[:1],
4759 },
4760 AndType: AndVectorized,
4761 AndExpression: &AndExpression{
4762 NotExpression: NotExpression{
4763 RelationalExpression: RelationalExpression{
4764 AdditionExpression: AdditionExpression{
4765 MultiplicationExpression: MultiplicationExpression{
4766 PipeOrSpecialExpression: PipeOrSpecialExpression{
4767 SequenceExpression: SequenceExpression{
4768 UnaryExpression: UnaryExpression{
4769 ExponentiationExpression: ExponentiationExpression{
4770 SubsetExpression: SubsetExpression{
4771 ScopeExpression: ScopeExpression{
4772 IndexOrCallExpression: IndexOrCallExpression{
4773 SimpleExpression: &SimpleExpression{
4774 Identifier: &tk[7],
4775 Tokens: tk[7:8],
4776 },
4777 Tokens: tk[7:8],
4778 },
4779 Tokens: tk[7:8],
4780 },
4781 Tokens: tk[7:8],
4782 },
4783 Tokens: tk[7:8],
4784 },
4785 Tokens: tk[7:8],
4786 },
4787 Tokens: tk[7:8],
4788 },
4789 Tokens: tk[7:8],
4790 },
4791 Tokens: tk[7:8],
4792 },
4793 Tokens: tk[7:8],
4794 },
4795 Tokens: tk[7:8],
4796 },
4797 Tokens: tk[7:8],
4798 },
4799 Tokens: tk[7:8],
4800 },
4801 Comments: [2]Comments{nil, {tk[4]}},
4802 Tokens: tk[:8],
4803 }
4804 }},
4805 }, func(t *test) (Type, error) {
4806 var ae AndExpression
4807
4808 err := ae.parse(&t.Tokens)
4809
4810 return ae, err
4811 })
4812 }
4813
4814 func TestNotExpression(t *testing.T) {
4815 doTests(t, []sourceFn{
4816 {"a", func(t *test, tk Tokens) { // 1
4817 t.Output = NotExpression{
4818 RelationalExpression: RelationalExpression{
4819 AdditionExpression: AdditionExpression{
4820 MultiplicationExpression: MultiplicationExpression{
4821 PipeOrSpecialExpression: PipeOrSpecialExpression{
4822 SequenceExpression: SequenceExpression{
4823 UnaryExpression: UnaryExpression{
4824 ExponentiationExpression: ExponentiationExpression{
4825 SubsetExpression: SubsetExpression{
4826 ScopeExpression: ScopeExpression{
4827 IndexOrCallExpression: IndexOrCallExpression{
4828 SimpleExpression: &SimpleExpression{
4829 Identifier: &tk[0],
4830 Tokens: tk[:1],
4831 },
4832 Tokens: tk[:1],
4833 },
4834 Tokens: tk[:1],
4835 },
4836 Tokens: tk[:1],
4837 },
4838 Tokens: tk[:1],
4839 },
4840 Tokens: tk[:1],
4841 },
4842 Tokens: tk[:1],
4843 },
4844 Tokens: tk[:1],
4845 },
4846 Tokens: tk[:1],
4847 },
4848 Tokens: tk[:1],
4849 },
4850 Tokens: tk[:1],
4851 },
4852 Tokens: tk[:1],
4853 }
4854 }},
4855 {"!a", func(t *test, tk Tokens) { // 2
4856 t.Output = NotExpression{
4857 Nots: 1,
4858 RelationalExpression: RelationalExpression{
4859 AdditionExpression: AdditionExpression{
4860 MultiplicationExpression: MultiplicationExpression{
4861 PipeOrSpecialExpression: PipeOrSpecialExpression{
4862 SequenceExpression: SequenceExpression{
4863 UnaryExpression: UnaryExpression{
4864 ExponentiationExpression: ExponentiationExpression{
4865 SubsetExpression: SubsetExpression{
4866 ScopeExpression: ScopeExpression{
4867 IndexOrCallExpression: IndexOrCallExpression{
4868 SimpleExpression: &SimpleExpression{
4869 Identifier: &tk[1],
4870 Tokens: tk[1:2],
4871 },
4872 Tokens: tk[1:2],
4873 },
4874 Tokens: tk[1:2],
4875 },
4876 Tokens: tk[1:2],
4877 },
4878 Tokens: tk[1:2],
4879 },
4880 Tokens: tk[1:2],
4881 },
4882 Tokens: tk[1:2],
4883 },
4884 Tokens: tk[1:2],
4885 },
4886 Tokens: tk[1:2],
4887 },
4888 Tokens: tk[1:2],
4889 },
4890 Tokens: tk[1:2],
4891 },
4892 Comments: []Comments{nil},
4893 Tokens: tk[:2],
4894 }
4895 }},
4896 {"! a", func(t *test, tk Tokens) { // 3
4897 t.Output = NotExpression{
4898 Nots: 1,
4899 RelationalExpression: RelationalExpression{
4900 AdditionExpression: AdditionExpression{
4901 MultiplicationExpression: MultiplicationExpression{
4902 PipeOrSpecialExpression: PipeOrSpecialExpression{
4903 SequenceExpression: SequenceExpression{
4904 UnaryExpression: UnaryExpression{
4905 ExponentiationExpression: ExponentiationExpression{
4906 SubsetExpression: SubsetExpression{
4907 ScopeExpression: ScopeExpression{
4908 IndexOrCallExpression: IndexOrCallExpression{
4909 SimpleExpression: &SimpleExpression{
4910 Identifier: &tk[2],
4911 Tokens: tk[2:3],
4912 },
4913 Tokens: tk[2:3],
4914 },
4915 Tokens: tk[2:3],
4916 },
4917 Tokens: tk[2:3],
4918 },
4919 Tokens: tk[2:3],
4920 },
4921 Tokens: tk[2:3],
4922 },
4923 Tokens: tk[2:3],
4924 },
4925 Tokens: tk[2:3],
4926 },
4927 Tokens: tk[2:3],
4928 },
4929 Tokens: tk[2:3],
4930 },
4931 Tokens: tk[2:3],
4932 },
4933 Comments: []Comments{nil},
4934 Tokens: tk[:3],
4935 }
4936 }},
4937 {"! !! a", func(t *test, tk Tokens) { // 4
4938 t.Output = NotExpression{
4939 Nots: 3,
4940 RelationalExpression: RelationalExpression{
4941 AdditionExpression: AdditionExpression{
4942 MultiplicationExpression: MultiplicationExpression{
4943 PipeOrSpecialExpression: PipeOrSpecialExpression{
4944 SequenceExpression: SequenceExpression{
4945 UnaryExpression: UnaryExpression{
4946 ExponentiationExpression: ExponentiationExpression{
4947 SubsetExpression: SubsetExpression{
4948 ScopeExpression: ScopeExpression{
4949 IndexOrCallExpression: IndexOrCallExpression{
4950 SimpleExpression: &SimpleExpression{
4951 Identifier: &tk[5],
4952 Tokens: tk[5:6],
4953 },
4954 Tokens: tk[5:6],
4955 },
4956 Tokens: tk[5:6],
4957 },
4958 Tokens: tk[5:6],
4959 },
4960 Tokens: tk[5:6],
4961 },
4962 Tokens: tk[5:6],
4963 },
4964 Tokens: tk[5:6],
4965 },
4966 Tokens: tk[5:6],
4967 },
4968 Tokens: tk[5:6],
4969 },
4970 Tokens: tk[5:6],
4971 },
4972 Tokens: tk[5:6],
4973 },
4974 Comments: []Comments{nil, nil, nil},
4975 Tokens: tk[:6],
4976 }
4977 }},
4978 {"in", func(t *test, tk Tokens) { // 5
4979 t.Err = Error{
4980 Err: Error{
4981 Err: Error{
4982 Err: Error{
4983 Err: Error{
4984 Err: Error{
4985 Err: Error{
4986 Err: Error{
4987 Err: Error{
4988 Err: Error{
4989 Err: Error{
4990 Err: Error{
4991 Err: ErrInvalidSimpleExpression,
4992 Parsing: "SimpleExpression",
4993 Token: tk[0],
4994 },
4995 Parsing: "IndexOrCallExpression",
4996 Token: tk[0],
4997 },
4998 Parsing: "ScopeExpression",
4999 Token: tk[0],
5000 },
5001 Parsing: "SubsetExpression",
5002 Token: tk[0],
5003 },
5004 Parsing: "ExponentiationExpression",
5005 Token: tk[0],
5006 },
5007 Parsing: "UnaryExpression",
5008 Token: tk[0],
5009 },
5010 Parsing: "SequenceExpression",
5011 Token: tk[0],
5012 },
5013 Parsing: "PipeOrSpecialExpression",
5014 Token: tk[0],
5015 },
5016 Parsing: "MultiplicationExpression",
5017 Token: tk[0],
5018 },
5019 Parsing: "AdditionExpression",
5020 Token: tk[0],
5021 },
5022 Parsing: "RelationalExpression",
5023 Token: tk[0],
5024 },
5025 Parsing: "NotExpression",
5026 Token: tk[0],
5027 }
5028 }},
5029 {"!#abc\na", func(t *test, tk Tokens) { // 6
5030 t.Output = NotExpression{
5031 Nots: 1,
5032 RelationalExpression: RelationalExpression{
5033 AdditionExpression: AdditionExpression{
5034 MultiplicationExpression: MultiplicationExpression{
5035 PipeOrSpecialExpression: PipeOrSpecialExpression{
5036 SequenceExpression: SequenceExpression{
5037 UnaryExpression: UnaryExpression{
5038 ExponentiationExpression: ExponentiationExpression{
5039 SubsetExpression: SubsetExpression{
5040 ScopeExpression: ScopeExpression{
5041 IndexOrCallExpression: IndexOrCallExpression{
5042 SimpleExpression: &SimpleExpression{
5043 Identifier: &tk[3],
5044 Tokens: tk[3:4],
5045 },
5046 Tokens: tk[3:4],
5047 },
5048 Tokens: tk[3:4],
5049 },
5050 Tokens: tk[3:4],
5051 },
5052 Tokens: tk[3:4],
5053 },
5054 Tokens: tk[3:4],
5055 },
5056 Tokens: tk[3:4],
5057 },
5058 Tokens: tk[3:4],
5059 },
5060 Tokens: tk[3:4],
5061 },
5062 Tokens: tk[3:4],
5063 },
5064 Tokens: tk[3:4],
5065 },
5066 Comments: []Comments{{tk[1]}},
5067 Tokens: tk[:4],
5068 }
5069 }},
5070 {"!#abc\n!#def\na", func(t *test, tk Tokens) { // 7
5071 t.Output = NotExpression{
5072 Nots: 2,
5073 RelationalExpression: RelationalExpression{
5074 AdditionExpression: AdditionExpression{
5075 MultiplicationExpression: MultiplicationExpression{
5076 PipeOrSpecialExpression: PipeOrSpecialExpression{
5077 SequenceExpression: SequenceExpression{
5078 UnaryExpression: UnaryExpression{
5079 ExponentiationExpression: ExponentiationExpression{
5080 SubsetExpression: SubsetExpression{
5081 ScopeExpression: ScopeExpression{
5082 IndexOrCallExpression: IndexOrCallExpression{
5083 SimpleExpression: &SimpleExpression{
5084 Identifier: &tk[6],
5085 Tokens: tk[6:7],
5086 },
5087 Tokens: tk[6:7],
5088 },
5089 Tokens: tk[6:7],
5090 },
5091 Tokens: tk[6:7],
5092 },
5093 Tokens: tk[6:7],
5094 },
5095 Tokens: tk[6:7],
5096 },
5097 Tokens: tk[6:7],
5098 },
5099 Tokens: tk[6:7],
5100 },
5101 Tokens: tk[6:7],
5102 },
5103 Tokens: tk[6:7],
5104 },
5105 Tokens: tk[6:7],
5106 },
5107 Comments: []Comments{{tk[1]}, {tk[4]}},
5108 Tokens: tk[:7],
5109 }
5110 }},
5111 {"! \n!#def\na", func(t *test, tk Tokens) { // 8
5112 t.Output = NotExpression{
5113 Nots: 2,
5114 RelationalExpression: RelationalExpression{
5115 AdditionExpression: AdditionExpression{
5116 MultiplicationExpression: MultiplicationExpression{
5117 PipeOrSpecialExpression: PipeOrSpecialExpression{
5118 SequenceExpression: SequenceExpression{
5119 UnaryExpression: UnaryExpression{
5120 ExponentiationExpression: ExponentiationExpression{
5121 SubsetExpression: SubsetExpression{
5122 ScopeExpression: ScopeExpression{
5123 IndexOrCallExpression: IndexOrCallExpression{
5124 SimpleExpression: &SimpleExpression{
5125 Identifier: &tk[6],
5126 Tokens: tk[6:7],
5127 },
5128 Tokens: tk[6:7],
5129 },
5130 Tokens: tk[6:7],
5131 },
5132 Tokens: tk[6:7],
5133 },
5134 Tokens: tk[6:7],
5135 },
5136 Tokens: tk[6:7],
5137 },
5138 Tokens: tk[6:7],
5139 },
5140 Tokens: tk[6:7],
5141 },
5142 Tokens: tk[6:7],
5143 },
5144 Tokens: tk[6:7],
5145 },
5146 Tokens: tk[6:7],
5147 },
5148 Comments: []Comments{nil, {tk[4]}},
5149 Tokens: tk[:7],
5150 }
5151 }},
5152 }, func(t *test) (Type, error) {
5153 var ne NotExpression
5154
5155 err := ne.parse(&t.Tokens)
5156
5157 return ne, err
5158 })
5159 }
5160
5161 func TestRelationalExpression(t *testing.T) {
5162 doTests(t, []sourceFn{
5163 {"a", func(t *test, tk Tokens) { // 1
5164 t.Output = RelationalExpression{
5165 AdditionExpression: AdditionExpression{
5166 MultiplicationExpression: MultiplicationExpression{
5167 PipeOrSpecialExpression: PipeOrSpecialExpression{
5168 SequenceExpression: SequenceExpression{
5169 UnaryExpression: UnaryExpression{
5170 ExponentiationExpression: ExponentiationExpression{
5171 SubsetExpression: SubsetExpression{
5172 ScopeExpression: ScopeExpression{
5173 IndexOrCallExpression: IndexOrCallExpression{
5174 SimpleExpression: &SimpleExpression{
5175 Identifier: &tk[0],
5176 Tokens: tk[:1],
5177 },
5178 Tokens: tk[:1],
5179 },
5180 Tokens: tk[:1],
5181 },
5182 Tokens: tk[:1],
5183 },
5184 Tokens: tk[:1],
5185 },
5186 Tokens: tk[:1],
5187 },
5188 Tokens: tk[:1],
5189 },
5190 Tokens: tk[:1],
5191 },
5192 Tokens: tk[:1],
5193 },
5194 Tokens: tk[:1],
5195 },
5196 Tokens: tk[:1],
5197 }
5198 }},
5199 {"a>b", func(t *test, tk Tokens) { // 2
5200 t.Output = RelationalExpression{
5201 AdditionExpression: AdditionExpression{
5202 MultiplicationExpression: MultiplicationExpression{
5203 PipeOrSpecialExpression: PipeOrSpecialExpression{
5204 SequenceExpression: SequenceExpression{
5205 UnaryExpression: UnaryExpression{
5206 ExponentiationExpression: ExponentiationExpression{
5207 SubsetExpression: SubsetExpression{
5208 ScopeExpression: ScopeExpression{
5209 IndexOrCallExpression: IndexOrCallExpression{
5210 SimpleExpression: &SimpleExpression{
5211 Identifier: &tk[0],
5212 Tokens: tk[:1],
5213 },
5214 Tokens: tk[:1],
5215 },
5216 Tokens: tk[:1],
5217 },
5218 Tokens: tk[:1],
5219 },
5220 Tokens: tk[:1],
5221 },
5222 Tokens: tk[:1],
5223 },
5224 Tokens: tk[:1],
5225 },
5226 Tokens: tk[:1],
5227 },
5228 Tokens: tk[:1],
5229 },
5230 Tokens: tk[:1],
5231 },
5232 RelationalOperator: RelationalGreaterThan,
5233 RelationalExpression: &RelationalExpression{
5234 AdditionExpression: AdditionExpression{
5235 MultiplicationExpression: MultiplicationExpression{
5236 PipeOrSpecialExpression: PipeOrSpecialExpression{
5237 SequenceExpression: SequenceExpression{
5238 UnaryExpression: UnaryExpression{
5239 ExponentiationExpression: ExponentiationExpression{
5240 SubsetExpression: SubsetExpression{
5241 ScopeExpression: ScopeExpression{
5242 IndexOrCallExpression: IndexOrCallExpression{
5243 SimpleExpression: &SimpleExpression{
5244 Identifier: &tk[2],
5245 Tokens: tk[2:3],
5246 },
5247 Tokens: tk[2:3],
5248 },
5249 Tokens: tk[2:3],
5250 },
5251 Tokens: tk[2:3],
5252 },
5253 Tokens: tk[2:3],
5254 },
5255 Tokens: tk[2:3],
5256 },
5257 Tokens: tk[2:3],
5258 },
5259 Tokens: tk[2:3],
5260 },
5261 Tokens: tk[2:3],
5262 },
5263 Tokens: tk[2:3],
5264 },
5265 Tokens: tk[2:3],
5266 },
5267 Tokens: tk[:3],
5268 }
5269 }},
5270 {"a < b", func(t *test, tk Tokens) { // 3
5271 t.Output = RelationalExpression{
5272 AdditionExpression: AdditionExpression{
5273 MultiplicationExpression: MultiplicationExpression{
5274 PipeOrSpecialExpression: PipeOrSpecialExpression{
5275 SequenceExpression: SequenceExpression{
5276 UnaryExpression: UnaryExpression{
5277 ExponentiationExpression: ExponentiationExpression{
5278 SubsetExpression: SubsetExpression{
5279 ScopeExpression: ScopeExpression{
5280 IndexOrCallExpression: IndexOrCallExpression{
5281 SimpleExpression: &SimpleExpression{
5282 Identifier: &tk[0],
5283 Tokens: tk[:1],
5284 },
5285 Tokens: tk[:1],
5286 },
5287 Tokens: tk[:1],
5288 },
5289 Tokens: tk[:1],
5290 },
5291 Tokens: tk[:1],
5292 },
5293 Tokens: tk[:1],
5294 },
5295 Tokens: tk[:1],
5296 },
5297 Tokens: tk[:1],
5298 },
5299 Tokens: tk[:1],
5300 },
5301 Tokens: tk[:1],
5302 },
5303 RelationalOperator: RelationalLessThan,
5304 RelationalExpression: &RelationalExpression{
5305 AdditionExpression: AdditionExpression{
5306 MultiplicationExpression: MultiplicationExpression{
5307 PipeOrSpecialExpression: PipeOrSpecialExpression{
5308 SequenceExpression: SequenceExpression{
5309 UnaryExpression: UnaryExpression{
5310 ExponentiationExpression: ExponentiationExpression{
5311 SubsetExpression: SubsetExpression{
5312 ScopeExpression: ScopeExpression{
5313 IndexOrCallExpression: IndexOrCallExpression{
5314 SimpleExpression: &SimpleExpression{
5315 Identifier: &tk[4],
5316 Tokens: tk[4:5],
5317 },
5318 Tokens: tk[4:5],
5319 },
5320 Tokens: tk[4:5],
5321 },
5322 Tokens: tk[4:5],
5323 },
5324 Tokens: tk[4:5],
5325 },
5326 Tokens: tk[4:5],
5327 },
5328 Tokens: tk[4:5],
5329 },
5330 Tokens: tk[4:5],
5331 },
5332 Tokens: tk[4:5],
5333 },
5334 Tokens: tk[4:5],
5335 },
5336 Tokens: tk[4:5],
5337 },
5338 Tokens: tk[:5],
5339 }
5340 }},
5341 {"a >= b<=c ==d!= e", func(t *test, tk Tokens) { // 4
5342 t.Output = RelationalExpression{
5343 AdditionExpression: AdditionExpression{
5344 MultiplicationExpression: MultiplicationExpression{
5345 PipeOrSpecialExpression: PipeOrSpecialExpression{
5346 SequenceExpression: SequenceExpression{
5347 UnaryExpression: UnaryExpression{
5348 ExponentiationExpression: ExponentiationExpression{
5349 SubsetExpression: SubsetExpression{
5350 ScopeExpression: ScopeExpression{
5351 IndexOrCallExpression: IndexOrCallExpression{
5352 SimpleExpression: &SimpleExpression{
5353 Identifier: &tk[0],
5354 Tokens: tk[:1],
5355 },
5356 Tokens: tk[:1],
5357 },
5358 Tokens: tk[:1],
5359 },
5360 Tokens: tk[:1],
5361 },
5362 Tokens: tk[:1],
5363 },
5364 Tokens: tk[:1],
5365 },
5366 Tokens: tk[:1],
5367 },
5368 Tokens: tk[:1],
5369 },
5370 Tokens: tk[:1],
5371 },
5372 Tokens: tk[:1],
5373 },
5374 RelationalOperator: RelationalGreaterThanOrEqual,
5375 RelationalExpression: &RelationalExpression{
5376 AdditionExpression: AdditionExpression{
5377 MultiplicationExpression: MultiplicationExpression{
5378 PipeOrSpecialExpression: PipeOrSpecialExpression{
5379 SequenceExpression: SequenceExpression{
5380 UnaryExpression: UnaryExpression{
5381 ExponentiationExpression: ExponentiationExpression{
5382 SubsetExpression: SubsetExpression{
5383 ScopeExpression: ScopeExpression{
5384 IndexOrCallExpression: IndexOrCallExpression{
5385 SimpleExpression: &SimpleExpression{
5386 Identifier: &tk[4],
5387 Tokens: tk[4:5],
5388 },
5389 Tokens: tk[4:5],
5390 },
5391 Tokens: tk[4:5],
5392 },
5393 Tokens: tk[4:5],
5394 },
5395 Tokens: tk[4:5],
5396 },
5397 Tokens: tk[4:5],
5398 },
5399 Tokens: tk[4:5],
5400 },
5401 Tokens: tk[4:5],
5402 },
5403 Tokens: tk[4:5],
5404 },
5405 Tokens: tk[4:5],
5406 },
5407 RelationalOperator: RelationalLessThanOrEqual,
5408 RelationalExpression: &RelationalExpression{
5409 AdditionExpression: AdditionExpression{
5410 MultiplicationExpression: MultiplicationExpression{
5411 PipeOrSpecialExpression: PipeOrSpecialExpression{
5412 SequenceExpression: SequenceExpression{
5413 UnaryExpression: UnaryExpression{
5414 ExponentiationExpression: ExponentiationExpression{
5415 SubsetExpression: SubsetExpression{
5416 ScopeExpression: ScopeExpression{
5417 IndexOrCallExpression: IndexOrCallExpression{
5418 SimpleExpression: &SimpleExpression{
5419 Identifier: &tk[6],
5420 Tokens: tk[6:7],
5421 },
5422 Tokens: tk[6:7],
5423 },
5424 Tokens: tk[6:7],
5425 },
5426 Tokens: tk[6:7],
5427 },
5428 Tokens: tk[6:7],
5429 },
5430 Tokens: tk[6:7],
5431 },
5432 Tokens: tk[6:7],
5433 },
5434 Tokens: tk[6:7],
5435 },
5436 Tokens: tk[6:7],
5437 },
5438 Tokens: tk[6:7],
5439 },
5440 RelationalOperator: RelationalEqual,
5441 RelationalExpression: &RelationalExpression{
5442 AdditionExpression: AdditionExpression{
5443 MultiplicationExpression: MultiplicationExpression{
5444 PipeOrSpecialExpression: PipeOrSpecialExpression{
5445 SequenceExpression: SequenceExpression{
5446 UnaryExpression: UnaryExpression{
5447 ExponentiationExpression: ExponentiationExpression{
5448 SubsetExpression: SubsetExpression{
5449 ScopeExpression: ScopeExpression{
5450 IndexOrCallExpression: IndexOrCallExpression{
5451 SimpleExpression: &SimpleExpression{
5452 Identifier: &tk[9],
5453 Tokens: tk[9:10],
5454 },
5455 Tokens: tk[9:10],
5456 },
5457 Tokens: tk[9:10],
5458 },
5459 Tokens: tk[9:10],
5460 },
5461 Tokens: tk[9:10],
5462 },
5463 Tokens: tk[9:10],
5464 },
5465 Tokens: tk[9:10],
5466 },
5467 Tokens: tk[9:10],
5468 },
5469 Tokens: tk[9:10],
5470 },
5471 Tokens: tk[9:10],
5472 },
5473 RelationalOperator: RelationalNotEqual,
5474 RelationalExpression: &RelationalExpression{
5475 AdditionExpression: AdditionExpression{
5476 MultiplicationExpression: MultiplicationExpression{
5477 PipeOrSpecialExpression: PipeOrSpecialExpression{
5478 SequenceExpression: SequenceExpression{
5479 UnaryExpression: UnaryExpression{
5480 ExponentiationExpression: ExponentiationExpression{
5481 SubsetExpression: SubsetExpression{
5482 ScopeExpression: ScopeExpression{
5483 IndexOrCallExpression: IndexOrCallExpression{
5484 SimpleExpression: &SimpleExpression{
5485 Identifier: &tk[12],
5486 Tokens: tk[12:13],
5487 },
5488 Tokens: tk[12:13],
5489 },
5490 Tokens: tk[12:13],
5491 },
5492 Tokens: tk[12:13],
5493 },
5494 Tokens: tk[12:13],
5495 },
5496 Tokens: tk[12:13],
5497 },
5498 Tokens: tk[12:13],
5499 },
5500 Tokens: tk[12:13],
5501 },
5502 Tokens: tk[12:13],
5503 },
5504 Tokens: tk[12:13],
5505 },
5506 Tokens: tk[12:13],
5507 },
5508 Tokens: tk[9:13],
5509 },
5510 Tokens: tk[6:13],
5511 },
5512 Tokens: tk[4:13],
5513 },
5514 Tokens: tk[:13],
5515 }
5516 }},
5517 {"in", func(t *test, tk Tokens) { // 5
5518 t.Err = Error{
5519 Err: Error{
5520 Err: Error{
5521 Err: Error{
5522 Err: Error{
5523 Err: Error{
5524 Err: Error{
5525 Err: Error{
5526 Err: Error{
5527 Err: Error{
5528 Err: Error{
5529 Err: ErrInvalidSimpleExpression,
5530 Parsing: "SimpleExpression",
5531 Token: tk[0],
5532 },
5533 Parsing: "IndexOrCallExpression",
5534 Token: tk[0],
5535 },
5536 Parsing: "ScopeExpression",
5537 Token: tk[0],
5538 },
5539 Parsing: "SubsetExpression",
5540 Token: tk[0],
5541 },
5542 Parsing: "ExponentiationExpression",
5543 Token: tk[0],
5544 },
5545 Parsing: "UnaryExpression",
5546 Token: tk[0],
5547 },
5548 Parsing: "SequenceExpression",
5549 Token: tk[0],
5550 },
5551 Parsing: "PipeOrSpecialExpression",
5552 Token: tk[0],
5553 },
5554 Parsing: "MultiplicationExpression",
5555 Token: tk[0],
5556 },
5557 Parsing: "AdditionExpression",
5558 Token: tk[0],
5559 },
5560 Parsing: "RelationalExpression",
5561 Token: tk[0],
5562 }
5563 }},
5564 {"a>in", func(t *test, tk Tokens) { // 6
5565 t.Err = Error{
5566 Err: Error{
5567 Err: Error{
5568 Err: Error{
5569 Err: Error{
5570 Err: Error{
5571 Err: Error{
5572 Err: Error{
5573 Err: Error{
5574 Err: Error{
5575 Err: Error{
5576 Err: Error{
5577 Err: ErrInvalidSimpleExpression,
5578 Parsing: "SimpleExpression",
5579 Token: tk[2],
5580 },
5581 Parsing: "IndexOrCallExpression",
5582 Token: tk[2],
5583 },
5584 Parsing: "ScopeExpression",
5585 Token: tk[2],
5586 },
5587 Parsing: "SubsetExpression",
5588 Token: tk[2],
5589 },
5590 Parsing: "ExponentiationExpression",
5591 Token: tk[2],
5592 },
5593 Parsing: "UnaryExpression",
5594 Token: tk[2],
5595 },
5596 Parsing: "SequenceExpression",
5597 Token: tk[2],
5598 },
5599 Parsing: "PipeOrSpecialExpression",
5600 Token: tk[2],
5601 },
5602 Parsing: "MultiplicationExpression",
5603 Token: tk[2],
5604 },
5605 Parsing: "AdditionExpression",
5606 Token: tk[2],
5607 },
5608 Parsing: "RelationalExpression",
5609 Token: tk[2],
5610 },
5611 Parsing: "RelationalExpression",
5612 Token: tk[2],
5613 }
5614 }},
5615 {"a>#abc\nb", func(t *test, tk Tokens) { // 7
5616 t.Output = RelationalExpression{
5617 AdditionExpression: AdditionExpression{
5618 MultiplicationExpression: MultiplicationExpression{
5619 PipeOrSpecialExpression: PipeOrSpecialExpression{
5620 SequenceExpression: SequenceExpression{
5621 UnaryExpression: UnaryExpression{
5622 ExponentiationExpression: ExponentiationExpression{
5623 SubsetExpression: SubsetExpression{
5624 ScopeExpression: ScopeExpression{
5625 IndexOrCallExpression: IndexOrCallExpression{
5626 SimpleExpression: &SimpleExpression{
5627 Identifier: &tk[0],
5628 Tokens: tk[:1],
5629 },
5630 Tokens: tk[:1],
5631 },
5632 Tokens: tk[:1],
5633 },
5634 Tokens: tk[:1],
5635 },
5636 Tokens: tk[:1],
5637 },
5638 Tokens: tk[:1],
5639 },
5640 Tokens: tk[:1],
5641 },
5642 Tokens: tk[:1],
5643 },
5644 Tokens: tk[:1],
5645 },
5646 Tokens: tk[:1],
5647 },
5648 RelationalOperator: RelationalGreaterThan,
5649 RelationalExpression: &RelationalExpression{
5650 AdditionExpression: AdditionExpression{
5651 MultiplicationExpression: MultiplicationExpression{
5652 PipeOrSpecialExpression: PipeOrSpecialExpression{
5653 SequenceExpression: SequenceExpression{
5654 UnaryExpression: UnaryExpression{
5655 ExponentiationExpression: ExponentiationExpression{
5656 SubsetExpression: SubsetExpression{
5657 ScopeExpression: ScopeExpression{
5658 IndexOrCallExpression: IndexOrCallExpression{
5659 SimpleExpression: &SimpleExpression{
5660 Identifier: &tk[4],
5661 Tokens: tk[4:5],
5662 },
5663 Tokens: tk[4:5],
5664 },
5665 Tokens: tk[4:5],
5666 },
5667 Tokens: tk[4:5],
5668 },
5669 Tokens: tk[4:5],
5670 },
5671 Tokens: tk[4:5],
5672 },
5673 Tokens: tk[4:5],
5674 },
5675 Tokens: tk[4:5],
5676 },
5677 Tokens: tk[4:5],
5678 },
5679 Tokens: tk[4:5],
5680 },
5681 Tokens: tk[4:5],
5682 },
5683 Comments: [2]Comments{nil, {tk[2]}},
5684 Tokens: tk[:5],
5685 }
5686 }},
5687 }, func(t *test) (Type, error) {
5688 var re RelationalExpression
5689
5690 err := re.parse(&t.Tokens)
5691
5692 return re, err
5693 })
5694 }
5695
5696 func TestAdditionExpression(t *testing.T) {
5697 doTests(t, []sourceFn{
5698 {"a", func(t *test, tk Tokens) { // 1
5699 t.Output = AdditionExpression{
5700 MultiplicationExpression: MultiplicationExpression{
5701 PipeOrSpecialExpression: PipeOrSpecialExpression{
5702 SequenceExpression: SequenceExpression{
5703 UnaryExpression: UnaryExpression{
5704 ExponentiationExpression: ExponentiationExpression{
5705 SubsetExpression: SubsetExpression{
5706 ScopeExpression: ScopeExpression{
5707 IndexOrCallExpression: IndexOrCallExpression{
5708 SimpleExpression: &SimpleExpression{
5709 Identifier: &tk[0],
5710 Tokens: tk[:1],
5711 },
5712 Tokens: tk[:1],
5713 },
5714 Tokens: tk[:1],
5715 },
5716 Tokens: tk[:1],
5717 },
5718 Tokens: tk[:1],
5719 },
5720 Tokens: tk[:1],
5721 },
5722 Tokens: tk[:1],
5723 },
5724 Tokens: tk[:1],
5725 },
5726 Tokens: tk[:1],
5727 },
5728 Tokens: tk[:1],
5729 }
5730 }},
5731 {"a+b", func(t *test, tk Tokens) { // 2
5732 t.Output = AdditionExpression{
5733 MultiplicationExpression: MultiplicationExpression{
5734 PipeOrSpecialExpression: PipeOrSpecialExpression{
5735 SequenceExpression: SequenceExpression{
5736 UnaryExpression: UnaryExpression{
5737 ExponentiationExpression: ExponentiationExpression{
5738 SubsetExpression: SubsetExpression{
5739 ScopeExpression: ScopeExpression{
5740 IndexOrCallExpression: IndexOrCallExpression{
5741 SimpleExpression: &SimpleExpression{
5742 Identifier: &tk[0],
5743 Tokens: tk[:1],
5744 },
5745 Tokens: tk[:1],
5746 },
5747 Tokens: tk[:1],
5748 },
5749 Tokens: tk[:1],
5750 },
5751 Tokens: tk[:1],
5752 },
5753 Tokens: tk[:1],
5754 },
5755 Tokens: tk[:1],
5756 },
5757 Tokens: tk[:1],
5758 },
5759 Tokens: tk[:1],
5760 },
5761 AdditionType: AdditionAdd,
5762 AdditionExpression: &AdditionExpression{
5763 MultiplicationExpression: MultiplicationExpression{
5764 PipeOrSpecialExpression: PipeOrSpecialExpression{
5765 SequenceExpression: SequenceExpression{
5766 UnaryExpression: UnaryExpression{
5767 ExponentiationExpression: ExponentiationExpression{
5768 SubsetExpression: SubsetExpression{
5769 ScopeExpression: ScopeExpression{
5770 IndexOrCallExpression: IndexOrCallExpression{
5771 SimpleExpression: &SimpleExpression{
5772 Identifier: &tk[2],
5773 Tokens: tk[2:3],
5774 },
5775 Tokens: tk[2:3],
5776 },
5777 Tokens: tk[2:3],
5778 },
5779 Tokens: tk[2:3],
5780 },
5781 Tokens: tk[2:3],
5782 },
5783 Tokens: tk[2:3],
5784 },
5785 Tokens: tk[2:3],
5786 },
5787 Tokens: tk[2:3],
5788 },
5789 Tokens: tk[2:3],
5790 },
5791 Tokens: tk[2:3],
5792 },
5793 Tokens: tk[:3],
5794 }
5795 }},
5796 {"a-b", func(t *test, tk Tokens) { // 3
5797 t.Output = AdditionExpression{
5798 MultiplicationExpression: MultiplicationExpression{
5799 PipeOrSpecialExpression: PipeOrSpecialExpression{
5800 SequenceExpression: SequenceExpression{
5801 UnaryExpression: UnaryExpression{
5802 ExponentiationExpression: ExponentiationExpression{
5803 SubsetExpression: SubsetExpression{
5804 ScopeExpression: ScopeExpression{
5805 IndexOrCallExpression: IndexOrCallExpression{
5806 SimpleExpression: &SimpleExpression{
5807 Identifier: &tk[0],
5808 Tokens: tk[:1],
5809 },
5810 Tokens: tk[:1],
5811 },
5812 Tokens: tk[:1],
5813 },
5814 Tokens: tk[:1],
5815 },
5816 Tokens: tk[:1],
5817 },
5818 Tokens: tk[:1],
5819 },
5820 Tokens: tk[:1],
5821 },
5822 Tokens: tk[:1],
5823 },
5824 Tokens: tk[:1],
5825 },
5826 AdditionType: AdditionSubtract,
5827 AdditionExpression: &AdditionExpression{
5828 MultiplicationExpression: MultiplicationExpression{
5829 PipeOrSpecialExpression: PipeOrSpecialExpression{
5830 SequenceExpression: SequenceExpression{
5831 UnaryExpression: UnaryExpression{
5832 ExponentiationExpression: ExponentiationExpression{
5833 SubsetExpression: SubsetExpression{
5834 ScopeExpression: ScopeExpression{
5835 IndexOrCallExpression: IndexOrCallExpression{
5836 SimpleExpression: &SimpleExpression{
5837 Identifier: &tk[2],
5838 Tokens: tk[2:3],
5839 },
5840 Tokens: tk[2:3],
5841 },
5842 Tokens: tk[2:3],
5843 },
5844 Tokens: tk[2:3],
5845 },
5846 Tokens: tk[2:3],
5847 },
5848 Tokens: tk[2:3],
5849 },
5850 Tokens: tk[2:3],
5851 },
5852 Tokens: tk[2:3],
5853 },
5854 Tokens: tk[2:3],
5855 },
5856 Tokens: tk[2:3],
5857 },
5858 Tokens: tk[:3],
5859 }
5860 }},
5861 {"a + b", func(t *test, tk Tokens) { // 4
5862 t.Output = AdditionExpression{
5863 MultiplicationExpression: MultiplicationExpression{
5864 PipeOrSpecialExpression: PipeOrSpecialExpression{
5865 SequenceExpression: SequenceExpression{
5866 UnaryExpression: UnaryExpression{
5867 ExponentiationExpression: ExponentiationExpression{
5868 SubsetExpression: SubsetExpression{
5869 ScopeExpression: ScopeExpression{
5870 IndexOrCallExpression: IndexOrCallExpression{
5871 SimpleExpression: &SimpleExpression{
5872 Identifier: &tk[0],
5873 Tokens: tk[:1],
5874 },
5875 Tokens: tk[:1],
5876 },
5877 Tokens: tk[:1],
5878 },
5879 Tokens: tk[:1],
5880 },
5881 Tokens: tk[:1],
5882 },
5883 Tokens: tk[:1],
5884 },
5885 Tokens: tk[:1],
5886 },
5887 Tokens: tk[:1],
5888 },
5889 Tokens: tk[:1],
5890 },
5891 AdditionType: AdditionAdd,
5892 AdditionExpression: &AdditionExpression{
5893 MultiplicationExpression: MultiplicationExpression{
5894 PipeOrSpecialExpression: PipeOrSpecialExpression{
5895 SequenceExpression: SequenceExpression{
5896 UnaryExpression: UnaryExpression{
5897 ExponentiationExpression: ExponentiationExpression{
5898 SubsetExpression: SubsetExpression{
5899 ScopeExpression: ScopeExpression{
5900 IndexOrCallExpression: IndexOrCallExpression{
5901 SimpleExpression: &SimpleExpression{
5902 Identifier: &tk[4],
5903 Tokens: tk[4:5],
5904 },
5905 Tokens: tk[4:5],
5906 },
5907 Tokens: tk[4:5],
5908 },
5909 Tokens: tk[4:5],
5910 },
5911 Tokens: tk[4:5],
5912 },
5913 Tokens: tk[4:5],
5914 },
5915 Tokens: tk[4:5],
5916 },
5917 Tokens: tk[4:5],
5918 },
5919 Tokens: tk[4:5],
5920 },
5921 Tokens: tk[4:5],
5922 },
5923 Tokens: tk[:5],
5924 }
5925 }},
5926 {"a - b", func(t *test, tk Tokens) { // 5
5927 t.Output = AdditionExpression{
5928 MultiplicationExpression: MultiplicationExpression{
5929 PipeOrSpecialExpression: PipeOrSpecialExpression{
5930 SequenceExpression: SequenceExpression{
5931 UnaryExpression: UnaryExpression{
5932 ExponentiationExpression: ExponentiationExpression{
5933 SubsetExpression: SubsetExpression{
5934 ScopeExpression: ScopeExpression{
5935 IndexOrCallExpression: IndexOrCallExpression{
5936 SimpleExpression: &SimpleExpression{
5937 Identifier: &tk[0],
5938 Tokens: tk[:1],
5939 },
5940 Tokens: tk[:1],
5941 },
5942 Tokens: tk[:1],
5943 },
5944 Tokens: tk[:1],
5945 },
5946 Tokens: tk[:1],
5947 },
5948 Tokens: tk[:1],
5949 },
5950 Tokens: tk[:1],
5951 },
5952 Tokens: tk[:1],
5953 },
5954 Tokens: tk[:1],
5955 },
5956 AdditionType: AdditionSubtract,
5957 AdditionExpression: &AdditionExpression{
5958 MultiplicationExpression: MultiplicationExpression{
5959 PipeOrSpecialExpression: PipeOrSpecialExpression{
5960 SequenceExpression: SequenceExpression{
5961 UnaryExpression: UnaryExpression{
5962 ExponentiationExpression: ExponentiationExpression{
5963 SubsetExpression: SubsetExpression{
5964 ScopeExpression: ScopeExpression{
5965 IndexOrCallExpression: IndexOrCallExpression{
5966 SimpleExpression: &SimpleExpression{
5967 Identifier: &tk[4],
5968 Tokens: tk[4:5],
5969 },
5970 Tokens: tk[4:5],
5971 },
5972 Tokens: tk[4:5],
5973 },
5974 Tokens: tk[4:5],
5975 },
5976 Tokens: tk[4:5],
5977 },
5978 Tokens: tk[4:5],
5979 },
5980 Tokens: tk[4:5],
5981 },
5982 Tokens: tk[4:5],
5983 },
5984 Tokens: tk[4:5],
5985 },
5986 Tokens: tk[4:5],
5987 },
5988 Tokens: tk[:5],
5989 }
5990 }},
5991 {"in", func(t *test, tk Tokens) { // 6
5992 t.Err = Error{
5993 Err: Error{
5994 Err: Error{
5995 Err: Error{
5996 Err: Error{
5997 Err: Error{
5998 Err: Error{
5999 Err: Error{
6000 Err: Error{
6001 Err: Error{
6002 Err: ErrInvalidSimpleExpression,
6003 Parsing: "SimpleExpression",
6004 Token: tk[0],
6005 },
6006 Parsing: "IndexOrCallExpression",
6007 Token: tk[0],
6008 },
6009 Parsing: "ScopeExpression",
6010 Token: tk[0],
6011 },
6012 Parsing: "SubsetExpression",
6013 Token: tk[0],
6014 },
6015 Parsing: "ExponentiationExpression",
6016 Token: tk[0],
6017 },
6018 Parsing: "UnaryExpression",
6019 Token: tk[0],
6020 },
6021 Parsing: "SequenceExpression",
6022 Token: tk[0],
6023 },
6024 Parsing: "PipeOrSpecialExpression",
6025 Token: tk[0],
6026 },
6027 Parsing: "MultiplicationExpression",
6028 Token: tk[0],
6029 },
6030 Parsing: "AdditionExpression",
6031 Token: tk[0],
6032 }
6033 }},
6034 {"a+in", func(t *test, tk Tokens) { // 7
6035 t.Err = Error{
6036 Err: Error{
6037 Err: Error{
6038 Err: Error{
6039 Err: Error{
6040 Err: Error{
6041 Err: Error{
6042 Err: Error{
6043 Err: Error{
6044 Err: Error{
6045 Err: Error{
6046 Err: ErrInvalidSimpleExpression,
6047 Parsing: "SimpleExpression",
6048 Token: tk[2],
6049 },
6050 Parsing: "IndexOrCallExpression",
6051 Token: tk[2],
6052 },
6053 Parsing: "ScopeExpression",
6054 Token: tk[2],
6055 },
6056 Parsing: "SubsetExpression",
6057 Token: tk[2],
6058 },
6059 Parsing: "ExponentiationExpression",
6060 Token: tk[2],
6061 },
6062 Parsing: "UnaryExpression",
6063 Token: tk[2],
6064 },
6065 Parsing: "SequenceExpression",
6066 Token: tk[2],
6067 },
6068 Parsing: "PipeOrSpecialExpression",
6069 Token: tk[2],
6070 },
6071 Parsing: "MultiplicationExpression",
6072 Token: tk[2],
6073 },
6074 Parsing: "AdditionExpression",
6075 Token: tk[2],
6076 },
6077 Parsing: "AdditionExpression",
6078 Token: tk[2],
6079 }
6080 }},
6081 {"a+#abc\nb", func(t *test, tk Tokens) { // 8
6082 t.Output = AdditionExpression{
6083 MultiplicationExpression: MultiplicationExpression{
6084 PipeOrSpecialExpression: PipeOrSpecialExpression{
6085 SequenceExpression: SequenceExpression{
6086 UnaryExpression: UnaryExpression{
6087 ExponentiationExpression: ExponentiationExpression{
6088 SubsetExpression: SubsetExpression{
6089 ScopeExpression: ScopeExpression{
6090 IndexOrCallExpression: IndexOrCallExpression{
6091 SimpleExpression: &SimpleExpression{
6092 Identifier: &tk[0],
6093 Tokens: tk[:1],
6094 },
6095 Tokens: tk[:1],
6096 },
6097 Tokens: tk[:1],
6098 },
6099 Tokens: tk[:1],
6100 },
6101 Tokens: tk[:1],
6102 },
6103 Tokens: tk[:1],
6104 },
6105 Tokens: tk[:1],
6106 },
6107 Tokens: tk[:1],
6108 },
6109 Tokens: tk[:1],
6110 },
6111 AdditionType: AdditionAdd,
6112 AdditionExpression: &AdditionExpression{
6113 MultiplicationExpression: MultiplicationExpression{
6114 PipeOrSpecialExpression: PipeOrSpecialExpression{
6115 SequenceExpression: SequenceExpression{
6116 UnaryExpression: UnaryExpression{
6117 ExponentiationExpression: ExponentiationExpression{
6118 SubsetExpression: SubsetExpression{
6119 ScopeExpression: ScopeExpression{
6120 IndexOrCallExpression: IndexOrCallExpression{
6121 SimpleExpression: &SimpleExpression{
6122 Identifier: &tk[4],
6123 Tokens: tk[4:5],
6124 },
6125 Tokens: tk[4:5],
6126 },
6127 Tokens: tk[4:5],
6128 },
6129 Tokens: tk[4:5],
6130 },
6131 Tokens: tk[4:5],
6132 },
6133 Tokens: tk[4:5],
6134 },
6135 Tokens: tk[4:5],
6136 },
6137 Tokens: tk[4:5],
6138 },
6139 Tokens: tk[4:5],
6140 },
6141 Tokens: tk[4:5],
6142 },
6143 Comments: [2]Comments{nil, {tk[2]}},
6144 Tokens: tk[:5],
6145 }
6146 }},
6147 }, func(t *test) (Type, error) {
6148 var ae AdditionExpression
6149
6150 err := ae.parse(&t.Tokens)
6151
6152 return ae, err
6153 })
6154 }
6155
6156 func TestMultiplicationExpression(t *testing.T) {
6157 doTests(t, []sourceFn{
6158 {"a", func(t *test, tk Tokens) { // 1
6159 t.Output = MultiplicationExpression{
6160 PipeOrSpecialExpression: PipeOrSpecialExpression{
6161 SequenceExpression: SequenceExpression{
6162 UnaryExpression: UnaryExpression{
6163 ExponentiationExpression: ExponentiationExpression{
6164 SubsetExpression: SubsetExpression{
6165 ScopeExpression: ScopeExpression{
6166 IndexOrCallExpression: IndexOrCallExpression{
6167 SimpleExpression: &SimpleExpression{
6168 Identifier: &tk[0],
6169 Tokens: tk[:1],
6170 },
6171 Tokens: tk[:1],
6172 },
6173 Tokens: tk[:1],
6174 },
6175 Tokens: tk[:1],
6176 },
6177 Tokens: tk[:1],
6178 },
6179 Tokens: tk[:1],
6180 },
6181 Tokens: tk[:1],
6182 },
6183 Tokens: tk[:1],
6184 },
6185 Tokens: tk[:1],
6186 }
6187 }},
6188 {"a*b", func(t *test, tk Tokens) { // 2
6189 t.Output = MultiplicationExpression{
6190 PipeOrSpecialExpression: PipeOrSpecialExpression{
6191 SequenceExpression: SequenceExpression{
6192 UnaryExpression: UnaryExpression{
6193 ExponentiationExpression: ExponentiationExpression{
6194 SubsetExpression: SubsetExpression{
6195 ScopeExpression: ScopeExpression{
6196 IndexOrCallExpression: IndexOrCallExpression{
6197 SimpleExpression: &SimpleExpression{
6198 Identifier: &tk[0],
6199 Tokens: tk[:1],
6200 },
6201 Tokens: tk[:1],
6202 },
6203 Tokens: tk[:1],
6204 },
6205 Tokens: tk[:1],
6206 },
6207 Tokens: tk[:1],
6208 },
6209 Tokens: tk[:1],
6210 },
6211 Tokens: tk[:1],
6212 },
6213 Tokens: tk[:1],
6214 },
6215 MultiplicationType: MultiplicationMultiply,
6216 MultiplicationExpression: &MultiplicationExpression{
6217 PipeOrSpecialExpression: PipeOrSpecialExpression{
6218 SequenceExpression: SequenceExpression{
6219 UnaryExpression: UnaryExpression{
6220 ExponentiationExpression: ExponentiationExpression{
6221 SubsetExpression: SubsetExpression{
6222 ScopeExpression: ScopeExpression{
6223 IndexOrCallExpression: IndexOrCallExpression{
6224 SimpleExpression: &SimpleExpression{
6225 Identifier: &tk[2],
6226 Tokens: tk[2:3],
6227 },
6228 Tokens: tk[2:3],
6229 },
6230 Tokens: tk[2:3],
6231 },
6232 Tokens: tk[2:3],
6233 },
6234 Tokens: tk[2:3],
6235 },
6236 Tokens: tk[2:3],
6237 },
6238 Tokens: tk[2:3],
6239 },
6240 Tokens: tk[2:3],
6241 },
6242 Tokens: tk[2:3],
6243 },
6244 Tokens: tk[:3],
6245 }
6246 }},
6247 {"a/b", func(t *test, tk Tokens) { // 3
6248 t.Output = MultiplicationExpression{
6249 PipeOrSpecialExpression: PipeOrSpecialExpression{
6250 SequenceExpression: SequenceExpression{
6251 UnaryExpression: UnaryExpression{
6252 ExponentiationExpression: ExponentiationExpression{
6253 SubsetExpression: SubsetExpression{
6254 ScopeExpression: ScopeExpression{
6255 IndexOrCallExpression: IndexOrCallExpression{
6256 SimpleExpression: &SimpleExpression{
6257 Identifier: &tk[0],
6258 Tokens: tk[:1],
6259 },
6260 Tokens: tk[:1],
6261 },
6262 Tokens: tk[:1],
6263 },
6264 Tokens: tk[:1],
6265 },
6266 Tokens: tk[:1],
6267 },
6268 Tokens: tk[:1],
6269 },
6270 Tokens: tk[:1],
6271 },
6272 Tokens: tk[:1],
6273 },
6274 MultiplicationType: MultiplicationDivide,
6275 MultiplicationExpression: &MultiplicationExpression{
6276 PipeOrSpecialExpression: PipeOrSpecialExpression{
6277 SequenceExpression: SequenceExpression{
6278 UnaryExpression: UnaryExpression{
6279 ExponentiationExpression: ExponentiationExpression{
6280 SubsetExpression: SubsetExpression{
6281 ScopeExpression: ScopeExpression{
6282 IndexOrCallExpression: IndexOrCallExpression{
6283 SimpleExpression: &SimpleExpression{
6284 Identifier: &tk[2],
6285 Tokens: tk[2:3],
6286 },
6287 Tokens: tk[2:3],
6288 },
6289 Tokens: tk[2:3],
6290 },
6291 Tokens: tk[2:3],
6292 },
6293 Tokens: tk[2:3],
6294 },
6295 Tokens: tk[2:3],
6296 },
6297 Tokens: tk[2:3],
6298 },
6299 Tokens: tk[2:3],
6300 },
6301 Tokens: tk[2:3],
6302 },
6303 Tokens: tk[:3],
6304 }
6305 }},
6306 {"a * b", func(t *test, tk Tokens) { // 4
6307 t.Output = MultiplicationExpression{
6308 PipeOrSpecialExpression: PipeOrSpecialExpression{
6309 SequenceExpression: SequenceExpression{
6310 UnaryExpression: UnaryExpression{
6311 ExponentiationExpression: ExponentiationExpression{
6312 SubsetExpression: SubsetExpression{
6313 ScopeExpression: ScopeExpression{
6314 IndexOrCallExpression: IndexOrCallExpression{
6315 SimpleExpression: &SimpleExpression{
6316 Identifier: &tk[0],
6317 Tokens: tk[:1],
6318 },
6319 Tokens: tk[:1],
6320 },
6321 Tokens: tk[:1],
6322 },
6323 Tokens: tk[:1],
6324 },
6325 Tokens: tk[:1],
6326 },
6327 Tokens: tk[:1],
6328 },
6329 Tokens: tk[:1],
6330 },
6331 Tokens: tk[:1],
6332 },
6333 MultiplicationType: MultiplicationMultiply,
6334 MultiplicationExpression: &MultiplicationExpression{
6335 PipeOrSpecialExpression: PipeOrSpecialExpression{
6336 SequenceExpression: SequenceExpression{
6337 UnaryExpression: UnaryExpression{
6338 ExponentiationExpression: ExponentiationExpression{
6339 SubsetExpression: SubsetExpression{
6340 ScopeExpression: ScopeExpression{
6341 IndexOrCallExpression: IndexOrCallExpression{
6342 SimpleExpression: &SimpleExpression{
6343 Identifier: &tk[4],
6344 Tokens: tk[4:5],
6345 },
6346 Tokens: tk[4:5],
6347 },
6348 Tokens: tk[4:5],
6349 },
6350 Tokens: tk[4:5],
6351 },
6352 Tokens: tk[4:5],
6353 },
6354 Tokens: tk[4:5],
6355 },
6356 Tokens: tk[4:5],
6357 },
6358 Tokens: tk[4:5],
6359 },
6360 Tokens: tk[4:5],
6361 },
6362 Tokens: tk[:5],
6363 }
6364 }},
6365 {"a / b", func(t *test, tk Tokens) { // 5
6366 t.Output = MultiplicationExpression{
6367 PipeOrSpecialExpression: PipeOrSpecialExpression{
6368 SequenceExpression: SequenceExpression{
6369 UnaryExpression: UnaryExpression{
6370 ExponentiationExpression: ExponentiationExpression{
6371 SubsetExpression: SubsetExpression{
6372 ScopeExpression: ScopeExpression{
6373 IndexOrCallExpression: IndexOrCallExpression{
6374 SimpleExpression: &SimpleExpression{
6375 Identifier: &tk[0],
6376 Tokens: tk[:1],
6377 },
6378 Tokens: tk[:1],
6379 },
6380 Tokens: tk[:1],
6381 },
6382 Tokens: tk[:1],
6383 },
6384 Tokens: tk[:1],
6385 },
6386 Tokens: tk[:1],
6387 },
6388 Tokens: tk[:1],
6389 },
6390 Tokens: tk[:1],
6391 },
6392 MultiplicationType: MultiplicationDivide,
6393 MultiplicationExpression: &MultiplicationExpression{
6394 PipeOrSpecialExpression: PipeOrSpecialExpression{
6395 SequenceExpression: SequenceExpression{
6396 UnaryExpression: UnaryExpression{
6397 ExponentiationExpression: ExponentiationExpression{
6398 SubsetExpression: SubsetExpression{
6399 ScopeExpression: ScopeExpression{
6400 IndexOrCallExpression: IndexOrCallExpression{
6401 SimpleExpression: &SimpleExpression{
6402 Identifier: &tk[4],
6403 Tokens: tk[4:5],
6404 },
6405 Tokens: tk[4:5],
6406 },
6407 Tokens: tk[4:5],
6408 },
6409 Tokens: tk[4:5],
6410 },
6411 Tokens: tk[4:5],
6412 },
6413 Tokens: tk[4:5],
6414 },
6415 Tokens: tk[4:5],
6416 },
6417 Tokens: tk[4:5],
6418 },
6419 Tokens: tk[4:5],
6420 },
6421 Tokens: tk[:5],
6422 }
6423 }},
6424 {"in", func(t *test, tk Tokens) { // 6
6425 t.Err = Error{
6426 Err: Error{
6427 Err: Error{
6428 Err: Error{
6429 Err: Error{
6430 Err: Error{
6431 Err: Error{
6432 Err: Error{
6433 Err: Error{
6434 Err: ErrInvalidSimpleExpression,
6435 Parsing: "SimpleExpression",
6436 Token: tk[0],
6437 },
6438 Parsing: "IndexOrCallExpression",
6439 Token: tk[0],
6440 },
6441 Parsing: "ScopeExpression",
6442 Token: tk[0],
6443 },
6444 Parsing: "SubsetExpression",
6445 Token: tk[0],
6446 },
6447 Parsing: "ExponentiationExpression",
6448 Token: tk[0],
6449 },
6450 Parsing: "UnaryExpression",
6451 Token: tk[0],
6452 },
6453 Parsing: "SequenceExpression",
6454 Token: tk[0],
6455 },
6456 Parsing: "PipeOrSpecialExpression",
6457 Token: tk[0],
6458 },
6459 Parsing: "MultiplicationExpression",
6460 Token: tk[0],
6461 }
6462 }},
6463 {"a*in", func(t *test, tk Tokens) { // 7
6464 t.Err = Error{
6465 Err: Error{
6466 Err: Error{
6467 Err: Error{
6468 Err: Error{
6469 Err: Error{
6470 Err: Error{
6471 Err: Error{
6472 Err: Error{
6473 Err: Error{
6474 Err: ErrInvalidSimpleExpression,
6475 Parsing: "SimpleExpression",
6476 Token: tk[2],
6477 },
6478 Parsing: "IndexOrCallExpression",
6479 Token: tk[2],
6480 },
6481 Parsing: "ScopeExpression",
6482 Token: tk[2],
6483 },
6484 Parsing: "SubsetExpression",
6485 Token: tk[2],
6486 },
6487 Parsing: "ExponentiationExpression",
6488 Token: tk[2],
6489 },
6490 Parsing: "UnaryExpression",
6491 Token: tk[2],
6492 },
6493 Parsing: "SequenceExpression",
6494 Token: tk[2],
6495 },
6496 Parsing: "PipeOrSpecialExpression",
6497 Token: tk[2],
6498 },
6499 Parsing: "MultiplicationExpression",
6500 Token: tk[2],
6501 },
6502 Parsing: "MultiplicationExpression",
6503 Token: tk[2],
6504 }
6505 }},
6506 {"a*#abc\nb", func(t *test, tk Tokens) { // 8
6507 t.Output = MultiplicationExpression{
6508 PipeOrSpecialExpression: PipeOrSpecialExpression{
6509 SequenceExpression: SequenceExpression{
6510 UnaryExpression: UnaryExpression{
6511 ExponentiationExpression: ExponentiationExpression{
6512 SubsetExpression: SubsetExpression{
6513 ScopeExpression: ScopeExpression{
6514 IndexOrCallExpression: IndexOrCallExpression{
6515 SimpleExpression: &SimpleExpression{
6516 Identifier: &tk[0],
6517 Tokens: tk[:1],
6518 },
6519 Tokens: tk[:1],
6520 },
6521 Tokens: tk[:1],
6522 },
6523 Tokens: tk[:1],
6524 },
6525 Tokens: tk[:1],
6526 },
6527 Tokens: tk[:1],
6528 },
6529 Tokens: tk[:1],
6530 },
6531 Tokens: tk[:1],
6532 },
6533 MultiplicationType: MultiplicationMultiply,
6534 MultiplicationExpression: &MultiplicationExpression{
6535 PipeOrSpecialExpression: PipeOrSpecialExpression{
6536 SequenceExpression: SequenceExpression{
6537 UnaryExpression: UnaryExpression{
6538 ExponentiationExpression: ExponentiationExpression{
6539 SubsetExpression: SubsetExpression{
6540 ScopeExpression: ScopeExpression{
6541 IndexOrCallExpression: IndexOrCallExpression{
6542 SimpleExpression: &SimpleExpression{
6543 Identifier: &tk[4],
6544 Tokens: tk[4:5],
6545 },
6546 Tokens: tk[4:5],
6547 },
6548 Tokens: tk[4:5],
6549 },
6550 Tokens: tk[4:5],
6551 },
6552 Tokens: tk[4:5],
6553 },
6554 Tokens: tk[4:5],
6555 },
6556 Tokens: tk[4:5],
6557 },
6558 Tokens: tk[4:5],
6559 },
6560 Tokens: tk[4:5],
6561 },
6562 Comments: [2]Comments{nil, {tk[2]}},
6563 Tokens: tk[:5],
6564 }
6565 }},
6566 }, func(t *test) (Type, error) {
6567 var me MultiplicationExpression
6568
6569 err := me.parse(&t.Tokens)
6570
6571 return me, err
6572 })
6573 }
6574
6575 func TestPipeOrSpecialExpression(t *testing.T) {
6576 doTests(t, []sourceFn{
6577 {"a", func(t *test, tk Tokens) { // 1
6578 t.Output = PipeOrSpecialExpression{
6579 SequenceExpression: SequenceExpression{
6580 UnaryExpression: UnaryExpression{
6581 ExponentiationExpression: ExponentiationExpression{
6582 SubsetExpression: SubsetExpression{
6583 ScopeExpression: ScopeExpression{
6584 IndexOrCallExpression: IndexOrCallExpression{
6585 SimpleExpression: &SimpleExpression{
6586 Identifier: &tk[0],
6587 Tokens: tk[:1],
6588 },
6589 Tokens: tk[:1],
6590 },
6591 Tokens: tk[:1],
6592 },
6593 Tokens: tk[:1],
6594 },
6595 Tokens: tk[:1],
6596 },
6597 Tokens: tk[:1],
6598 },
6599 Tokens: tk[:1],
6600 },
6601 Tokens: tk[:1],
6602 }
6603 }},
6604 {"a|>b", func(t *test, tk Tokens) { // 2
6605 t.Output = PipeOrSpecialExpression{
6606 SequenceExpression: SequenceExpression{
6607 UnaryExpression: UnaryExpression{
6608 ExponentiationExpression: ExponentiationExpression{
6609 SubsetExpression: SubsetExpression{
6610 ScopeExpression: ScopeExpression{
6611 IndexOrCallExpression: IndexOrCallExpression{
6612 SimpleExpression: &SimpleExpression{
6613 Identifier: &tk[0],
6614 Tokens: tk[:1],
6615 },
6616 Tokens: tk[:1],
6617 },
6618 Tokens: tk[:1],
6619 },
6620 Tokens: tk[:1],
6621 },
6622 Tokens: tk[:1],
6623 },
6624 Tokens: tk[:1],
6625 },
6626 Tokens: tk[:1],
6627 },
6628 Operator: &tk[1],
6629 PipeOrSpecialExpression: &PipeOrSpecialExpression{
6630 SequenceExpression: SequenceExpression{
6631 UnaryExpression: UnaryExpression{
6632 ExponentiationExpression: ExponentiationExpression{
6633 SubsetExpression: SubsetExpression{
6634 ScopeExpression: ScopeExpression{
6635 IndexOrCallExpression: IndexOrCallExpression{
6636 SimpleExpression: &SimpleExpression{
6637 Identifier: &tk[2],
6638 Tokens: tk[2:3],
6639 },
6640 Tokens: tk[2:3],
6641 },
6642 Tokens: tk[2:3],
6643 },
6644 Tokens: tk[2:3],
6645 },
6646 Tokens: tk[2:3],
6647 },
6648 Tokens: tk[2:3],
6649 },
6650 Tokens: tk[2:3],
6651 },
6652 Tokens: tk[2:3],
6653 },
6654 Tokens: tk[:3],
6655 }
6656 }},
6657 {"a |> b", func(t *test, tk Tokens) { // 3
6658 t.Output = PipeOrSpecialExpression{
6659 SequenceExpression: SequenceExpression{
6660 UnaryExpression: UnaryExpression{
6661 ExponentiationExpression: ExponentiationExpression{
6662 SubsetExpression: SubsetExpression{
6663 ScopeExpression: ScopeExpression{
6664 IndexOrCallExpression: IndexOrCallExpression{
6665 SimpleExpression: &SimpleExpression{
6666 Identifier: &tk[0],
6667 Tokens: tk[:1],
6668 },
6669 Tokens: tk[:1],
6670 },
6671 Tokens: tk[:1],
6672 },
6673 Tokens: tk[:1],
6674 },
6675 Tokens: tk[:1],
6676 },
6677 Tokens: tk[:1],
6678 },
6679 Tokens: tk[:1],
6680 },
6681 Operator: &tk[2],
6682 PipeOrSpecialExpression: &PipeOrSpecialExpression{
6683 SequenceExpression: SequenceExpression{
6684 UnaryExpression: UnaryExpression{
6685 ExponentiationExpression: ExponentiationExpression{
6686 SubsetExpression: SubsetExpression{
6687 ScopeExpression: ScopeExpression{
6688 IndexOrCallExpression: IndexOrCallExpression{
6689 SimpleExpression: &SimpleExpression{
6690 Identifier: &tk[4],
6691 Tokens: tk[4:5],
6692 },
6693 Tokens: tk[4:5],
6694 },
6695 Tokens: tk[4:5],
6696 },
6697 Tokens: tk[4:5],
6698 },
6699 Tokens: tk[4:5],
6700 },
6701 Tokens: tk[4:5],
6702 },
6703 Tokens: tk[4:5],
6704 },
6705 Tokens: tk[4:5],
6706 },
6707 Tokens: tk[:5],
6708 }
6709 }},
6710 {"a%%b", func(t *test, tk Tokens) { // 4
6711 t.Output = PipeOrSpecialExpression{
6712 SequenceExpression: SequenceExpression{
6713 UnaryExpression: UnaryExpression{
6714 ExponentiationExpression: ExponentiationExpression{
6715 SubsetExpression: SubsetExpression{
6716 ScopeExpression: ScopeExpression{
6717 IndexOrCallExpression: IndexOrCallExpression{
6718 SimpleExpression: &SimpleExpression{
6719 Identifier: &tk[0],
6720 Tokens: tk[:1],
6721 },
6722 Tokens: tk[:1],
6723 },
6724 Tokens: tk[:1],
6725 },
6726 Tokens: tk[:1],
6727 },
6728 Tokens: tk[:1],
6729 },
6730 Tokens: tk[:1],
6731 },
6732 Tokens: tk[:1],
6733 },
6734 Operator: &tk[1],
6735 PipeOrSpecialExpression: &PipeOrSpecialExpression{
6736 SequenceExpression: SequenceExpression{
6737 UnaryExpression: UnaryExpression{
6738 ExponentiationExpression: ExponentiationExpression{
6739 SubsetExpression: SubsetExpression{
6740 ScopeExpression: ScopeExpression{
6741 IndexOrCallExpression: IndexOrCallExpression{
6742 SimpleExpression: &SimpleExpression{
6743 Identifier: &tk[2],
6744 Tokens: tk[2:3],
6745 },
6746 Tokens: tk[2:3],
6747 },
6748 Tokens: tk[2:3],
6749 },
6750 Tokens: tk[2:3],
6751 },
6752 Tokens: tk[2:3],
6753 },
6754 Tokens: tk[2:3],
6755 },
6756 Tokens: tk[2:3],
6757 },
6758 Tokens: tk[2:3],
6759 },
6760 Tokens: tk[:3],
6761 }
6762 }},
6763 {"a %abc% b", func(t *test, tk Tokens) { // 5
6764 t.Output = PipeOrSpecialExpression{
6765 SequenceExpression: SequenceExpression{
6766 UnaryExpression: UnaryExpression{
6767 ExponentiationExpression: ExponentiationExpression{
6768 SubsetExpression: SubsetExpression{
6769 ScopeExpression: ScopeExpression{
6770 IndexOrCallExpression: IndexOrCallExpression{
6771 SimpleExpression: &SimpleExpression{
6772 Identifier: &tk[0],
6773 Tokens: tk[:1],
6774 },
6775 Tokens: tk[:1],
6776 },
6777 Tokens: tk[:1],
6778 },
6779 Tokens: tk[:1],
6780 },
6781 Tokens: tk[:1],
6782 },
6783 Tokens: tk[:1],
6784 },
6785 Tokens: tk[:1],
6786 },
6787 Operator: &tk[2],
6788 PipeOrSpecialExpression: &PipeOrSpecialExpression{
6789 SequenceExpression: SequenceExpression{
6790 UnaryExpression: UnaryExpression{
6791 ExponentiationExpression: ExponentiationExpression{
6792 SubsetExpression: SubsetExpression{
6793 ScopeExpression: ScopeExpression{
6794 IndexOrCallExpression: IndexOrCallExpression{
6795 SimpleExpression: &SimpleExpression{
6796 Identifier: &tk[4],
6797 Tokens: tk[4:5],
6798 },
6799 Tokens: tk[4:5],
6800 },
6801 Tokens: tk[4:5],
6802 },
6803 Tokens: tk[4:5],
6804 },
6805 Tokens: tk[4:5],
6806 },
6807 Tokens: tk[4:5],
6808 },
6809 Tokens: tk[4:5],
6810 },
6811 Tokens: tk[4:5],
6812 },
6813 Tokens: tk[:5],
6814 }
6815 }},
6816 {"in", func(t *test, tk Tokens) { // 6
6817 t.Err = Error{
6818 Err: Error{
6819 Err: Error{
6820 Err: Error{
6821 Err: Error{
6822 Err: Error{
6823 Err: Error{
6824 Err: Error{
6825 Err: ErrInvalidSimpleExpression,
6826 Parsing: "SimpleExpression",
6827 Token: tk[0],
6828 },
6829 Parsing: "IndexOrCallExpression",
6830 Token: tk[0],
6831 },
6832 Parsing: "ScopeExpression",
6833 Token: tk[0],
6834 },
6835 Parsing: "SubsetExpression",
6836 Token: tk[0],
6837 },
6838 Parsing: "ExponentiationExpression",
6839 Token: tk[0],
6840 },
6841 Parsing: "UnaryExpression",
6842 Token: tk[0],
6843 },
6844 Parsing: "SequenceExpression",
6845 Token: tk[0],
6846 },
6847 Parsing: "PipeOrSpecialExpression",
6848 Token: tk[0],
6849 }
6850 }},
6851 {"a|>in", func(t *test, tk Tokens) { // 7
6852 t.Err = Error{
6853 Err: Error{
6854 Err: Error{
6855 Err: Error{
6856 Err: Error{
6857 Err: Error{
6858 Err: Error{
6859 Err: Error{
6860 Err: Error{
6861 Err: ErrInvalidSimpleExpression,
6862 Parsing: "SimpleExpression",
6863 Token: tk[2],
6864 },
6865 Parsing: "IndexOrCallExpression",
6866 Token: tk[2],
6867 },
6868 Parsing: "ScopeExpression",
6869 Token: tk[2],
6870 },
6871 Parsing: "SubsetExpression",
6872 Token: tk[2],
6873 },
6874 Parsing: "ExponentiationExpression",
6875 Token: tk[2],
6876 },
6877 Parsing: "UnaryExpression",
6878 Token: tk[2],
6879 },
6880 Parsing: "SequenceExpression",
6881 Token: tk[2],
6882 },
6883 Parsing: "PipeOrSpecialExpression",
6884 Token: tk[2],
6885 },
6886 Parsing: "PipeOrSpecialExpression",
6887 Token: tk[2],
6888 }
6889 }},
6890 {"a|>#abc\nb", func(t *test, tk Tokens) { // 8
6891 t.Output = PipeOrSpecialExpression{
6892 SequenceExpression: SequenceExpression{
6893 UnaryExpression: UnaryExpression{
6894 ExponentiationExpression: ExponentiationExpression{
6895 SubsetExpression: SubsetExpression{
6896 ScopeExpression: ScopeExpression{
6897 IndexOrCallExpression: IndexOrCallExpression{
6898 SimpleExpression: &SimpleExpression{
6899 Identifier: &tk[0],
6900 Tokens: tk[:1],
6901 },
6902 Tokens: tk[:1],
6903 },
6904 Tokens: tk[:1],
6905 },
6906 Tokens: tk[:1],
6907 },
6908 Tokens: tk[:1],
6909 },
6910 Tokens: tk[:1],
6911 },
6912 Tokens: tk[:1],
6913 },
6914 Operator: &tk[1],
6915 PipeOrSpecialExpression: &PipeOrSpecialExpression{
6916 SequenceExpression: SequenceExpression{
6917 UnaryExpression: UnaryExpression{
6918 ExponentiationExpression: ExponentiationExpression{
6919 SubsetExpression: SubsetExpression{
6920 ScopeExpression: ScopeExpression{
6921 IndexOrCallExpression: IndexOrCallExpression{
6922 SimpleExpression: &SimpleExpression{
6923 Identifier: &tk[4],
6924 Tokens: tk[4:5],
6925 },
6926 Tokens: tk[4:5],
6927 },
6928 Tokens: tk[4:5],
6929 },
6930 Tokens: tk[4:5],
6931 },
6932 Tokens: tk[4:5],
6933 },
6934 Tokens: tk[4:5],
6935 },
6936 Tokens: tk[4:5],
6937 },
6938 Tokens: tk[4:5],
6939 },
6940 Comments: [2]Comments{nil, {tk[2]}},
6941 Tokens: tk[:5],
6942 }
6943 }},
6944 }, func(t *test) (Type, error) {
6945 var pe PipeOrSpecialExpression
6946
6947 err := pe.parse(&t.Tokens)
6948
6949 return pe, err
6950 })
6951 }
6952
6953 func TestSequenceExpression(t *testing.T) {
6954 doTests(t, []sourceFn{
6955 {"a", func(t *test, tk Tokens) { // 1
6956 t.Output = SequenceExpression{
6957 UnaryExpression: UnaryExpression{
6958 ExponentiationExpression: ExponentiationExpression{
6959 SubsetExpression: SubsetExpression{
6960 ScopeExpression: ScopeExpression{
6961 IndexOrCallExpression: IndexOrCallExpression{
6962 SimpleExpression: &SimpleExpression{
6963 Identifier: &tk[0],
6964 Tokens: tk[:1],
6965 },
6966 Tokens: tk[:1],
6967 },
6968 Tokens: tk[:1],
6969 },
6970 Tokens: tk[:1],
6971 },
6972 Tokens: tk[:1],
6973 },
6974 Tokens: tk[:1],
6975 },
6976 Tokens: tk[:1],
6977 }
6978 }},
6979 {"a:b", func(t *test, tk Tokens) { // 2
6980 t.Output = SequenceExpression{
6981 UnaryExpression: UnaryExpression{
6982 ExponentiationExpression: ExponentiationExpression{
6983 SubsetExpression: SubsetExpression{
6984 ScopeExpression: ScopeExpression{
6985 IndexOrCallExpression: IndexOrCallExpression{
6986 SimpleExpression: &SimpleExpression{
6987 Identifier: &tk[0],
6988 Tokens: tk[:1],
6989 },
6990 Tokens: tk[:1],
6991 },
6992 Tokens: tk[:1],
6993 },
6994 Tokens: tk[:1],
6995 },
6996 Tokens: tk[:1],
6997 },
6998 Tokens: tk[:1],
6999 },
7000 SequenceExpression: &SequenceExpression{
7001 UnaryExpression: UnaryExpression{
7002 ExponentiationExpression: ExponentiationExpression{
7003 SubsetExpression: SubsetExpression{
7004 ScopeExpression: ScopeExpression{
7005 IndexOrCallExpression: IndexOrCallExpression{
7006 SimpleExpression: &SimpleExpression{
7007 Identifier: &tk[2],
7008 Tokens: tk[2:3],
7009 },
7010 Tokens: tk[2:3],
7011 },
7012 Tokens: tk[2:3],
7013 },
7014 Tokens: tk[2:3],
7015 },
7016 Tokens: tk[2:3],
7017 },
7018 Tokens: tk[2:3],
7019 },
7020 Tokens: tk[2:3],
7021 },
7022 Tokens: tk[:3],
7023 }
7024 }},
7025 {"a : b", func(t *test, tk Tokens) { // 3
7026 t.Output = SequenceExpression{
7027 UnaryExpression: UnaryExpression{
7028 ExponentiationExpression: ExponentiationExpression{
7029 SubsetExpression: SubsetExpression{
7030 ScopeExpression: ScopeExpression{
7031 IndexOrCallExpression: IndexOrCallExpression{
7032 SimpleExpression: &SimpleExpression{
7033 Identifier: &tk[0],
7034 Tokens: tk[:1],
7035 },
7036 Tokens: tk[:1],
7037 },
7038 Tokens: tk[:1],
7039 },
7040 Tokens: tk[:1],
7041 },
7042 Tokens: tk[:1],
7043 },
7044 Tokens: tk[:1],
7045 },
7046 SequenceExpression: &SequenceExpression{
7047 UnaryExpression: UnaryExpression{
7048 ExponentiationExpression: ExponentiationExpression{
7049 SubsetExpression: SubsetExpression{
7050 ScopeExpression: ScopeExpression{
7051 IndexOrCallExpression: IndexOrCallExpression{
7052 SimpleExpression: &SimpleExpression{
7053 Identifier: &tk[4],
7054 Tokens: tk[4:5],
7055 },
7056 Tokens: tk[4:5],
7057 },
7058 Tokens: tk[4:5],
7059 },
7060 Tokens: tk[4:5],
7061 },
7062 Tokens: tk[4:5],
7063 },
7064 Tokens: tk[4:5],
7065 },
7066 Tokens: tk[4:5],
7067 },
7068 Tokens: tk[:5],
7069 }
7070 }},
7071 {"in", func(t *test, tk Tokens) { // 4
7072 t.Err = Error{
7073 Err: Error{
7074 Err: Error{
7075 Err: Error{
7076 Err: Error{
7077 Err: Error{
7078 Err: Error{
7079 Err: ErrInvalidSimpleExpression,
7080 Parsing: "SimpleExpression",
7081 Token: tk[0],
7082 },
7083 Parsing: "IndexOrCallExpression",
7084 Token: tk[0],
7085 },
7086 Parsing: "ScopeExpression",
7087 Token: tk[0],
7088 },
7089 Parsing: "SubsetExpression",
7090 Token: tk[0],
7091 },
7092 Parsing: "ExponentiationExpression",
7093 Token: tk[0],
7094 },
7095 Parsing: "UnaryExpression",
7096 Token: tk[0],
7097 },
7098 Parsing: "SequenceExpression",
7099 Token: tk[0],
7100 }
7101 }},
7102 {"a:in", func(t *test, tk Tokens) { // 5
7103 t.Err = Error{
7104 Err: Error{
7105 Err: Error{
7106 Err: Error{
7107 Err: Error{
7108 Err: Error{
7109 Err: Error{
7110 Err: Error{
7111 Err: ErrInvalidSimpleExpression,
7112 Parsing: "SimpleExpression",
7113 Token: tk[2],
7114 },
7115 Parsing: "IndexOrCallExpression",
7116 Token: tk[2],
7117 },
7118 Parsing: "ScopeExpression",
7119 Token: tk[2],
7120 },
7121 Parsing: "SubsetExpression",
7122 Token: tk[2],
7123 },
7124 Parsing: "ExponentiationExpression",
7125 Token: tk[2],
7126 },
7127 Parsing: "UnaryExpression",
7128 Token: tk[2],
7129 },
7130 Parsing: "SequenceExpression",
7131 Token: tk[2],
7132 },
7133 Parsing: "SequenceExpression",
7134 Token: tk[2],
7135 }
7136 }},
7137 {"a:#abc\nb", func(t *test, tk Tokens) { // 6
7138 t.Output = SequenceExpression{
7139 UnaryExpression: UnaryExpression{
7140 ExponentiationExpression: ExponentiationExpression{
7141 SubsetExpression: SubsetExpression{
7142 ScopeExpression: ScopeExpression{
7143 IndexOrCallExpression: IndexOrCallExpression{
7144 SimpleExpression: &SimpleExpression{
7145 Identifier: &tk[0],
7146 Tokens: tk[:1],
7147 },
7148 Tokens: tk[:1],
7149 },
7150 Tokens: tk[:1],
7151 },
7152 Tokens: tk[:1],
7153 },
7154 Tokens: tk[:1],
7155 },
7156 Tokens: tk[:1],
7157 },
7158 SequenceExpression: &SequenceExpression{
7159 UnaryExpression: UnaryExpression{
7160 ExponentiationExpression: ExponentiationExpression{
7161 SubsetExpression: SubsetExpression{
7162 ScopeExpression: ScopeExpression{
7163 IndexOrCallExpression: IndexOrCallExpression{
7164 SimpleExpression: &SimpleExpression{
7165 Identifier: &tk[4],
7166 Tokens: tk[4:5],
7167 },
7168 Tokens: tk[4:5],
7169 },
7170 Tokens: tk[4:5],
7171 },
7172 Tokens: tk[4:5],
7173 },
7174 Tokens: tk[4:5],
7175 },
7176 Tokens: tk[4:5],
7177 },
7178 Tokens: tk[4:5],
7179 },
7180 Comments: [2]Comments{nil, {tk[2]}},
7181 Tokens: tk[:5],
7182 }
7183 }},
7184 }, func(t *test) (Type, error) {
7185 var se SequenceExpression
7186
7187 err := se.parse(&t.Tokens)
7188
7189 return se, err
7190 })
7191 }
7192
7193 func TestUnaryExpression(t *testing.T) {
7194 doTests(t, []sourceFn{
7195 {"a", func(t *test, tk Tokens) { // 1
7196 t.Output = UnaryExpression{
7197 ExponentiationExpression: ExponentiationExpression{
7198 SubsetExpression: SubsetExpression{
7199 ScopeExpression: ScopeExpression{
7200 IndexOrCallExpression: IndexOrCallExpression{
7201 SimpleExpression: &SimpleExpression{
7202 Identifier: &tk[0],
7203 Tokens: tk[:1],
7204 },
7205 Tokens: tk[:1],
7206 },
7207 Tokens: tk[:1],
7208 },
7209 Tokens: tk[:1],
7210 },
7211 Tokens: tk[:1],
7212 },
7213 Tokens: tk[:1],
7214 }
7215 }},
7216 {"+a", func(t *test, tk Tokens) { // 2
7217 t.Output = UnaryExpression{
7218 UnaryType: []UnaryType{
7219 UnaryAdd,
7220 },
7221 ExponentiationExpression: ExponentiationExpression{
7222 SubsetExpression: SubsetExpression{
7223 ScopeExpression: ScopeExpression{
7224 IndexOrCallExpression: IndexOrCallExpression{
7225 SimpleExpression: &SimpleExpression{
7226 Identifier: &tk[1],
7227 Tokens: tk[1:2],
7228 },
7229 Tokens: tk[1:2],
7230 },
7231 Tokens: tk[1:2],
7232 },
7233 Tokens: tk[1:2],
7234 },
7235 Tokens: tk[1:2],
7236 },
7237 Comments: []Comments{nil},
7238 Tokens: tk[:2],
7239 }
7240 }},
7241 {"-a", func(t *test, tk Tokens) { // 3
7242 t.Output = UnaryExpression{
7243 UnaryType: []UnaryType{
7244 UnaryMinus,
7245 },
7246 ExponentiationExpression: ExponentiationExpression{
7247 SubsetExpression: SubsetExpression{
7248 ScopeExpression: ScopeExpression{
7249 IndexOrCallExpression: IndexOrCallExpression{
7250 SimpleExpression: &SimpleExpression{
7251 Identifier: &tk[1],
7252 Tokens: tk[1:2],
7253 },
7254 Tokens: tk[1:2],
7255 },
7256 Tokens: tk[1:2],
7257 },
7258 Tokens: tk[1:2],
7259 },
7260 Tokens: tk[1:2],
7261 },
7262 Comments: []Comments{nil},
7263 Tokens: tk[:2],
7264 }
7265 }},
7266 {"+ a", func(t *test, tk Tokens) { // 4
7267 t.Output = UnaryExpression{
7268 UnaryType: []UnaryType{
7269 UnaryAdd,
7270 },
7271 ExponentiationExpression: ExponentiationExpression{
7272 SubsetExpression: SubsetExpression{
7273 ScopeExpression: ScopeExpression{
7274 IndexOrCallExpression: IndexOrCallExpression{
7275 SimpleExpression: &SimpleExpression{
7276 Identifier: &tk[2],
7277 Tokens: tk[2:3],
7278 },
7279 Tokens: tk[2:3],
7280 },
7281 Tokens: tk[2:3],
7282 },
7283 Tokens: tk[2:3],
7284 },
7285 Tokens: tk[2:3],
7286 },
7287 Comments: []Comments{nil},
7288 Tokens: tk[:3],
7289 }
7290 }},
7291 {"+- + a", func(t *test, tk Tokens) { // 5
7292 t.Output = UnaryExpression{
7293 UnaryType: []UnaryType{
7294 UnaryAdd,
7295 UnaryMinus,
7296 UnaryAdd,
7297 },
7298 ExponentiationExpression: ExponentiationExpression{
7299 SubsetExpression: SubsetExpression{
7300 ScopeExpression: ScopeExpression{
7301 IndexOrCallExpression: IndexOrCallExpression{
7302 SimpleExpression: &SimpleExpression{
7303 Identifier: &tk[5],
7304 Tokens: tk[5:6],
7305 },
7306 Tokens: tk[5:6],
7307 },
7308 Tokens: tk[5:6],
7309 },
7310 Tokens: tk[5:6],
7311 },
7312 Tokens: tk[5:6],
7313 },
7314 Comments: []Comments{nil, nil, nil},
7315 Tokens: tk[:6],
7316 }
7317 }},
7318 {"in", func(t *test, tk Tokens) { // 6
7319 t.Err = Error{
7320 Err: Error{
7321 Err: Error{
7322 Err: Error{
7323 Err: Error{
7324 Err: Error{
7325 Err: ErrInvalidSimpleExpression,
7326 Parsing: "SimpleExpression",
7327 Token: tk[0],
7328 },
7329 Parsing: "IndexOrCallExpression",
7330 Token: tk[0],
7331 },
7332 Parsing: "ScopeExpression",
7333 Token: tk[0],
7334 },
7335 Parsing: "SubsetExpression",
7336 Token: tk[0],
7337 },
7338 Parsing: "ExponentiationExpression",
7339 Token: tk[0],
7340 },
7341 Parsing: "UnaryExpression",
7342 Token: tk[0],
7343 }
7344 }},
7345 {"+#abc\na", func(t *test, tk Tokens) { // 7
7346 t.Output = UnaryExpression{
7347 UnaryType: []UnaryType{
7348 UnaryAdd,
7349 },
7350 ExponentiationExpression: ExponentiationExpression{
7351 SubsetExpression: SubsetExpression{
7352 ScopeExpression: ScopeExpression{
7353 IndexOrCallExpression: IndexOrCallExpression{
7354 SimpleExpression: &SimpleExpression{
7355 Identifier: &tk[3],
7356 Tokens: tk[3:4],
7357 },
7358 Tokens: tk[3:4],
7359 },
7360 Tokens: tk[3:4],
7361 },
7362 Tokens: tk[3:4],
7363 },
7364 Tokens: tk[3:4],
7365 },
7366 Comments: []Comments{{tk[1]}},
7367 Tokens: tk[:4],
7368 }
7369 }},
7370 {"+#abc\n-#def\na", func(t *test, tk Tokens) { // 8
7371 t.Output = UnaryExpression{
7372 UnaryType: []UnaryType{
7373 UnaryAdd,
7374 UnaryMinus,
7375 },
7376 ExponentiationExpression: ExponentiationExpression{
7377 SubsetExpression: SubsetExpression{
7378 ScopeExpression: ScopeExpression{
7379 IndexOrCallExpression: IndexOrCallExpression{
7380 SimpleExpression: &SimpleExpression{
7381 Identifier: &tk[6],
7382 Tokens: tk[6:7],
7383 },
7384 Tokens: tk[6:7],
7385 },
7386 Tokens: tk[6:7],
7387 },
7388 Tokens: tk[6:7],
7389 },
7390 Tokens: tk[6:7],
7391 },
7392 Comments: []Comments{{tk[1]}, {tk[4]}},
7393 Tokens: tk[:7],
7394 }
7395 }},
7396 }, func(t *test) (Type, error) {
7397 var ue UnaryExpression
7398
7399 err := ue.parse(&t.Tokens)
7400
7401 return ue, err
7402 })
7403 }
7404
7405 func TestExponentiationExpression(t *testing.T) {
7406 doTests(t, []sourceFn{
7407 {"a", func(t *test, tk Tokens) { // 1
7408 t.Output = ExponentiationExpression{
7409 SubsetExpression: SubsetExpression{
7410 ScopeExpression: ScopeExpression{
7411 IndexOrCallExpression: IndexOrCallExpression{
7412 SimpleExpression: &SimpleExpression{
7413 Identifier: &tk[0],
7414 Tokens: tk[:1],
7415 },
7416 Tokens: tk[:1],
7417 },
7418 Tokens: tk[:1],
7419 },
7420 Tokens: tk[:1],
7421 },
7422 Tokens: tk[:1],
7423 }
7424 }},
7425 {"a^b", func(t *test, tk Tokens) { // 2
7426 t.Output = ExponentiationExpression{
7427 SubsetExpression: SubsetExpression{
7428 ScopeExpression: ScopeExpression{
7429 IndexOrCallExpression: IndexOrCallExpression{
7430 SimpleExpression: &SimpleExpression{
7431 Identifier: &tk[0],
7432 Tokens: tk[:1],
7433 },
7434 Tokens: tk[:1],
7435 },
7436 Tokens: tk[:1],
7437 },
7438 Tokens: tk[:1],
7439 },
7440 ExponentiationExpression: &ExponentiationExpression{
7441 SubsetExpression: SubsetExpression{
7442 ScopeExpression: ScopeExpression{
7443 IndexOrCallExpression: IndexOrCallExpression{
7444 SimpleExpression: &SimpleExpression{
7445 Identifier: &tk[2],
7446 Tokens: tk[2:3],
7447 },
7448 Tokens: tk[2:3],
7449 },
7450 Tokens: tk[2:3],
7451 },
7452 Tokens: tk[2:3],
7453 },
7454 Tokens: tk[2:3],
7455 },
7456 Tokens: tk[:3],
7457 }
7458 }},
7459 {"a ^ b", func(t *test, tk Tokens) { // 3
7460 t.Output = ExponentiationExpression{
7461 SubsetExpression: SubsetExpression{
7462 ScopeExpression: ScopeExpression{
7463 IndexOrCallExpression: IndexOrCallExpression{
7464 SimpleExpression: &SimpleExpression{
7465 Identifier: &tk[0],
7466 Tokens: tk[:1],
7467 },
7468 Tokens: tk[:1],
7469 },
7470 Tokens: tk[:1],
7471 },
7472 Tokens: tk[:1],
7473 },
7474 ExponentiationExpression: &ExponentiationExpression{
7475 SubsetExpression: SubsetExpression{
7476 ScopeExpression: ScopeExpression{
7477 IndexOrCallExpression: IndexOrCallExpression{
7478 SimpleExpression: &SimpleExpression{
7479 Identifier: &tk[4],
7480 Tokens: tk[4:5],
7481 },
7482 Tokens: tk[4:5],
7483 },
7484 Tokens: tk[4:5],
7485 },
7486 Tokens: tk[4:5],
7487 },
7488 Tokens: tk[4:5],
7489 },
7490 Tokens: tk[:5],
7491 }
7492 }},
7493 {"in", func(t *test, tk Tokens) { // 4
7494 t.Err = Error{
7495 Err: Error{
7496 Err: Error{
7497 Err: Error{
7498 Err: Error{
7499 Err: ErrInvalidSimpleExpression,
7500 Parsing: "SimpleExpression",
7501 Token: tk[0],
7502 },
7503 Parsing: "IndexOrCallExpression",
7504 Token: tk[0],
7505 },
7506 Parsing: "ScopeExpression",
7507 Token: tk[0],
7508 },
7509 Parsing: "SubsetExpression",
7510 Token: tk[0],
7511 },
7512 Parsing: "ExponentiationExpression",
7513 Token: tk[0],
7514 }
7515 }},
7516 {"a^in", func(t *test, tk Tokens) { // 5
7517 t.Err = Error{
7518 Err: Error{
7519 Err: Error{
7520 Err: Error{
7521 Err: Error{
7522 Err: Error{
7523 Err: ErrInvalidSimpleExpression,
7524 Parsing: "SimpleExpression",
7525 Token: tk[2],
7526 },
7527 Parsing: "IndexOrCallExpression",
7528 Token: tk[2],
7529 },
7530 Parsing: "ScopeExpression",
7531 Token: tk[2],
7532 },
7533 Parsing: "SubsetExpression",
7534 Token: tk[2],
7535 },
7536 Parsing: "ExponentiationExpression",
7537 Token: tk[2],
7538 },
7539 Parsing: "ExponentiationExpression",
7540 Token: tk[2],
7541 }
7542 }},
7543 {"a^#abc\nb", func(t *test, tk Tokens) { // 6
7544 t.Output = ExponentiationExpression{
7545 SubsetExpression: SubsetExpression{
7546 ScopeExpression: ScopeExpression{
7547 IndexOrCallExpression: IndexOrCallExpression{
7548 SimpleExpression: &SimpleExpression{
7549 Identifier: &tk[0],
7550 Tokens: tk[:1],
7551 },
7552 Tokens: tk[:1],
7553 },
7554 Tokens: tk[:1],
7555 },
7556 Tokens: tk[:1],
7557 },
7558 ExponentiationExpression: &ExponentiationExpression{
7559 SubsetExpression: SubsetExpression{
7560 ScopeExpression: ScopeExpression{
7561 IndexOrCallExpression: IndexOrCallExpression{
7562 SimpleExpression: &SimpleExpression{
7563 Identifier: &tk[4],
7564 Tokens: tk[4:5],
7565 },
7566 Tokens: tk[4:5],
7567 },
7568 Tokens: tk[4:5],
7569 },
7570 Tokens: tk[4:5],
7571 },
7572 Tokens: tk[4:5],
7573 },
7574 Comments: [2]Comments{nil, {tk[2]}},
7575 Tokens: tk[:5],
7576 }
7577 }},
7578 }, func(t *test) (Type, error) {
7579 var ee ExponentiationExpression
7580
7581 err := ee.parse(&t.Tokens)
7582
7583 return ee, err
7584 })
7585 }
7586
7587 func TestSubsetExpression(t *testing.T) {
7588 doTests(t, []sourceFn{
7589 {"a", func(t *test, tk Tokens) { // 1
7590 t.Output = SubsetExpression{
7591 ScopeExpression: ScopeExpression{
7592 IndexOrCallExpression: IndexOrCallExpression{
7593 SimpleExpression: &SimpleExpression{
7594 Identifier: &tk[0],
7595 Tokens: tk[:1],
7596 },
7597 Tokens: tk[:1],
7598 },
7599 Tokens: tk[:1],
7600 },
7601 Tokens: tk[:1],
7602 }
7603 }},
7604 {"a$b", func(t *test, tk Tokens) { // 2
7605 t.Output = SubsetExpression{
7606 SubsetType: SubsetList,
7607 ScopeExpression: ScopeExpression{
7608 IndexOrCallExpression: IndexOrCallExpression{
7609 SimpleExpression: &SimpleExpression{
7610 Identifier: &tk[0],
7611 Tokens: tk[:1],
7612 },
7613 Tokens: tk[:1],
7614 },
7615 Tokens: tk[:1],
7616 },
7617 SubsetExpression: &SubsetExpression{
7618 ScopeExpression: ScopeExpression{
7619 IndexOrCallExpression: IndexOrCallExpression{
7620 SimpleExpression: &SimpleExpression{
7621 Identifier: &tk[2],
7622 Tokens: tk[2:3],
7623 },
7624 Tokens: tk[2:3],
7625 },
7626 Tokens: tk[2:3],
7627 },
7628 Tokens: tk[2:3],
7629 },
7630 Tokens: tk[:3],
7631 }
7632 }},
7633 {"a $ b", func(t *test, tk Tokens) { // 3
7634 t.Output = SubsetExpression{
7635 SubsetType: SubsetList,
7636 ScopeExpression: ScopeExpression{
7637 IndexOrCallExpression: IndexOrCallExpression{
7638 SimpleExpression: &SimpleExpression{
7639 Identifier: &tk[0],
7640 Tokens: tk[:1],
7641 },
7642 Tokens: tk[:1],
7643 },
7644 Tokens: tk[:1],
7645 },
7646 SubsetExpression: &SubsetExpression{
7647 ScopeExpression: ScopeExpression{
7648 IndexOrCallExpression: IndexOrCallExpression{
7649 SimpleExpression: &SimpleExpression{
7650 Identifier: &tk[4],
7651 Tokens: tk[4:5],
7652 },
7653 Tokens: tk[4:5],
7654 },
7655 Tokens: tk[4:5],
7656 },
7657 Tokens: tk[4:5],
7658 },
7659 Tokens: tk[:5],
7660 }
7661 }},
7662 {"a@b", func(t *test, tk Tokens) { // 4
7663 t.Output = SubsetExpression{
7664 SubsetType: SubsetStructure,
7665 ScopeExpression: ScopeExpression{
7666 IndexOrCallExpression: IndexOrCallExpression{
7667 SimpleExpression: &SimpleExpression{
7668 Identifier: &tk[0],
7669 Tokens: tk[:1],
7670 },
7671 Tokens: tk[:1],
7672 },
7673 Tokens: tk[:1],
7674 },
7675 SubsetExpression: &SubsetExpression{
7676 ScopeExpression: ScopeExpression{
7677 IndexOrCallExpression: IndexOrCallExpression{
7678 SimpleExpression: &SimpleExpression{
7679 Identifier: &tk[2],
7680 Tokens: tk[2:3],
7681 },
7682 Tokens: tk[2:3],
7683 },
7684 Tokens: tk[2:3],
7685 },
7686 Tokens: tk[2:3],
7687 },
7688 Tokens: tk[:3],
7689 }
7690 }},
7691 {"a @ b", func(t *test, tk Tokens) { // 5
7692 t.Output = SubsetExpression{
7693 SubsetType: SubsetStructure,
7694 ScopeExpression: ScopeExpression{
7695 IndexOrCallExpression: IndexOrCallExpression{
7696 SimpleExpression: &SimpleExpression{
7697 Identifier: &tk[0],
7698 Tokens: tk[:1],
7699 },
7700 Tokens: tk[:1],
7701 },
7702 Tokens: tk[:1],
7703 },
7704 SubsetExpression: &SubsetExpression{
7705 ScopeExpression: ScopeExpression{
7706 IndexOrCallExpression: IndexOrCallExpression{
7707 SimpleExpression: &SimpleExpression{
7708 Identifier: &tk[4],
7709 Tokens: tk[4:5],
7710 },
7711 Tokens: tk[4:5],
7712 },
7713 Tokens: tk[4:5],
7714 },
7715 Tokens: tk[4:5],
7716 },
7717 Tokens: tk[:5],
7718 }
7719 }},
7720 {"in", func(t *test, tk Tokens) { // 6
7721 t.Err = Error{
7722 Err: Error{
7723 Err: Error{
7724 Err: Error{
7725 Err: ErrInvalidSimpleExpression,
7726 Parsing: "SimpleExpression",
7727 Token: tk[0],
7728 },
7729 Parsing: "IndexOrCallExpression",
7730 Token: tk[0],
7731 },
7732 Parsing: "ScopeExpression",
7733 Token: tk[0],
7734 },
7735 Parsing: "SubsetExpression",
7736 Token: tk[0],
7737 }
7738 }},
7739 {"a$in", func(t *test, tk Tokens) { // 7
7740 t.Err = Error{
7741 Err: Error{
7742 Err: Error{
7743 Err: Error{
7744 Err: Error{
7745 Err: ErrInvalidSimpleExpression,
7746 Parsing: "SimpleExpression",
7747 Token: tk[2],
7748 },
7749 Parsing: "IndexOrCallExpression",
7750 Token: tk[2],
7751 },
7752 Parsing: "ScopeExpression",
7753 Token: tk[2],
7754 },
7755 Parsing: "SubsetExpression",
7756 Token: tk[2],
7757 },
7758 Parsing: "SubsetExpression",
7759 Token: tk[2],
7760 }
7761 }},
7762 {"a@in", func(t *test, tk Tokens) { // 8
7763 t.Err = Error{
7764 Err: Error{
7765 Err: Error{
7766 Err: Error{
7767 Err: Error{
7768 Err: ErrInvalidSimpleExpression,
7769 Parsing: "SimpleExpression",
7770 Token: tk[2],
7771 },
7772 Parsing: "IndexOrCallExpression",
7773 Token: tk[2],
7774 },
7775 Parsing: "ScopeExpression",
7776 Token: tk[2],
7777 },
7778 Parsing: "SubsetExpression",
7779 Token: tk[2],
7780 },
7781 Parsing: "SubsetExpression",
7782 Token: tk[2],
7783 }
7784 }},
7785 {"a$#abc\nb", func(t *test, tk Tokens) { // 9
7786 t.Output = SubsetExpression{
7787 SubsetType: SubsetList,
7788 ScopeExpression: ScopeExpression{
7789 IndexOrCallExpression: IndexOrCallExpression{
7790 SimpleExpression: &SimpleExpression{
7791 Identifier: &tk[0],
7792 Tokens: tk[:1],
7793 },
7794 Tokens: tk[:1],
7795 },
7796 Tokens: tk[:1],
7797 },
7798 SubsetExpression: &SubsetExpression{
7799 ScopeExpression: ScopeExpression{
7800 IndexOrCallExpression: IndexOrCallExpression{
7801 SimpleExpression: &SimpleExpression{
7802 Identifier: &tk[4],
7803 Tokens: tk[4:5],
7804 },
7805 Tokens: tk[4:5],
7806 },
7807 Tokens: tk[4:5],
7808 },
7809 Tokens: tk[4:5],
7810 },
7811 Comments: [2]Comments{nil, {tk[2]}},
7812 Tokens: tk[:5],
7813 }
7814 }},
7815 }, func(t *test) (Type, error) {
7816 var se SubsetExpression
7817
7818 err := se.parse(&t.Tokens)
7819
7820 return se, err
7821 })
7822 }
7823
7824 func TestScopeExpression(t *testing.T) {
7825 doTests(t, []sourceFn{
7826 {"a", func(t *test, tk Tokens) { // 1
7827 t.Output = ScopeExpression{
7828 IndexOrCallExpression: IndexOrCallExpression{
7829 SimpleExpression: &SimpleExpression{
7830 Identifier: &tk[0],
7831 Tokens: tk[:1],
7832 },
7833 Tokens: tk[:1],
7834 },
7835 Tokens: tk[:1],
7836 }
7837 }},
7838 {"a::b", func(t *test, tk Tokens) { // 2
7839 t.Output = ScopeExpression{
7840 IndexOrCallExpression: IndexOrCallExpression{
7841 SimpleExpression: &SimpleExpression{
7842 Identifier: &tk[0],
7843 Tokens: tk[:1],
7844 },
7845 Tokens: tk[:1],
7846 },
7847 ScopeExpression: &ScopeExpression{
7848 IndexOrCallExpression: IndexOrCallExpression{
7849 SimpleExpression: &SimpleExpression{
7850 Identifier: &tk[2],
7851 Tokens: tk[2:3],
7852 },
7853 Tokens: tk[2:3],
7854 },
7855 Tokens: tk[2:3],
7856 },
7857 Tokens: tk[:3],
7858 }
7859 }},
7860 {"a :: b", func(t *test, tk Tokens) { // 3
7861 t.Output = ScopeExpression{
7862 IndexOrCallExpression: IndexOrCallExpression{
7863 SimpleExpression: &SimpleExpression{
7864 Identifier: &tk[0],
7865 Tokens: tk[:1],
7866 },
7867 Tokens: tk[:1],
7868 },
7869 ScopeExpression: &ScopeExpression{
7870 IndexOrCallExpression: IndexOrCallExpression{
7871 SimpleExpression: &SimpleExpression{
7872 Identifier: &tk[4],
7873 Tokens: tk[4:5],
7874 },
7875 Tokens: tk[4:5],
7876 },
7877 Tokens: tk[4:5],
7878 },
7879 Tokens: tk[:5],
7880 }
7881 }},
7882 {"a::b::c", func(t *test, tk Tokens) { // 4
7883 t.Output = ScopeExpression{
7884 IndexOrCallExpression: IndexOrCallExpression{
7885 SimpleExpression: &SimpleExpression{
7886 Identifier: &tk[0],
7887 Tokens: tk[:1],
7888 },
7889 Tokens: tk[:1],
7890 },
7891 ScopeExpression: &ScopeExpression{
7892 IndexOrCallExpression: IndexOrCallExpression{
7893 SimpleExpression: &SimpleExpression{
7894 Identifier: &tk[2],
7895 Tokens: tk[2:3],
7896 },
7897 Tokens: tk[2:3],
7898 },
7899 ScopeExpression: &ScopeExpression{
7900 IndexOrCallExpression: IndexOrCallExpression{
7901 SimpleExpression: &SimpleExpression{
7902 Identifier: &tk[4],
7903 Tokens: tk[4:5],
7904 },
7905 Tokens: tk[4:5],
7906 },
7907 Tokens: tk[4:5],
7908 },
7909 Tokens: tk[2:5],
7910 },
7911 Tokens: tk[:5],
7912 }
7913 }},
7914 {"in", func(t *test, tk Tokens) { // 5
7915 t.Err = Error{
7916 Err: Error{
7917 Err: Error{
7918 Err: ErrInvalidSimpleExpression,
7919 Parsing: "SimpleExpression",
7920 Token: tk[0],
7921 },
7922 Parsing: "IndexOrCallExpression",
7923 Token: tk[0],
7924 },
7925 Parsing: "ScopeExpression",
7926 Token: tk[0],
7927 }
7928 }},
7929 {"a::in", func(t *test, tk Tokens) { // 6
7930 t.Err = Error{
7931 Err: Error{
7932 Err: Error{
7933 Err: Error{
7934 Err: ErrInvalidSimpleExpression,
7935 Parsing: "SimpleExpression",
7936 Token: tk[2],
7937 },
7938 Parsing: "IndexOrCallExpression",
7939 Token: tk[2],
7940 },
7941 Parsing: "ScopeExpression",
7942 Token: tk[2],
7943 },
7944 Parsing: "ScopeExpression",
7945 Token: tk[2],
7946 }
7947 }},
7948 {"a::#abc\nb", func(t *test, tk Tokens) { // 7
7949 t.Output = ScopeExpression{
7950 IndexOrCallExpression: IndexOrCallExpression{
7951 SimpleExpression: &SimpleExpression{
7952 Identifier: &tk[0],
7953 Tokens: tk[:1],
7954 },
7955 Tokens: tk[:1],
7956 },
7957 ScopeExpression: &ScopeExpression{
7958 IndexOrCallExpression: IndexOrCallExpression{
7959 SimpleExpression: &SimpleExpression{
7960 Identifier: &tk[4],
7961 Tokens: tk[4:5],
7962 },
7963 Tokens: tk[4:5],
7964 },
7965 Tokens: tk[4:5],
7966 },
7967 Comments: [2]Comments{nil, {tk[2]}},
7968 Tokens: tk[:5],
7969 }
7970 }},
7971 }, func(t *test) (Type, error) {
7972 var se ScopeExpression
7973
7974 err := se.parse(&t.Tokens)
7975
7976 return se, err
7977 })
7978 }
7979
7980 func TestIndexOrCallExpression(t *testing.T) {
7981 doTests(t, []sourceFn{
7982 {"a[b]", func(t *test, tk Tokens) { // 1
7983 t.Output = IndexOrCallExpression{
7984 IndexOrCallExpression: &IndexOrCallExpression{
7985 SimpleExpression: &SimpleExpression{
7986 Identifier: &tk[0],
7987 Tokens: tk[:1],
7988 },
7989 Tokens: tk[:1],
7990 },
7991 Index: &Index{
7992 Args: []IndexExpression{
7993 {
7994 QueryExpression: *WrapQuery(&SimpleExpression{
7995 Identifier: &tk[2],
7996 Tokens: tk[2:3],
7997 }),
7998 Tokens: tk[2:3],
7999 },
8000 },
8001 Tokens: tk[1:4],
8002 },
8003 Tokens: tk[:4],
8004 }
8005 }},
8006 {"a [b]", func(t *test, tk Tokens) { // 2
8007 t.Output = IndexOrCallExpression{
8008 IndexOrCallExpression: &IndexOrCallExpression{
8009 SimpleExpression: &SimpleExpression{
8010 Identifier: &tk[0],
8011 Tokens: tk[:1],
8012 },
8013 Tokens: tk[:1],
8014 },
8015 Index: &Index{
8016 Args: []IndexExpression{
8017 {
8018 QueryExpression: *WrapQuery(&SimpleExpression{
8019 Identifier: &tk[3],
8020 Tokens: tk[3:4],
8021 }),
8022 Tokens: tk[3:4],
8023 },
8024 },
8025 Tokens: tk[2:5],
8026 },
8027 Tokens: tk[:5],
8028 }
8029 }},
8030 {"a[[b]]", func(t *test, tk Tokens) { // 3
8031 t.Output = IndexOrCallExpression{
8032 IndexOrCallExpression: &IndexOrCallExpression{
8033 SimpleExpression: &SimpleExpression{
8034 Identifier: &tk[0],
8035 Tokens: tk[:1],
8036 },
8037 Tokens: tk[:1],
8038 },
8039 Index: &Index{
8040 Double: true,
8041 Args: []IndexExpression{
8042 {
8043 QueryExpression: *WrapQuery(&SimpleExpression{
8044 Identifier: &tk[2],
8045 Tokens: tk[2:3],
8046 }),
8047 Tokens: tk[2:3],
8048 },
8049 },
8050 Tokens: tk[1:4],
8051 },
8052 Tokens: tk[:4],
8053 }
8054 }},
8055 {"a [[b]]", func(t *test, tk Tokens) { // 4
8056 t.Output = IndexOrCallExpression{
8057 IndexOrCallExpression: &IndexOrCallExpression{
8058 SimpleExpression: &SimpleExpression{
8059 Identifier: &tk[0],
8060 Tokens: tk[:1],
8061 },
8062 Tokens: tk[:1],
8063 },
8064 Index: &Index{
8065 Double: true,
8066 Args: []IndexExpression{
8067 {
8068 QueryExpression: *WrapQuery(&SimpleExpression{
8069 Identifier: &tk[3],
8070 Tokens: tk[3:4],
8071 }),
8072 Tokens: tk[3:4],
8073 },
8074 },
8075 Tokens: tk[2:5],
8076 },
8077 Tokens: tk[:5],
8078 }
8079 }},
8080 {"a(b)", func(t *test, tk Tokens) { // 5
8081 t.Output = IndexOrCallExpression{
8082 IndexOrCallExpression: &IndexOrCallExpression{
8083 SimpleExpression: &SimpleExpression{
8084 Identifier: &tk[0],
8085 Tokens: tk[:1],
8086 },
8087 Tokens: tk[:1],
8088 },
8089 Call: &Call{
8090 Args: []Arg{
8091 {
8092 QueryExpression: WrapQuery(&SimpleExpression{
8093 Identifier: &tk[2],
8094 Tokens: tk[2:3],
8095 }),
8096 Tokens: tk[2:3],
8097 },
8098 },
8099 Tokens: tk[1:4],
8100 },
8101 Tokens: tk[:4],
8102 }
8103 }},
8104 {"a (b)", func(t *test, tk Tokens) { // 6
8105 t.Output = IndexOrCallExpression{
8106 IndexOrCallExpression: &IndexOrCallExpression{
8107 SimpleExpression: &SimpleExpression{
8108 Identifier: &tk[0],
8109 Tokens: tk[:1],
8110 },
8111 Tokens: tk[:1],
8112 },
8113 Call: &Call{
8114 Args: []Arg{
8115 {
8116 QueryExpression: WrapQuery(&SimpleExpression{
8117 Identifier: &tk[3],
8118 Tokens: tk[3:4],
8119 }),
8120 Tokens: tk[3:4],
8121 },
8122 },
8123 Tokens: tk[2:5],
8124 },
8125 Tokens: tk[:5],
8126 }
8127 }},
8128 {"in", func(t *test, tk Tokens) { // 7
8129 t.Err = Error{
8130 Err: Error{
8131 Err: ErrInvalidSimpleExpression,
8132 Parsing: "SimpleExpression",
8133 Token: tk[0],
8134 },
8135 Parsing: "IndexOrCallExpression",
8136 Token: tk[0],
8137 }
8138 }},
8139 {"a[in]", func(t *test, tk Tokens) { // 8
8140 t.Err = Error{
8141 Err: Error{
8142 Err: Error{
8143 Err: wrapQueryExpressionError(Error{
8144 Err: ErrInvalidSimpleExpression,
8145 Parsing: "SimpleExpression",
8146 Token: tk[2],
8147 }),
8148 Parsing: "IndexExpression",
8149 Token: tk[2],
8150 },
8151 Parsing: "Index",
8152 Token: tk[2],
8153 },
8154 Parsing: "IndexOrCallExpression",
8155 Token: tk[1],
8156 }
8157 }},
8158 {"a(in)", func(t *test, tk Tokens) { // 9
8159 t.Err = Error{
8160 Err: Error{
8161 Err: Error{
8162 Err: wrapQueryExpressionError(Error{
8163 Err: ErrInvalidSimpleExpression,
8164 Parsing: "SimpleExpression",
8165 Token: tk[2],
8166 }),
8167 Parsing: "Arg",
8168 Token: tk[2],
8169 },
8170 Parsing: "Call",
8171 Token: tk[2],
8172 },
8173 Parsing: "IndexOrCallExpression",
8174 Token: tk[1],
8175 }
8176 }},
8177 {"a#abv\n[b]", func(t *test, tk Tokens) { // 10
8178 t.Output = IndexOrCallExpression{
8179 SimpleExpression: &SimpleExpression{
8180 Identifier: &tk[0],
8181 Tokens: tk[:1],
8182 },
8183 Tokens: tk[:1],
8184 }
8185 }},
8186 }, func(t *test) (Type, error) {
8187 var ice IndexOrCallExpression
8188
8189 err := ice.parse(&t.Tokens)
8190
8191 return ice, err
8192 })
8193 }
8194
8195 func TestSimpleExpression(t *testing.T) {
8196 doTests(t, []sourceFn{
8197 {"a", func(t *test, tk Tokens) { // 1
8198 t.Output = SimpleExpression{
8199 Identifier: &tk[0],
8200 Tokens: tk[:1],
8201 }
8202 }},
8203 {"1", func(t *test, tk Tokens) { // 2
8204 t.Output = SimpleExpression{
8205 Constant: &tk[0],
8206 Tokens: tk[:1],
8207 }
8208 }},
8209 {"2L", func(t *test, tk Tokens) { // 3
8210 t.Output = SimpleExpression{
8211 Constant: &tk[0],
8212 Tokens: tk[:1],
8213 }
8214 }},
8215 {"3i", func(t *test, tk Tokens) { // 4
8216 t.Output = SimpleExpression{
8217 Constant: &tk[0],
8218 Tokens: tk[:1],
8219 }
8220 }},
8221 {"TRUE", func(t *test, tk Tokens) { // 5
8222 t.Output = SimpleExpression{
8223 Constant: &tk[0],
8224 Tokens: tk[:1],
8225 }
8226 }},
8227 {"FALSE", func(t *test, tk Tokens) { // 6
8228 t.Output = SimpleExpression{
8229 Constant: &tk[0],
8230 Tokens: tk[:1],
8231 }
8232 }},
8233 {"\"abc\"", func(t *test, tk Tokens) { // 7
8234 t.Output = SimpleExpression{
8235 Constant: &tk[0],
8236 Tokens: tk[:1],
8237 }
8238 }},
8239 {"NULL", func(t *test, tk Tokens) { // 8
8240 t.Output = SimpleExpression{
8241 Constant: &tk[0],
8242 Tokens: tk[:1],
8243 }
8244 }},
8245 {"NA", func(t *test, tk Tokens) { // 9
8246 t.Output = SimpleExpression{
8247 Constant: &tk[0],
8248 Tokens: tk[:1],
8249 }
8250 }},
8251 {"...", func(t *test, tk Tokens) { // 10
8252 t.Output = SimpleExpression{
8253 Ellipsis: &tk[0],
8254 Tokens: tk[:1],
8255 }
8256 }},
8257 {"..1", func(t *test, tk Tokens) { // 11
8258 t.Output = SimpleExpression{
8259 Ellipsis: &tk[0],
8260 Tokens: tk[:1],
8261 }
8262 }},
8263 {"(a)", func(t *test, tk Tokens) { // 12
8264 t.Output = SimpleExpression{
8265 ParenthesizedExpression: &ParenthesizedExpression{
8266 Expression: Expression{
8267 QueryExpression: WrapQuery(&SimpleExpression{
8268 Identifier: &tk[1],
8269 Tokens: tk[1:2],
8270 }),
8271 Tokens: tk[1:2],
8272 },
8273 Tokens: tk[:3],
8274 },
8275 Tokens: tk[:3],
8276 }
8277 }},
8278 {"{a}", func(t *test, tk Tokens) { // 13
8279 t.Output = SimpleExpression{
8280 CompoundExpression: &CompoundExpression{
8281 Expressions: []Expression{
8282 {
8283 QueryExpression: WrapQuery(&SimpleExpression{
8284 Identifier: &tk[1],
8285 Tokens: tk[1:2],
8286 }),
8287 Tokens: tk[1:2],
8288 },
8289 },
8290 Tokens: tk[:3],
8291 },
8292 Tokens: tk[:3],
8293 }
8294 }},
8295 {"in", func(t *test, tk Tokens) { // 14
8296 t.Err = Error{
8297 Err: ErrInvalidSimpleExpression,
8298 Parsing: "SimpleExpression",
8299 Token: tk[0],
8300 }
8301 }},
8302 {"(a b)", func(t *test, tk Tokens) { // 15
8303 t.Err = Error{
8304 Err: Error{
8305 Err: ErrMissingClosingParen,
8306 Parsing: "ParenthesizedExpression",
8307 Token: tk[3],
8308 },
8309 Parsing: "SimpleExpression",
8310 Token: tk[0],
8311 }
8312 }},
8313 {"(in)", func(t *test, tk Tokens) { // 16
8314 t.Err = Error{
8315 Err: Error{
8316 Err: Error{
8317 Err: wrapQueryExpressionError(Error{
8318 Err: ErrInvalidSimpleExpression,
8319 Parsing: "SimpleExpression",
8320 Token: tk[1],
8321 }),
8322 Parsing: "Expression",
8323 Token: tk[1],
8324 },
8325 Parsing: "ParenthesizedExpression",
8326 Token: tk[1],
8327 },
8328 Parsing: "SimpleExpression",
8329 Token: tk[0],
8330 }
8331 }},
8332 {"{in}", func(t *test, tk Tokens) { // 17
8333 t.Err = Error{
8334 Err: Error{
8335 Err: Error{
8336 Err: wrapQueryExpressionError(Error{
8337 Err: ErrInvalidSimpleExpression,
8338 Parsing: "SimpleExpression",
8339 Token: tk[1],
8340 }),
8341 Parsing: "Expression",
8342 Token: tk[1],
8343 },
8344 Parsing: "CompoundExpression",
8345 Token: tk[1],
8346 },
8347 Parsing: "SimpleExpression",
8348 Token: tk[0],
8349 }
8350 }},
8351 }, func(t *test) (Type, error) {
8352 var se SimpleExpression
8353
8354 err := se.parse(&t.Tokens)
8355
8356 return se, err
8357 })
8358 }
8359
8360 func TestParenthesizedExpression(t *testing.T) {
8361 doTests(t, []sourceFn{
8362 {"(a)", func(t *test, tk Tokens) { // 1
8363 t.Output = ParenthesizedExpression{
8364 Expression: Expression{
8365 QueryExpression: WrapQuery(&SimpleExpression{
8366 Identifier: &tk[1],
8367 Tokens: tk[1:2],
8368 }),
8369 Tokens: tk[1:2],
8370 },
8371 Tokens: tk[:3],
8372 }
8373 }},
8374 {"(\na\n)", func(t *test, tk Tokens) { // 2
8375 t.Output = ParenthesizedExpression{
8376 Expression: Expression{
8377 QueryExpression: WrapQuery(&SimpleExpression{
8378 Identifier: &tk[2],
8379 Tokens: tk[2:3],
8380 }),
8381 Tokens: tk[2:3],
8382 },
8383 Tokens: tk[:5],
8384 }
8385 }},
8386 {"(in)", func(t *test, tk Tokens) { // 3
8387 t.Err = Error{
8388 Err: Error{
8389 Err: wrapQueryExpressionError(Error{
8390 Err: ErrInvalidSimpleExpression,
8391 Parsing: "SimpleExpression",
8392 Token: tk[1],
8393 }),
8394 Parsing: "Expression",
8395 Token: tk[1],
8396 },
8397 Parsing: "ParenthesizedExpression",
8398 Token: tk[1],
8399 }
8400 }},
8401 {"(#a comment\n# Another Comment\na\n\n# parsed\n)", func(t *test, tk Tokens) { // 4
8402 t.Output = ParenthesizedExpression{
8403 Expression: Expression{
8404 QueryExpression: WrapQuery(&SimpleExpression{
8405 Identifier: &tk[5],
8406 Tokens: tk[5:6],
8407 }),
8408 Comments: [2]Comments{{tk[1], tk[3]}, {tk[8]}},
8409 Tokens: tk[1:9],
8410 },
8411 Tokens: tk[:11],
8412 }
8413 }},
8414 {"(a#abc\n?#def\nb)", func(t *test, tk Tokens) { // 5
8415 t.Output = ParenthesizedExpression{
8416 Expression: Expression{
8417 QueryExpression: &QueryExpression{
8418 AssignmentExpression: WrapQuery(&SimpleExpression{
8419 Identifier: &tk[1],
8420 Tokens: tk[1:2],
8421 }).AssignmentExpression,
8422 QueryExpression: WrapQuery(&SimpleExpression{
8423 Identifier: &tk[7],
8424 Tokens: tk[7:8],
8425 }),
8426 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8427 Tokens: tk[1:8],
8428 },
8429 Tokens: tk[1:8],
8430 },
8431 Tokens: tk[:9],
8432 }
8433 }},
8434 {"(a#abc\n=#def\nb)", func(t *test, tk Tokens) { // 6
8435 t.Output = ParenthesizedExpression{
8436 Expression: Expression{
8437 QueryExpression: &QueryExpression{
8438 AssignmentExpression: &AssignmentExpression{
8439 FormulaeExpression: WrapQuery(&SimpleExpression{
8440 Identifier: &tk[1],
8441 Tokens: tk[1:2],
8442 }).AssignmentExpression.FormulaeExpression,
8443 AssignmentType: AssignmentEquals,
8444 AssignmentExpression: WrapQuery(&SimpleExpression{
8445 Identifier: &tk[7],
8446 Tokens: tk[7:8],
8447 }).AssignmentExpression,
8448 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8449 Tokens: tk[1:8],
8450 },
8451 Tokens: tk[1:8],
8452 },
8453 Tokens: tk[1:8],
8454 },
8455 Tokens: tk[:9],
8456 }
8457 }},
8458 {"(a#abc\n|#def\nb)", func(t *test, tk Tokens) { // 7
8459 t.Output = ParenthesizedExpression{
8460 Expression: Expression{
8461 QueryExpression: WrapQuery(OrExpression{
8462 AndExpression: WrapQuery(&SimpleExpression{
8463 Identifier: &tk[1],
8464 Tokens: tk[1:2],
8465 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression,
8466 OrType: OrVectorized,
8467 OrExpression: WrapQuery(&SimpleExpression{
8468 Identifier: &tk[7],
8469 Tokens: tk[7:8],
8470 }).AssignmentExpression.FormulaeExpression.OrExpression,
8471 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8472 Tokens: tk[1:8],
8473 }),
8474 Tokens: tk[1:8],
8475 },
8476 Tokens: tk[:9],
8477 }
8478 }},
8479 {"(a#abc\n&#def\nb)", func(t *test, tk Tokens) { // 8
8480 t.Output = ParenthesizedExpression{
8481 Expression: Expression{
8482 QueryExpression: WrapQuery(AndExpression{
8483 NotExpression: WrapQuery(&SimpleExpression{
8484 Identifier: &tk[1],
8485 Tokens: tk[1:2],
8486 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression,
8487 AndType: AndVectorized,
8488 AndExpression: &WrapQuery(&SimpleExpression{
8489 Identifier: &tk[7],
8490 Tokens: tk[7:8],
8491 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression,
8492 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8493 Tokens: tk[1:8],
8494 }),
8495 Tokens: tk[1:8],
8496 },
8497 Tokens: tk[:9],
8498 }
8499 }},
8500 {"(a#abc\n>#def\nb)", func(t *test, tk Tokens) { // 9
8501 t.Output = ParenthesizedExpression{
8502 Expression: Expression{
8503 QueryExpression: WrapQuery(RelationalExpression{
8504 AdditionExpression: WrapQuery(&SimpleExpression{
8505 Identifier: &tk[1],
8506 Tokens: tk[1:2],
8507 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression,
8508 RelationalOperator: RelationalGreaterThan,
8509 RelationalExpression: &WrapQuery(&SimpleExpression{
8510 Identifier: &tk[7],
8511 Tokens: tk[7:8],
8512 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression,
8513 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8514 Tokens: tk[1:8],
8515 }),
8516 Tokens: tk[1:8],
8517 },
8518 Tokens: tk[:9],
8519 }
8520 }},
8521 {"(a#abc\n+#def\nb)", func(t *test, tk Tokens) { // 10
8522 t.Output = ParenthesizedExpression{
8523 Expression: Expression{
8524 QueryExpression: WrapQuery(AdditionExpression{
8525 MultiplicationExpression: WrapQuery(&SimpleExpression{
8526 Identifier: &tk[1],
8527 Tokens: tk[1:2],
8528 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression,
8529 AdditionType: AdditionAdd,
8530 AdditionExpression: &WrapQuery(&SimpleExpression{
8531 Identifier: &tk[7],
8532 Tokens: tk[7:8],
8533 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression,
8534 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8535 Tokens: tk[1:8],
8536 }),
8537 Tokens: tk[1:8],
8538 },
8539 Tokens: tk[:9],
8540 }
8541 }},
8542 {"(a#abc\n*#def\nb)", func(t *test, tk Tokens) { // 11
8543 t.Output = ParenthesizedExpression{
8544 Expression: Expression{
8545 QueryExpression: WrapQuery(MultiplicationExpression{
8546 PipeOrSpecialExpression: WrapQuery(&SimpleExpression{
8547 Identifier: &tk[1],
8548 Tokens: tk[1:2],
8549 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression,
8550 MultiplicationType: MultiplicationMultiply,
8551 MultiplicationExpression: &WrapQuery(&SimpleExpression{
8552 Identifier: &tk[7],
8553 Tokens: tk[7:8],
8554 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression,
8555 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8556 Tokens: tk[1:8],
8557 }),
8558 Tokens: tk[1:8],
8559 },
8560 Tokens: tk[:9],
8561 }
8562 }},
8563 {"(a#abc\n|>#def\nb)", func(t *test, tk Tokens) { // 12
8564 t.Output = ParenthesizedExpression{
8565 Expression: Expression{
8566 QueryExpression: WrapQuery(PipeOrSpecialExpression{
8567 SequenceExpression: WrapQuery(&SimpleExpression{
8568 Identifier: &tk[1],
8569 Tokens: tk[1:2],
8570 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression,
8571 Operator: &tk[4],
8572 PipeOrSpecialExpression: &WrapQuery(&SimpleExpression{
8573 Identifier: &tk[7],
8574 Tokens: tk[7:8],
8575 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression,
8576 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8577 Tokens: tk[1:8],
8578 }),
8579 Tokens: tk[1:8],
8580 },
8581 Tokens: tk[:9],
8582 }
8583 }},
8584 {"(a#abc\n:#def\nb)", func(t *test, tk Tokens) { // 13
8585 t.Output = ParenthesizedExpression{
8586 Expression: Expression{
8587 QueryExpression: WrapQuery(SequenceExpression{
8588 UnaryExpression: WrapQuery(&SimpleExpression{
8589 Identifier: &tk[1],
8590 Tokens: tk[1:2],
8591 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression,
8592 SequenceExpression: &WrapQuery(&SimpleExpression{
8593 Identifier: &tk[7],
8594 Tokens: tk[7:8],
8595 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression,
8596 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8597 Tokens: tk[1:8],
8598 }),
8599 Tokens: tk[1:8],
8600 },
8601 Tokens: tk[:9],
8602 }
8603 }},
8604 {"(a#abc\n^#def\nb)", func(t *test, tk Tokens) { // 14
8605 t.Output = ParenthesizedExpression{
8606 Expression: Expression{
8607 QueryExpression: WrapQuery(ExponentiationExpression{
8608 SubsetExpression: WrapQuery(&SimpleExpression{
8609 Identifier: &tk[1],
8610 Tokens: tk[1:2],
8611 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression.SubsetExpression,
8612 ExponentiationExpression: &WrapQuery(&SimpleExpression{
8613 Identifier: &tk[7],
8614 Tokens: tk[7:8],
8615 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression,
8616 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8617 Tokens: tk[1:8],
8618 }),
8619 Tokens: tk[1:8],
8620 },
8621 Tokens: tk[:9],
8622 }
8623 }},
8624 {"(a#abc\n$#def\nb)", func(t *test, tk Tokens) { // 15
8625 t.Output = ParenthesizedExpression{
8626 Expression: Expression{
8627 QueryExpression: WrapQuery(SubsetExpression{
8628 ScopeExpression: WrapQuery(&SimpleExpression{
8629 Identifier: &tk[1],
8630 Tokens: tk[1:2],
8631 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression.SubsetExpression.ScopeExpression,
8632 SubsetType: SubsetList,
8633 SubsetExpression: &WrapQuery(&SimpleExpression{
8634 Identifier: &tk[7],
8635 Tokens: tk[7:8],
8636 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression.SubsetExpression,
8637 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8638 Tokens: tk[1:8],
8639 }),
8640 Tokens: tk[1:8],
8641 },
8642 Tokens: tk[:9],
8643 }
8644 }},
8645 {"(a#abc\n::#def\nb)", func(t *test, tk Tokens) { // 16
8646 t.Output = ParenthesizedExpression{
8647 Expression: Expression{
8648 QueryExpression: WrapQuery(ScopeExpression{
8649 IndexOrCallExpression: WrapQuery(&SimpleExpression{
8650 Identifier: &tk[1],
8651 Tokens: tk[1:2],
8652 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression.SubsetExpression.ScopeExpression.IndexOrCallExpression,
8653 ScopeExpression: &WrapQuery(&SimpleExpression{
8654 Identifier: &tk[7],
8655 Tokens: tk[7:8],
8656 }).AssignmentExpression.FormulaeExpression.OrExpression.AndExpression.NotExpression.RelationalExpression.AdditionExpression.MultiplicationExpression.PipeOrSpecialExpression.SequenceExpression.UnaryExpression.ExponentiationExpression.SubsetExpression.ScopeExpression,
8657 Comments: [2]Comments{{tk[2]}, {tk[5]}},
8658 Tokens: tk[1:8],
8659 }),
8660 Tokens: tk[1:8],
8661 },
8662 Tokens: tk[:9],
8663 }
8664 }},
8665 {"(a#abc\n[b])", func(t *test, tk Tokens) { // 17
8666 t.Output = ParenthesizedExpression{
8667 Expression: Expression{
8668 QueryExpression: WrapQuery(&IndexOrCallExpression{
8669 IndexOrCallExpression: &IndexOrCallExpression{
8670 SimpleExpression: &SimpleExpression{
8671 Identifier: &tk[1],
8672 Tokens: tk[1:2],
8673 },
8674 Tokens: tk[1:2],
8675 },
8676 Index: &Index{
8677 Args: []IndexExpression{
8678 {
8679 QueryExpression: *WrapQuery(&SimpleExpression{
8680 Identifier: &tk[5],
8681 Tokens: tk[5:6],
8682 }),
8683 Tokens: tk[5:6],
8684 },
8685 },
8686 Tokens: tk[4:7],
8687 },
8688 Comments: Comments{tk[2]},
8689 Tokens: tk[1:7],
8690 }),
8691 Tokens: tk[1:7],
8692 },
8693 Tokens: tk[:8],
8694 }
8695 }},
8696 }, func(t *test) (Type, error) {
8697 var pe ParenthesizedExpression
8698
8699 err := pe.parse(&t.Tokens)
8700
8701 return pe, err
8702 })
8703 }
8704
8705 func TestIndex(t *testing.T) {
8706 doTests(t, []sourceFn{
8707 {"[]", func(t *test, tk Tokens) { // 1
8708 t.Output = Index{
8709 Tokens: tk[:2],
8710 }
8711 }},
8712 {"[a]", func(t *test, tk Tokens) { // 2
8713 t.Output = Index{
8714 Args: []IndexExpression{
8715 {
8716 QueryExpression: *WrapQuery(&SimpleExpression{
8717 Identifier: &tk[1],
8718 Tokens: tk[1:2],
8719 }),
8720 Tokens: tk[1:2],
8721 },
8722 },
8723 Tokens: tk[:3],
8724 }
8725 }},
8726 {"[ a ]", func(t *test, tk Tokens) { // 3
8727 t.Output = Index{
8728 Args: []IndexExpression{
8729 {
8730 QueryExpression: *WrapQuery(&SimpleExpression{
8731 Identifier: &tk[2],
8732 Tokens: tk[2:3],
8733 }),
8734 Tokens: tk[2:3],
8735 },
8736 },
8737 Tokens: tk[:5],
8738 }
8739 }},
8740 {"[a,b]", func(t *test, tk Tokens) { // 4
8741 t.Output = Index{
8742 Args: []IndexExpression{
8743 {
8744 QueryExpression: *WrapQuery(&SimpleExpression{
8745 Identifier: &tk[1],
8746 Tokens: tk[1:2],
8747 }),
8748 Tokens: tk[1:2],
8749 },
8750 {
8751 QueryExpression: *WrapQuery(&SimpleExpression{
8752 Identifier: &tk[3],
8753 Tokens: tk[3:4],
8754 }),
8755 Tokens: tk[3:4],
8756 },
8757 },
8758 Tokens: tk[:5],
8759 }
8760 }},
8761 {"[a , b]", func(t *test, tk Tokens) { // 5
8762 t.Output = Index{
8763 Args: []IndexExpression{
8764 {
8765 QueryExpression: *WrapQuery(&SimpleExpression{
8766 Identifier: &tk[1],
8767 Tokens: tk[1:2],
8768 }),
8769 Tokens: tk[1:2],
8770 },
8771 {
8772 QueryExpression: *WrapQuery(&SimpleExpression{
8773 Identifier: &tk[5],
8774 Tokens: tk[5:6],
8775 }),
8776 Tokens: tk[5:6],
8777 },
8778 },
8779 Tokens: tk[:7],
8780 }
8781 }},
8782 {"[[a]]", func(t *test, tk Tokens) { // 6
8783 t.Output = Index{
8784 Double: true,
8785 Args: []IndexExpression{
8786 {
8787 QueryExpression: *WrapQuery(&SimpleExpression{
8788 Identifier: &tk[1],
8789 Tokens: tk[1:2],
8790 }),
8791 Tokens: tk[1:2],
8792 },
8793 },
8794 Tokens: tk[:3],
8795 }
8796 }},
8797 {"[[ a ]]", func(t *test, tk Tokens) { // 7
8798 t.Output = Index{
8799 Double: true,
8800 Args: []IndexExpression{
8801 {
8802 QueryExpression: *WrapQuery(&SimpleExpression{
8803 Identifier: &tk[2],
8804 Tokens: tk[2:3],
8805 }),
8806 Tokens: tk[2:3],
8807 },
8808 },
8809 Tokens: tk[:5],
8810 }
8811 }},
8812 {"[in]", func(t *test, tk Tokens) { // 8
8813 t.Err = Error{
8814 Err: Error{
8815 Err: wrapQueryExpressionError(Error{
8816 Err: ErrInvalidSimpleExpression,
8817 Parsing: "SimpleExpression",
8818 Token: tk[1],
8819 }),
8820 Parsing: "IndexExpression",
8821 Token: tk[1],
8822 },
8823 Parsing: "Index",
8824 Token: tk[1],
8825 }
8826 }},
8827 {"[a b]", func(t *test, tk Tokens) { // 9
8828 t.Err = Error{
8829 Err: ErrMissingComma,
8830 Parsing: "Index",
8831 Token: tk[3],
8832 }
8833 }},
8834 {"[[in]]", func(t *test, tk Tokens) { // 10
8835 t.Err = Error{
8836 Err: Error{
8837 Err: wrapQueryExpressionError(Error{
8838 Err: ErrInvalidSimpleExpression,
8839 Parsing: "SimpleExpression",
8840 Token: tk[1],
8841 }),
8842 Parsing: "IndexExpression",
8843 Token: tk[1],
8844 },
8845 Parsing: "Index",
8846 Token: tk[1],
8847 }
8848 }},
8849 {"[[a b]]", func(t *test, tk Tokens) { // 11
8850 t.Err = Error{
8851 Err: ErrMissingClosingDoubleBracket,
8852 Parsing: "Index",
8853 Token: tk[3],
8854 }
8855 }},
8856 {"[#abc\na#def\n]", func(t *test, tk Tokens) { // 12
8857 t.Output = Index{
8858 Args: []IndexExpression{
8859 {
8860 QueryExpression: *WrapQuery(&SimpleExpression{
8861 Identifier: &tk[3],
8862 Tokens: tk[3:4],
8863 }),
8864 Comments: [2]Comments{{tk[1]}, {tk[4]}},
8865 Tokens: tk[1:5],
8866 },
8867 },
8868 Tokens: tk[:7],
8869 }
8870 }},
8871 {"[ #abc\na #def\n , #ghi\n\n#jkl\nb\n#mno\n]", func(t *test, tk Tokens) { // 13
8872 t.Output = Index{
8873 Args: []IndexExpression{
8874 {
8875 QueryExpression: *WrapQuery(&SimpleExpression{
8876 Identifier: &tk[4],
8877 Tokens: tk[4:5],
8878 }),
8879 Comments: [2]Comments{{tk[2]}, {tk[6]}},
8880 Tokens: tk[2:7],
8881 },
8882 {
8883 QueryExpression: *WrapQuery(&SimpleExpression{
8884 Identifier: &tk[16],
8885 Tokens: tk[16:17],
8886 }),
8887 Comments: [2]Comments{{tk[11], tk[14]}, {tk[18]}},
8888 Tokens: tk[11:19],
8889 },
8890 },
8891 Tokens: tk[:21],
8892 }
8893 }},
8894 }, func(t *test) (Type, error) {
8895 var i Index
8896
8897 err := i.parse(&t.Tokens)
8898
8899 return i, err
8900 })
8901 }
8902
8903 func TestIndexExpression(t *testing.T) {
8904 doTests(t, []sourceFn{
8905 {"a", func(t *test, tk Tokens) { // 1
8906 t.Output = IndexExpression{
8907 QueryExpression: *WrapQuery(&SimpleExpression{
8908 Identifier: &tk[0],
8909 Tokens: tk[:1],
8910 }),
8911 Tokens: tk[:1],
8912 }
8913 }},
8914 {"in", func(t *test, tk Tokens) { // 2
8915 t.Err = Error{
8916 Err: wrapQueryExpressionError(Error{
8917 Err: ErrInvalidSimpleExpression,
8918 Parsing: "SimpleExpression",
8919 Token: tk[0],
8920 }),
8921 Parsing: "IndexExpression",
8922 Token: tk[0],
8923 }
8924 }},
8925 {"#abc\na#def", func(t *test, tk Tokens) { // 3
8926 t.Output = IndexExpression{
8927 QueryExpression: *WrapQuery(&SimpleExpression{
8928 Identifier: &tk[2],
8929 Tokens: tk[2:3],
8930 }),
8931 Comments: [2]Comments{{tk[0]}, {tk[3]}},
8932 Tokens: tk[:4],
8933 }
8934 }},
8935 }, func(t *test) (Type, error) {
8936 var i IndexExpression
8937
8938 err := i.parse(&t.Tokens)
8939
8940 return i, err
8941 })
8942 }
8943
8944 func TestCall(t *testing.T) {
8945 doTests(t, []sourceFn{
8946 {"()", func(t *test, tk Tokens) { // 1
8947 t.Output = Call{
8948 Tokens: tk[:2],
8949 }
8950 }},
8951 {"(a)", func(t *test, tk Tokens) { // 2
8952 t.Output = Call{
8953 Args: []Arg{
8954 {
8955 QueryExpression: WrapQuery(&SimpleExpression{
8956 Identifier: &tk[1],
8957 Tokens: tk[1:2],
8958 }),
8959 Tokens: tk[1:2],
8960 },
8961 },
8962 Tokens: tk[:3],
8963 }
8964 }},
8965 {"( a )", func(t *test, tk Tokens) { // 3
8966 t.Output = Call{
8967 Args: []Arg{
8968 {
8969 QueryExpression: WrapQuery(&SimpleExpression{
8970 Identifier: &tk[2],
8971 Tokens: tk[2:3],
8972 }),
8973 Tokens: tk[2:3],
8974 },
8975 },
8976 Tokens: tk[:5],
8977 }
8978 }},
8979 {"(a,b)", func(t *test, tk Tokens) { // 4
8980 t.Output = Call{
8981 Args: []Arg{
8982 {
8983 QueryExpression: WrapQuery(&SimpleExpression{
8984 Identifier: &tk[1],
8985 Tokens: tk[1:2],
8986 }),
8987 Tokens: tk[1:2],
8988 },
8989 {
8990 QueryExpression: WrapQuery(&SimpleExpression{
8991 Identifier: &tk[3],
8992 Tokens: tk[3:4],
8993 }),
8994 Tokens: tk[3:4],
8995 },
8996 },
8997 Tokens: tk[:5],
8998 }
8999 }},
9000 {"(a , b)", func(t *test, tk Tokens) { // 5
9001 t.Output = Call{
9002 Args: []Arg{
9003 {
9004 QueryExpression: WrapQuery(&SimpleExpression{
9005 Identifier: &tk[1],
9006 Tokens: tk[1:2],
9007 }),
9008 Tokens: tk[1:2],
9009 },
9010 {
9011 QueryExpression: WrapQuery(&SimpleExpression{
9012 Identifier: &tk[5],
9013 Tokens: tk[5:6],
9014 }),
9015 Tokens: tk[5:6],
9016 },
9017 },
9018 Tokens: tk[:7],
9019 }
9020 }},
9021 {"(,)", func(t *test, tk Tokens) { // 6
9022 t.Output = Call{
9023 Args: []Arg{},
9024 Tokens: tk[:3],
9025 }
9026 }},
9027 {"(a,)", func(t *test, tk Tokens) { // 7
9028 t.Output = Call{
9029 Args: []Arg{
9030 {
9031 QueryExpression: WrapQuery(&SimpleExpression{
9032 Identifier: &tk[1],
9033 Tokens: tk[1:2],
9034 }),
9035 Tokens: tk[1:2],
9036 },
9037 },
9038 Tokens: tk[:4],
9039 }
9040 }},
9041 {"(,a)", func(t *test, tk Tokens) { // 8
9042 t.Output = Call{
9043 Args: []Arg{
9044 {
9045 Tokens: tk[1:1],
9046 },
9047 {
9048 QueryExpression: WrapQuery(&SimpleExpression{
9049 Identifier: &tk[2],
9050 Tokens: tk[2:3],
9051 }),
9052 Tokens: tk[2:3],
9053 },
9054 },
9055 Tokens: tk[:4],
9056 }
9057 }},
9058 {"(,,)", func(t *test, tk Tokens) { // 9
9059 t.Output = Call{
9060 Args: []Arg{},
9061 Tokens: tk[:4],
9062 }
9063 }},
9064 {"(a,,)", func(t *test, tk Tokens) { // 10
9065 t.Output = Call{
9066 Args: []Arg{
9067 {
9068 QueryExpression: WrapQuery(&SimpleExpression{
9069 Identifier: &tk[1],
9070 Tokens: tk[1:2],
9071 }),
9072 Tokens: tk[1:2],
9073 },
9074 },
9075 Tokens: tk[:5],
9076 }
9077 }},
9078 {"(,,a)", func(t *test, tk Tokens) { // 11
9079 t.Output = Call{
9080 Args: []Arg{
9081 {
9082 Tokens: tk[1:1],
9083 },
9084 {
9085 Tokens: tk[2:2],
9086 },
9087 {
9088 QueryExpression: WrapQuery(&SimpleExpression{
9089 Identifier: &tk[3],
9090 Tokens: tk[3:4],
9091 }),
9092 Tokens: tk[3:4],
9093 },
9094 },
9095 Tokens: tk[:5],
9096 }
9097 }},
9098 {"(,a,)", func(t *test, tk Tokens) { // 12
9099 t.Output = Call{
9100 Args: []Arg{
9101 {
9102 Tokens: tk[1:1],
9103 },
9104 {
9105 QueryExpression: WrapQuery(&SimpleExpression{
9106 Identifier: &tk[2],
9107 Tokens: tk[2:3],
9108 }),
9109 Tokens: tk[2:3],
9110 },
9111 },
9112 Tokens: tk[:5],
9113 }
9114 }},
9115 {"(a,,b)", func(t *test, tk Tokens) { // 13
9116 t.Output = Call{
9117 Args: []Arg{
9118 {
9119 QueryExpression: WrapQuery(&SimpleExpression{
9120 Identifier: &tk[1],
9121 Tokens: tk[1:2],
9122 }),
9123 Tokens: tk[1:2],
9124 },
9125 {
9126 Tokens: tk[3:3],
9127 },
9128 {
9129 QueryExpression: WrapQuery(&SimpleExpression{
9130 Identifier: &tk[4],
9131 Tokens: tk[4:5],
9132 }),
9133 Tokens: tk[4:5],
9134 },
9135 },
9136 Tokens: tk[:6],
9137 }
9138 }},
9139 {"(in)", func(t *test, tk Tokens) { // 14
9140 t.Err = Error{
9141 Err: Error{
9142 Err: wrapQueryExpressionError(Error{
9143 Err: ErrInvalidSimpleExpression,
9144 Parsing: "SimpleExpression",
9145 Token: tk[1],
9146 }),
9147 Parsing: "Arg",
9148 Token: tk[1],
9149 },
9150 Parsing: "Call",
9151 Token: tk[1],
9152 }
9153 }},
9154 {"(a b)", func(t *test, tk Tokens) { // 15
9155 t.Err = Error{
9156 Err: ErrMissingComma,
9157 Parsing: "Call",
9158 Token: tk[3],
9159 }
9160 }},
9161 {"(#abc\n)", func(t *test, tk Tokens) { // 16
9162 t.Output = Call{
9163 Comments: Comments{tk[1]},
9164 Tokens: tk[:4],
9165 }
9166 }},
9167 }, func(t *test) (Type, error) {
9168 var c Call
9169
9170 err := c.parse(&t.Tokens)
9171
9172 return c, err
9173 })
9174 }
9175
9176 func TestArg(t *testing.T) {
9177 doTests(t, []sourceFn{
9178 {"a", func(t *test, tk Tokens) { // 1
9179 t.Output = Arg{
9180 QueryExpression: WrapQuery(&SimpleExpression{
9181 Identifier: &tk[0],
9182 Tokens: tk[:1],
9183 }),
9184 Tokens: tk[:1],
9185 }
9186 }},
9187 {"...", func(t *test, tk Tokens) { // 2
9188 t.Output = Arg{
9189 Ellipsis: &tk[0],
9190 Tokens: tk[:1],
9191 }
9192 }},
9193 {"", func(t *test, tk Tokens) { // 3
9194 t.Output = Arg{
9195 Tokens: tk[:0],
9196 }
9197 }},
9198 {"in", func(t *test, tk Tokens) { // 4
9199 t.Err = Error{
9200 Err: wrapQueryExpressionError(Error{
9201 Err: ErrInvalidSimpleExpression,
9202 Parsing: "SimpleExpression",
9203 Token: tk[0],
9204 }),
9205 Parsing: "Arg",
9206 Token: tk[0],
9207 }
9208 }},
9209 {"#abc\na", func(t *test, tk Tokens) { // 5
9210 t.Output = Arg{
9211 QueryExpression: WrapQuery(&SimpleExpression{
9212 Identifier: &tk[2],
9213 Tokens: tk[2:3],
9214 }),
9215 Comments: [2]Comments{{tk[0]}},
9216 Tokens: tk[:3],
9217 }
9218 }},
9219 {"a #abc", func(t *test, tk Tokens) { // 6
9220 t.Output = Arg{
9221 QueryExpression: WrapQuery(&SimpleExpression{
9222 Identifier: &tk[0],
9223 Tokens: tk[:1],
9224 }),
9225 Comments: [2]Comments{nil, {tk[2]}},
9226 Tokens: tk[:3],
9227 }
9228 }},
9229 {"#abc\n#def\n\n#ghi\na #jkl\n#mno\n\n#pqr", func(t *test, tk Tokens) { // 7
9230 t.Output = Arg{
9231 QueryExpression: WrapQuery(&SimpleExpression{
9232 Identifier: &tk[7],
9233 Tokens: tk[7:8],
9234 }),
9235 Comments: [2]Comments{{tk[0], tk[2], tk[5]}, {tk[9], tk[11], tk[14]}},
9236 Tokens: tk[:15],
9237 }
9238 }},
9239 }, func(t *test) (Type, error) {
9240 var a Arg
9241
9242 err := a.parse(&t.Tokens)
9243
9244 return a, err
9245 })
9246 }
9247