How to use matchTokenAt_7 method in Cucumber-gherkin

Best JavaScript code snippet using cucumber-gherkin

Run Cucumber-gherkin automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

parser.js

Source: parser.js Github

copy
1// This file is generated. Do not edit! Edit gherkin-javascript.razor instead.
2var Errors = require('./errors');
3
4module.exports = function Parser() {
5
6  var RULE_TYPES = [
7    'None',
8    '_EOF', // #EOF
9    '_Empty', // #Empty
10    '_Comment', // #Comment
11    '_TagLine', // #TagLine
12    '_FeatureLine', // #FeatureLine
13    '_BackgroundLine', // #BackgroundLine
14    '_ScenarioLine', // #ScenarioLine
15    '_ScenarioOutlineLine', // #ScenarioOutlineLine
16    '_ExamplesLine', // #ExamplesLine
17    '_StepLine', // #StepLine
18    '_DocStringSeparator', // #DocStringSeparator
19    '_TableRow', // #TableRow
20    '_Language', // #Language
21    '_Other', // #Other
22    'Feature', // Feature! := Feature_Header Background? Scenario_Definition*
23    'Feature_Header', // Feature_Header! := #Language? Tags? #FeatureLine Feature_Description
24    'Background', // Background! := #BackgroundLine Background_Description Scenario_Step*
25    'Scenario_Definition', // Scenario_Definition! := Tags? (Scenario | ScenarioOutline)
26    'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
27    'ScenarioOutline', // ScenarioOutline! := #ScenarioOutlineLine ScenarioOutline_Description ScenarioOutline_Step* Examples+
28    'Examples', // Examples! [#Empty|#Comment|#TagLine->#ExamplesLine] := Tags? #ExamplesLine Examples_Description Examples_Table
29    'Examples_Table', // Examples_Table := #TableRow+
30    'Scenario_Step', // Scenario_Step := Step
31    'ScenarioOutline_Step', // ScenarioOutline_Step := Step
32    'Step', // Step! := #StepLine Step_Arg?
33    'Step_Arg', // Step_Arg := (DataTable | DocString)
34    'DataTable', // DataTable! := #TableRow+
35    'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
36    'Tags', // Tags! := #TagLine+
37    'Feature_Description', // Feature_Description := Description_Helper
38    'Background_Description', // Background_Description := Description_Helper
39    'Scenario_Description', // Scenario_Description := Description_Helper
40    'ScenarioOutline_Description', // ScenarioOutline_Description := Description_Helper
41    'Examples_Description', // Examples_Description := Description_Helper
42    'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
43    'Description', // Description! := #Other+
44  ]
45
46  var context = {};
47
48  this.parse = function(tokenScanner, astBuilder, tokenMatcher) {
49    context.tokenScanner = tokenScanner;
50    context.astBuilder = astBuilder;
51    context.tokenMatcher = tokenMatcher;
52    context.tokenQueue = [];
53    context.errors = [];
54
55    startRule(context, 'Feature');
56    var state = 0;
57    var token = null;
58    while(true) {
59      token = readToken(context);
60      state = matchToken(state, token, context);
61      if(token.isEof) break;
62    }
63
64    endRule(context, 'Feature');
65
66    // TODO: Similar optimisation in C#/Java/JavaScript
67    if(context.errors.length == 1) {
68      throw context.errors[0];
69    } else if(context.errors.length > 1) {
70      throw Errors.CompositeParserException.create(context.errors);
71    }
72
73    return getResult(context);
74  };
75
76  function addError(context, error) {
77    context.errors.push(error);
78    if (context.errors.length > 10)
79      throw Errors.CompositeParserException.create(context.errors);
80  }
81
82  function startRule(context, ruleType) {
83    handleAstError(context, function () {
84      context.astBuilder.startRule(ruleType);
85    });
86  }
87
88  function endRule(context, ruleType) {
89    handleAstError(context, function () {
90      context.astBuilder.endRule(ruleType);
91    });
92  }
93
94  function build(context, token) {
95    handleAstError(context, function () {
96      context.astBuilder.build(token);
97    });
98  }
99
100  function getResult(context) {
101    return context.astBuilder.getResult();
102  }
103
104  function handleAstError(context, action) {
105    handleExternalError(context, true, action)
106  }
107
108  function handleExternalError(context, defaultValue, action) {
109    if(this.stopAtFirstError) return action();
110    try {
111      return action();
112    } catch (e) {
113      if(e instanceof Errors.CompositeParserException) {
114        e.errors.forEach(function (error) {
115          addError(context, error);
116        });
117      } else if(e instanceof Errors.ParserException) {
118        addError(context, e);
119      } else {
120        throw e;
121      }
122    }
123    return defaultValue;
124  }
125
126  function readToken(context) {
127    return context.tokenQueue.length > 0 ?
128      context.tokenQueue.shift() :
129      context.tokenScanner.read();
130  }
131
132  function matchToken(state, token, context) {
133    switch(state) {
134    case 0:
135      return matchTokenAt_0(token, context);
136    case 1:
137      return matchTokenAt_1(token, context);
138    case 2:
139      return matchTokenAt_2(token, context);
140    case 3:
141      return matchTokenAt_3(token, context);
142    case 4:
143      return matchTokenAt_4(token, context);
144    case 5:
145      return matchTokenAt_5(token, context);
146    case 6:
147      return matchTokenAt_6(token, context);
148    case 7:
149      return matchTokenAt_7(token, context);
150    case 8:
151      return matchTokenAt_8(token, context);
152    case 9:
153      return matchTokenAt_9(token, context);
154    case 10:
155      return matchTokenAt_10(token, context);
156    case 11:
157      return matchTokenAt_11(token, context);
158    case 12:
159      return matchTokenAt_12(token, context);
160    case 13:
161      return matchTokenAt_13(token, context);
162    case 14:
163      return matchTokenAt_14(token, context);
164    case 15:
165      return matchTokenAt_15(token, context);
166    case 16:
167      return matchTokenAt_16(token, context);
168    case 17:
169      return matchTokenAt_17(token, context);
170    case 18:
171      return matchTokenAt_18(token, context);
172    case 19:
173      return matchTokenAt_19(token, context);
174    case 20:
175      return matchTokenAt_20(token, context);
176    case 21:
177      return matchTokenAt_21(token, context);
178    case 22:
179      return matchTokenAt_22(token, context);
180    case 23:
181      return matchTokenAt_23(token, context);
182    case 24:
183      return matchTokenAt_24(token, context);
184    case 25:
185      return matchTokenAt_25(token, context);
186    case 26:
187      return matchTokenAt_26(token, context);
188    case 28:
189      return matchTokenAt_28(token, context);
190    case 29:
191      return matchTokenAt_29(token, context);
192    case 30:
193      return matchTokenAt_30(token, context);
194    case 31:
195      return matchTokenAt_31(token, context);
196    case 32:
197      return matchTokenAt_32(token, context);
198    case 33:
199      return matchTokenAt_33(token, context);
200    default:
201      throw new Error("Unknown state: " + state);
202    }
203  }
204
205
206  // Start
207  function matchTokenAt_0(token, context) {
208    if(match_Language(context, token)) {
209      startRule(context, 'Feature_Header');
210      build(context, token);
211      return 1;
212    }
213    if(match_TagLine(context, token)) {
214      startRule(context, 'Feature_Header');
215      startRule(context, 'Tags');
216      build(context, token);
217      return 2;
218    }
219    if(match_FeatureLine(context, token)) {
220      startRule(context, 'Feature_Header');
221      build(context, token);
222      return 3;
223    }
224    if(match_Comment(context, token)) {
225      build(context, token);
226      return 0;
227    }
228    if(match_Empty(context, token)) {
229      build(context, token);
230      return 0;
231    }
232    
233    var stateComment = "State: 0 - Start";
234    token.detach();
235    var expectedTokens = ["#Language", "#TagLine", "#FeatureLine", "#Comment", "#Empty"];
236    var error = token.isEof ?
237      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
238      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
239    if (this.stopAtFirstError) throw error;
240    addError(context, error);
241    return 0;
242  }
243
244
245  // Feature:0>Feature_Header:0>#Language:0
246  function matchTokenAt_1(token, context) {
247    if(match_TagLine(context, token)) {
248      startRule(context, 'Tags');
249      build(context, token);
250      return 2;
251    }
252    if(match_FeatureLine(context, token)) {
253      build(context, token);
254      return 3;
255    }
256    if(match_Comment(context, token)) {
257      build(context, token);
258      return 1;
259    }
260    if(match_Empty(context, token)) {
261      build(context, token);
262      return 1;
263    }
264    
265    var stateComment = "State: 1 - Feature:0>Feature_Header:0>#Language:0";
266    token.detach();
267    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
268    var error = token.isEof ?
269      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
270      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
271    if (this.stopAtFirstError) throw error;
272    addError(context, error);
273    return 1;
274  }
275
276
277  // Feature:0>Feature_Header:1>Tags:0>#TagLine:0
278  function matchTokenAt_2(token, context) {
279    if(match_TagLine(context, token)) {
280      build(context, token);
281      return 2;
282    }
283    if(match_FeatureLine(context, token)) {
284      endRule(context, 'Tags');
285      build(context, token);
286      return 3;
287    }
288    if(match_Comment(context, token)) {
289      build(context, token);
290      return 2;
291    }
292    if(match_Empty(context, token)) {
293      build(context, token);
294      return 2;
295    }
296    
297    var stateComment = "State: 2 - Feature:0>Feature_Header:1>Tags:0>#TagLine:0";
298    token.detach();
299    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
300    var error = token.isEof ?
301      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
302      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
303    if (this.stopAtFirstError) throw error;
304    addError(context, error);
305    return 2;
306  }
307
308
309  // Feature:0>Feature_Header:2>#FeatureLine:0
310  function matchTokenAt_3(token, context) {
311    if(match_EOF(context, token)) {
312      endRule(context, 'Feature_Header');
313      build(context, token);
314      return 27;
315    }
316    if(match_Empty(context, token)) {
317      build(context, token);
318      return 3;
319    }
320    if(match_Comment(context, token)) {
321      build(context, token);
322      return 5;
323    }
324    if(match_BackgroundLine(context, token)) {
325      endRule(context, 'Feature_Header');
326      startRule(context, 'Background');
327      build(context, token);
328      return 6;
329    }
330    if(match_TagLine(context, token)) {
331      endRule(context, 'Feature_Header');
332      startRule(context, 'Scenario_Definition');
333      startRule(context, 'Tags');
334      build(context, token);
335      return 11;
336    }
337    if(match_ScenarioLine(context, token)) {
338      endRule(context, 'Feature_Header');
339      startRule(context, 'Scenario_Definition');
340      startRule(context, 'Scenario');
341      build(context, token);
342      return 12;
343    }
344    if(match_ScenarioOutlineLine(context, token)) {
345      endRule(context, 'Feature_Header');
346      startRule(context, 'Scenario_Definition');
347      startRule(context, 'ScenarioOutline');
348      build(context, token);
349      return 17;
350    }
351    if(match_Other(context, token)) {
352      startRule(context, 'Description');
353      build(context, token);
354      return 4;
355    }
356    
357    var stateComment = "State: 3 - Feature:0>Feature_Header:2>#FeatureLine:0";
358    token.detach();
359    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
360    var error = token.isEof ?
361      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
362      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
363    if (this.stopAtFirstError) throw error;
364    addError(context, error);
365    return 3;
366  }
367
368
369  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0
370  function matchTokenAt_4(token, context) {
371    if(match_EOF(context, token)) {
372      endRule(context, 'Description');
373      endRule(context, 'Feature_Header');
374      build(context, token);
375      return 27;
376    }
377    if(match_Comment(context, token)) {
378      endRule(context, 'Description');
379      build(context, token);
380      return 5;
381    }
382    if(match_BackgroundLine(context, token)) {
383      endRule(context, 'Description');
384      endRule(context, 'Feature_Header');
385      startRule(context, 'Background');
386      build(context, token);
387      return 6;
388    }
389    if(match_TagLine(context, token)) {
390      endRule(context, 'Description');
391      endRule(context, 'Feature_Header');
392      startRule(context, 'Scenario_Definition');
393      startRule(context, 'Tags');
394      build(context, token);
395      return 11;
396    }
397    if(match_ScenarioLine(context, token)) {
398      endRule(context, 'Description');
399      endRule(context, 'Feature_Header');
400      startRule(context, 'Scenario_Definition');
401      startRule(context, 'Scenario');
402      build(context, token);
403      return 12;
404    }
405    if(match_ScenarioOutlineLine(context, token)) {
406      endRule(context, 'Description');
407      endRule(context, 'Feature_Header');
408      startRule(context, 'Scenario_Definition');
409      startRule(context, 'ScenarioOutline');
410      build(context, token);
411      return 17;
412    }
413    if(match_Other(context, token)) {
414      build(context, token);
415      return 4;
416    }
417    
418    var stateComment = "State: 4 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0";
419    token.detach();
420    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
421    var error = token.isEof ?
422      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
423      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
424    if (this.stopAtFirstError) throw error;
425    addError(context, error);
426    return 4;
427  }
428
429
430  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0
431  function matchTokenAt_5(token, context) {
432    if(match_EOF(context, token)) {
433      endRule(context, 'Feature_Header');
434      build(context, token);
435      return 27;
436    }
437    if(match_Comment(context, token)) {
438      build(context, token);
439      return 5;
440    }
441    if(match_BackgroundLine(context, token)) {
442      endRule(context, 'Feature_Header');
443      startRule(context, 'Background');
444      build(context, token);
445      return 6;
446    }
447    if(match_TagLine(context, token)) {
448      endRule(context, 'Feature_Header');
449      startRule(context, 'Scenario_Definition');
450      startRule(context, 'Tags');
451      build(context, token);
452      return 11;
453    }
454    if(match_ScenarioLine(context, token)) {
455      endRule(context, 'Feature_Header');
456      startRule(context, 'Scenario_Definition');
457      startRule(context, 'Scenario');
458      build(context, token);
459      return 12;
460    }
461    if(match_ScenarioOutlineLine(context, token)) {
462      endRule(context, 'Feature_Header');
463      startRule(context, 'Scenario_Definition');
464      startRule(context, 'ScenarioOutline');
465      build(context, token);
466      return 17;
467    }
468    if(match_Empty(context, token)) {
469      build(context, token);
470      return 5;
471    }
472    
473    var stateComment = "State: 5 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0";
474    token.detach();
475    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
476    var error = token.isEof ?
477      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
478      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
479    if (this.stopAtFirstError) throw error;
480    addError(context, error);
481    return 5;
482  }
483
484
485  // Feature:1>Background:0>#BackgroundLine:0
486  function matchTokenAt_6(token, context) {
487    if(match_EOF(context, token)) {
488      endRule(context, 'Background');
489      build(context, token);
490      return 27;
491    }
492    if(match_Empty(context, token)) {
493      build(context, token);
494      return 6;
495    }
496    if(match_Comment(context, token)) {
497      build(context, token);
498      return 8;
499    }
500    if(match_StepLine(context, token)) {
501      startRule(context, 'Step');
502      build(context, token);
503      return 9;
504    }
505    if(match_TagLine(context, token)) {
506      endRule(context, 'Background');
507      startRule(context, 'Scenario_Definition');
508      startRule(context, 'Tags');
509      build(context, token);
510      return 11;
511    }
512    if(match_ScenarioLine(context, token)) {
513      endRule(context, 'Background');
514      startRule(context, 'Scenario_Definition');
515      startRule(context, 'Scenario');
516      build(context, token);
517      return 12;
518    }
519    if(match_ScenarioOutlineLine(context, token)) {
520      endRule(context, 'Background');
521      startRule(context, 'Scenario_Definition');
522      startRule(context, 'ScenarioOutline');
523      build(context, token);
524      return 17;
525    }
526    if(match_Other(context, token)) {
527      startRule(context, 'Description');
528      build(context, token);
529      return 7;
530    }
531    
532    var stateComment = "State: 6 - Feature:1>Background:0>#BackgroundLine:0";
533    token.detach();
534    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
535    var error = token.isEof ?
536      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
537      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
538    if (this.stopAtFirstError) throw error;
539    addError(context, error);
540    return 6;
541  }
542
543
544  // Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0
545  function matchTokenAt_7(token, context) {
546    if(match_EOF(context, token)) {
547      endRule(context, 'Description');
548      endRule(context, 'Background');
549      build(context, token);
550      return 27;
551    }
552    if(match_Comment(context, token)) {
553      endRule(context, 'Description');
554      build(context, token);
555      return 8;
556    }
557    if(match_StepLine(context, token)) {
558      endRule(context, 'Description');
559      startRule(context, 'Step');
560      build(context, token);
561      return 9;
562    }
563    if(match_TagLine(context, token)) {
564      endRule(context, 'Description');
565      endRule(context, 'Background');
566      startRule(context, 'Scenario_Definition');
567      startRule(context, 'Tags');
568      build(context, token);
569      return 11;
570    }
571    if(match_ScenarioLine(context, token)) {
572      endRule(context, 'Description');
573      endRule(context, 'Background');
574      startRule(context, 'Scenario_Definition');
575      startRule(context, 'Scenario');
576      build(context, token);
577      return 12;
578    }
579    if(match_ScenarioOutlineLine(context, token)) {
580      endRule(context, 'Description');
581      endRule(context, 'Background');
582      startRule(context, 'Scenario_Definition');
583      startRule(context, 'ScenarioOutline');
584      build(context, token);
585      return 17;
586    }
587    if(match_Other(context, token)) {
588      build(context, token);
589      return 7;
590    }
591    
592    var stateComment = "State: 7 - Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0";
593    token.detach();
594    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
595    var error = token.isEof ?
596      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
597      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
598    if (this.stopAtFirstError) throw error;
599    addError(context, error);
600    return 7;
601  }
602
603
604  // Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0
605  function matchTokenAt_8(token, context) {
606    if(match_EOF(context, token)) {
607      endRule(context, 'Background');
608      build(context, token);
609      return 27;
610    }
611    if(match_Comment(context, token)) {
612      build(context, token);
613      return 8;
614    }
615    if(match_StepLine(context, token)) {
616      startRule(context, 'Step');
617      build(context, token);
618      return 9;
619    }
620    if(match_TagLine(context, token)) {
621      endRule(context, 'Background');
622      startRule(context, 'Scenario_Definition');
623      startRule(context, 'Tags');
624      build(context, token);
625      return 11;
626    }
627    if(match_ScenarioLine(context, token)) {
628      endRule(context, 'Background');
629      startRule(context, 'Scenario_Definition');
630      startRule(context, 'Scenario');
631      build(context, token);
632      return 12;
633    }
634    if(match_ScenarioOutlineLine(context, token)) {
635      endRule(context, 'Background');
636      startRule(context, 'Scenario_Definition');
637      startRule(context, 'ScenarioOutline');
638      build(context, token);
639      return 17;
640    }
641    if(match_Empty(context, token)) {
642      build(context, token);
643      return 8;
644    }
645    
646    var stateComment = "State: 8 - Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0";
647    token.detach();
648    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
649    var error = token.isEof ?
650      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
651      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
652    if (this.stopAtFirstError) throw error;
653    addError(context, error);
654    return 8;
655  }
656
657
658  // Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0
659  function matchTokenAt_9(token, context) {
660    if(match_EOF(context, token)) {
661      endRule(context, 'Step');
662      endRule(context, 'Background');
663      build(context, token);
664      return 27;
665    }
666    if(match_TableRow(context, token)) {
667      startRule(context, 'DataTable');
668      build(context, token);
669      return 10;
670    }
671    if(match_DocStringSeparator(context, token)) {
672      startRule(context, 'DocString');
673      build(context, token);
674      return 32;
675    }
676    if(match_StepLine(context, token)) {
677      endRule(context, 'Step');
678      startRule(context, 'Step');
679      build(context, token);
680      return 9;
681    }
682    if(match_TagLine(context, token)) {
683      endRule(context, 'Step');
684      endRule(context, 'Background');
685      startRule(context, 'Scenario_Definition');
686      startRule(context, 'Tags');
687      build(context, token);
688      return 11;
689    }
690    if(match_ScenarioLine(context, token)) {
691      endRule(context, 'Step');
692      endRule(context, 'Background');
693      startRule(context, 'Scenario_Definition');
694      startRule(context, 'Scenario');
695      build(context, token);
696      return 12;
697    }
698    if(match_ScenarioOutlineLine(context, token)) {
699      endRule(context, 'Step');
700      endRule(context, 'Background');
701      startRule(context, 'Scenario_Definition');
702      startRule(context, 'ScenarioOutline');
703      build(context, token);
704      return 17;
705    }
706    if(match_Comment(context, token)) {
707      build(context, token);
708      return 9;
709    }
710    if(match_Empty(context, token)) {
711      build(context, token);
712      return 9;
713    }
714    
715    var stateComment = "State: 9 - Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0";
716    token.detach();
717    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
718    var error = token.isEof ?
719      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
720      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
721    if (this.stopAtFirstError) throw error;
722    addError(context, error);
723    return 9;
724  }
725
726
727  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
728  function matchTokenAt_10(token, context) {
729    if(match_EOF(context, token)) {
730      endRule(context, 'DataTable');
731      endRule(context, 'Step');
732      endRule(context, 'Background');
733      build(context, token);
734      return 27;
735    }
736    if(match_TableRow(context, token)) {
737      build(context, token);
738      return 10;
739    }
740    if(match_StepLine(context, token)) {
741      endRule(context, 'DataTable');
742      endRule(context, 'Step');
743      startRule(context, 'Step');
744      build(context, token);
745      return 9;
746    }
747    if(match_TagLine(context, token)) {
748      endRule(context, 'DataTable');
749      endRule(context, 'Step');
750      endRule(context, 'Background');
751      startRule(context, 'Scenario_Definition');
752      startRule(context, 'Tags');
753      build(context, token);
754      return 11;
755    }
756    if(match_ScenarioLine(context, token)) {
757      endRule(context, 'DataTable');
758      endRule(context, 'Step');
759      endRule(context, 'Background');
760      startRule(context, 'Scenario_Definition');
761      startRule(context, 'Scenario');
762      build(context, token);
763      return 12;
764    }
765    if(match_ScenarioOutlineLine(context, token)) {
766      endRule(context, 'DataTable');
767      endRule(context, 'Step');
768      endRule(context, 'Background');
769      startRule(context, 'Scenario_Definition');
770      startRule(context, 'ScenarioOutline');
771      build(context, token);
772      return 17;
773    }
774    if(match_Comment(context, token)) {
775      build(context, token);
776      return 10;
777    }
778    if(match_Empty(context, token)) {
779      build(context, token);
780      return 10;
781    }
782    
783    var stateComment = "State: 10 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
784    token.detach();
785    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
786    var error = token.isEof ?
787      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
788      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
789    if (this.stopAtFirstError) throw error;
790    addError(context, error);
791    return 10;
792  }
793
794
795  // Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0
796  function matchTokenAt_11(token, context) {
797    if(match_TagLine(context, token)) {
798      build(context, token);
799      return 11;
800    }
801    if(match_ScenarioLine(context, token)) {
802      endRule(context, 'Tags');
803      startRule(context, 'Scenario');
804      build(context, token);
805      return 12;
806    }
807    if(match_ScenarioOutlineLine(context, token)) {
808      endRule(context, 'Tags');
809      startRule(context, 'ScenarioOutline');
810      build(context, token);
811      return 17;
812    }
813    if(match_Comment(context, token)) {
814      build(context, token);
815      return 11;
816    }
817    if(match_Empty(context, token)) {
818      build(context, token);
819      return 11;
820    }
821    
822    var stateComment = "State: 11 - Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0";
823    token.detach();
824    var expectedTokens = ["#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
825    var error = token.isEof ?
826      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
827      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
828    if (this.stopAtFirstError) throw error;
829    addError(context, error);
830    return 11;
831  }
832
833
834  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0
835  function matchTokenAt_12(token, context) {
836    if(match_EOF(context, token)) {
837      endRule(context, 'Scenario');
838      endRule(context, 'Scenario_Definition');
839      build(context, token);
840      return 27;
841    }
842    if(match_Empty(context, token)) {
843      build(context, token);
844      return 12;
845    }
846    if(match_Comment(context, token)) {
847      build(context, token);
848      return 14;
849    }
850    if(match_StepLine(context, token)) {
851      startRule(context, 'Step');
852      build(context, token);
853      return 15;
854    }
855    if(match_TagLine(context, token)) {
856      endRule(context, 'Scenario');
857      endRule(context, 'Scenario_Definition');
858      startRule(context, 'Scenario_Definition');
859      startRule(context, 'Tags');
860      build(context, token);
861      return 11;
862    }
863    if(match_ScenarioLine(context, token)) {
864      endRule(context, 'Scenario');
865      endRule(context, 'Scenario_Definition');
866      startRule(context, 'Scenario_Definition');
867      startRule(context, 'Scenario');
868      build(context, token);
869      return 12;
870    }
871    if(match_ScenarioOutlineLine(context, token)) {
872      endRule(context, 'Scenario');
873      endRule(context, 'Scenario_Definition');
874      startRule(context, 'Scenario_Definition');
875      startRule(context, 'ScenarioOutline');
876      build(context, token);
877      return 17;
878    }
879    if(match_Other(context, token)) {
880      startRule(context, 'Description');
881      build(context, token);
882      return 13;
883    }
884    
885    var stateComment = "State: 12 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0";
886    token.detach();
887    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
888    var error = token.isEof ?
889      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
890      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
891    if (this.stopAtFirstError) throw error;
892    addError(context, error);
893    return 12;
894  }
895
896
897  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
898  function matchTokenAt_13(token, context) {
899    if(match_EOF(context, token)) {
900      endRule(context, 'Description');
901      endRule(context, 'Scenario');
902      endRule(context, 'Scenario_Definition');
903      build(context, token);
904      return 27;
905    }
906    if(match_Comment(context, token)) {
907      endRule(context, 'Description');
908      build(context, token);
909      return 14;
910    }
911    if(match_StepLine(context, token)) {
912      endRule(context, 'Description');
913      startRule(context, 'Step');
914      build(context, token);
915      return 15;
916    }
917    if(match_TagLine(context, token)) {
918      endRule(context, 'Description');
919      endRule(context, 'Scenario');
920      endRule(context, 'Scenario_Definition');
921      startRule(context, 'Scenario_Definition');
922      startRule(context, 'Tags');
923      build(context, token);
924      return 11;
925    }
926    if(match_ScenarioLine(context, token)) {
927      endRule(context, 'Description');
928      endRule(context, 'Scenario');
929      endRule(context, 'Scenario_Definition');
930      startRule(context, 'Scenario_Definition');
931      startRule(context, 'Scenario');
932      build(context, token);
933      return 12;
934    }
935    if(match_ScenarioOutlineLine(context, token)) {
936      endRule(context, 'Description');
937      endRule(context, 'Scenario');
938      endRule(context, 'Scenario_Definition');
939      startRule(context, 'Scenario_Definition');
940      startRule(context, 'ScenarioOutline');
941      build(context, token);
942      return 17;
943    }
944    if(match_Other(context, token)) {
945      build(context, token);
946      return 13;
947    }
948    
949    var stateComment = "State: 13 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
950    token.detach();
951    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
952    var error = token.isEof ?
953      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
954      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
955    if (this.stopAtFirstError) throw error;
956    addError(context, error);
957    return 13;
958  }
959
960
961  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
962  function matchTokenAt_14(token, context) {
963    if(match_EOF(context, token)) {
964      endRule(context, 'Scenario');
965      endRule(context, 'Scenario_Definition');
966      build(context, token);
967      return 27;
968    }
969    if(match_Comment(context, token)) {
970      build(context, token);
971      return 14;
972    }
973    if(match_StepLine(context, token)) {
974      startRule(context, 'Step');
975      build(context, token);
976      return 15;
977    }
978    if(match_TagLine(context, token)) {
979      endRule(context, 'Scenario');
980      endRule(context, 'Scenario_Definition');
981      startRule(context, 'Scenario_Definition');
982      startRule(context, 'Tags');
983      build(context, token);
984      return 11;
985    }
986    if(match_ScenarioLine(context, token)) {
987      endRule(context, 'Scenario');
988      endRule(context, 'Scenario_Definition');
989      startRule(context, 'Scenario_Definition');
990      startRule(context, 'Scenario');
991      build(context, token);
992      return 12;
993    }
994    if(match_ScenarioOutlineLine(context, token)) {
995      endRule(context, 'Scenario');
996      endRule(context, 'Scenario_Definition');
997      startRule(context, 'Scenario_Definition');
998      startRule(context, 'ScenarioOutline');
999      build(context, token);
1000      return 17;
1001    }
1002    if(match_Empty(context, token)) {
1003      build(context, token);
1004      return 14;
1005    }
1006    
1007    var stateComment = "State: 14 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
1008    token.detach();
1009    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
1010    var error = token.isEof ?
1011      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1012      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1013    if (this.stopAtFirstError) throw error;
1014    addError(context, error);
1015    return 14;
1016  }
1017
1018
1019  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
1020  function matchTokenAt_15(token, context) {
1021    if(match_EOF(context, token)) {
1022      endRule(context, 'Step');
1023      endRule(context, 'Scenario');
1024      endRule(context, 'Scenario_Definition');
1025      build(context, token);
1026      return 27;
1027    }
1028    if(match_TableRow(context, token)) {
1029      startRule(context, 'DataTable');
1030      build(context, token);
1031      return 16;
1032    }
1033    if(match_DocStringSeparator(context, token)) {
1034      startRule(context, 'DocString');
1035      build(context, token);
1036      return 30;
1037    }
1038    if(match_StepLine(context, token)) {
1039      endRule(context, 'Step');
1040      startRule(context, 'Step');
1041      build(context, token);
1042      return 15;
1043    }
1044    if(match_TagLine(context, token)) {
1045      endRule(context, 'Step');
1046      endRule(context, 'Scenario');
1047      endRule(context, 'Scenario_Definition');
1048      startRule(context, 'Scenario_Definition');
1049      startRule(context, 'Tags');
1050      build(context, token);
1051      return 11;
1052    }
1053    if(match_ScenarioLine(context, token)) {
1054      endRule(context, 'Step');
1055      endRule(context, 'Scenario');
1056      endRule(context, 'Scenario_Definition');
1057      startRule(context, 'Scenario_Definition');
1058      startRule(context, 'Scenario');
1059      build(context, token);
1060      return 12;
1061    }
1062    if(match_ScenarioOutlineLine(context, token)) {
1063      endRule(context, 'Step');
1064      endRule(context, 'Scenario');
1065      endRule(context, 'Scenario_Definition');
1066      startRule(context, 'Scenario_Definition');
1067      startRule(context, 'ScenarioOutline');
1068      build(context, token);
1069      return 17;
1070    }
1071    if(match_Comment(context, token)) {
1072      build(context, token);
1073      return 15;
1074    }
1075    if(match_Empty(context, token)) {
1076      build(context, token);
1077      return 15;
1078    }
1079    
1080    var stateComment = "State: 15 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
1081    token.detach();
1082    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1083    var error = token.isEof ?
1084      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1085      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1086    if (this.stopAtFirstError) throw error;
1087    addError(context, error);
1088    return 15;
1089  }
1090
1091
1092  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
1093  function matchTokenAt_16(token, context) {
1094    if(match_EOF(context, token)) {
1095      endRule(context, 'DataTable');
1096      endRule(context, 'Step');
1097      endRule(context, 'Scenario');
1098      endRule(context, 'Scenario_Definition');
1099      build(context, token);
1100      return 27;
1101    }
1102    if(match_TableRow(context, token)) {
1103      build(context, token);
1104      return 16;
1105    }
1106    if(match_StepLine(context, token)) {
1107      endRule(context, 'DataTable');
1108      endRule(context, 'Step');
1109      startRule(context, 'Step');
1110      build(context, token);
1111      return 15;
1112    }
1113    if(match_TagLine(context, token)) {
1114      endRule(context, 'DataTable');
1115      endRule(context, 'Step');
1116      endRule(context, 'Scenario');
1117      endRule(context, 'Scenario_Definition');
1118      startRule(context, 'Scenario_Definition');
1119      startRule(context, 'Tags');
1120      build(context, token);
1121      return 11;
1122    }
1123    if(match_ScenarioLine(context, token)) {
1124      endRule(context, 'DataTable');
1125      endRule(context, 'Step');
1126      endRule(context, 'Scenario');
1127      endRule(context, 'Scenario_Definition');
1128      startRule(context, 'Scenario_Definition');
1129      startRule(context, 'Scenario');
1130      build(context, token);
1131      return 12;
1132    }
1133    if(match_ScenarioOutlineLine(context, token)) {
1134      endRule(context, 'DataTable');
1135      endRule(context, 'Step');
1136      endRule(context, 'Scenario');
1137      endRule(context, 'Scenario_Definition');
1138      startRule(context, 'Scenario_Definition');
1139      startRule(context, 'ScenarioOutline');
1140      build(context, token);
1141      return 17;
1142    }
1143    if(match_Comment(context, token)) {
1144      build(context, token);
1145      return 16;
1146    }
1147    if(match_Empty(context, token)) {
1148      build(context, token);
1149      return 16;
1150    }
1151    
1152    var stateComment = "State: 16 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
1153    token.detach();
1154    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1155    var error = token.isEof ?
1156      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1157      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1158    if (this.stopAtFirstError) throw error;
1159    addError(context, error);
1160    return 16;
1161  }
1162
1163
1164  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0
1165  function matchTokenAt_17(token, context) {
1166    if(match_Empty(context, token)) {
1167      build(context, token);
1168      return 17;
1169    }
1170    if(match_Comment(context, token)) {
1171      build(context, token);
1172      return 19;
1173    }
1174    if(match_StepLine(context, token)) {
1175      startRule(context, 'Step');
1176      build(context, token);
1177      return 20;
1178    }
1179    if(match_TagLine(context, token)) {
1180      startRule(context, 'Examples');
1181      startRule(context, 'Tags');
1182      build(context, token);
1183      return 22;
1184    }
1185    if(match_ExamplesLine(context, token)) {
1186      startRule(context, 'Examples');
1187      build(context, token);
1188      return 23;
1189    }
1190    if(match_Other(context, token)) {
1191      startRule(context, 'Description');
1192      build(context, token);
1193      return 18;
1194    }
1195    
1196    var stateComment = "State: 17 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0";
1197    token.detach();
1198    var expectedTokens = ["#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
1199    var error = token.isEof ?
1200      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1201      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1202    if (this.stopAtFirstError) throw error;
1203    addError(context, error);
1204    return 17;
1205  }
1206
1207
1208  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0
1209  function matchTokenAt_18(token, context) {
1210    if(match_Comment(context, token)) {
1211      endRule(context, 'Description');
1212      build(context, token);
1213      return 19;
1214    }
1215    if(match_StepLine(context, token)) {
1216      endRule(context, 'Description');
1217      startRule(context, 'Step');
1218      build(context, token);
1219      return 20;
1220    }
1221    if(match_TagLine(context, token)) {
1222      endRule(context, 'Description');
1223      startRule(context, 'Examples');
1224      startRule(context, 'Tags');
1225      build(context, token);
1226      return 22;
1227    }
1228    if(match_ExamplesLine(context, token)) {
1229      endRule(context, 'Description');
1230      startRule(context, 'Examples');
1231      build(context, token);
1232      return 23;
1233    }
1234    if(match_Other(context, token)) {
1235      build(context, token);
1236      return 18;
1237    }
1238    
1239    var stateComment = "State: 18 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0";
1240    token.detach();
1241    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
1242    var error = token.isEof ?
1243      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1244      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1245    if (this.stopAtFirstError) throw error;
1246    addError(context, error);
1247    return 18;
1248  }
1249
1250
1251  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0
1252  function matchTokenAt_19(token, context) {
1253    if(match_Comment(context, token)) {
1254      build(context, token);
1255      return 19;
1256    }
1257    if(match_StepLine(context, token)) {
1258      startRule(context, 'Step');
1259      build(context, token);
1260      return 20;
1261    }
1262    if(match_TagLine(context, token)) {
1263      startRule(context, 'Examples');
1264      startRule(context, 'Tags');
1265      build(context, token);
1266      return 22;
1267    }
1268    if(match_ExamplesLine(context, token)) {
1269      startRule(context, 'Examples');
1270      build(context, token);
1271      return 23;
1272    }
1273    if(match_Empty(context, token)) {
1274      build(context, token);
1275      return 19;
1276    }
1277    
1278    var stateComment = "State: 19 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0";
1279    token.detach();
1280    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Empty"];
1281    var error = token.isEof ?
1282      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1283      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1284    if (this.stopAtFirstError) throw error;
1285    addError(context, error);
1286    return 19;
1287  }
1288
1289
1290  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0
1291  function matchTokenAt_20(token, context) {
1292    if(match_TableRow(context, token)) {
1293      startRule(context, 'DataTable');
1294      build(context, token);
1295      return 21;
1296    }
1297    if(match_DocStringSeparator(context, token)) {
1298      startRule(context, 'DocString');
1299      build(context, token);
1300      return 28;
1301    }
1302    if(match_StepLine(context, token)) {
1303      endRule(context, 'Step');
1304      startRule(context, 'Step');
1305      build(context, token);
1306      return 20;
1307    }
1308    if(match_TagLine(context, token)) {
1309      endRule(context, 'Step');
1310      startRule(context, 'Examples');
1311      startRule(context, 'Tags');
1312      build(context, token);
1313      return 22;
1314    }
1315    if(match_ExamplesLine(context, token)) {
1316      endRule(context, 'Step');
1317      startRule(context, 'Examples');
1318      build(context, token);
1319      return 23;
1320    }
1321    if(match_Comment(context, token)) {
1322      build(context, token);
1323      return 20;
1324    }
1325    if(match_Empty(context, token)) {
1326      build(context, token);
1327      return 20;
1328    }
1329    
1330    var stateComment = "State: 20 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0";
1331    token.detach();
1332    var expectedTokens = ["#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1333    var error = token.isEof ?
1334      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1335      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1336    if (this.stopAtFirstError) throw error;
1337    addError(context, error);
1338    return 20;
1339  }
1340
1341
1342  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
1343  function matchTokenAt_21(token, context) {
1344    if(match_TableRow(context, token)) {
1345      build(context, token);
1346      return 21;
1347    }
1348    if(match_StepLine(context, token)) {
1349      endRule(context, 'DataTable');
1350      endRule(context, 'Step');
1351      startRule(context, 'Step');
1352      build(context, token);
1353      return 20;
1354    }
1355    if(match_TagLine(context, token)) {
1356      endRule(context, 'DataTable');
1357      endRule(context, 'Step');
1358      startRule(context, 'Examples');
1359      startRule(context, 'Tags');
1360      build(context, token);
1361      return 22;
1362    }
1363    if(match_ExamplesLine(context, token)) {
1364      endRule(context, 'DataTable');
1365      endRule(context, 'Step');
1366      startRule(context, 'Examples');
1367      build(context, token);
1368      return 23;
1369    }
1370    if(match_Comment(context, token)) {
1371      build(context, token);
1372      return 21;
1373    }
1374    if(match_Empty(context, token)) {
1375      build(context, token);
1376      return 21;
1377    }
1378    
1379    var stateComment = "State: 21 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
1380    token.detach();
1381    var expectedTokens = ["#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1382    var error = token.isEof ?
1383      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1384      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1385    if (this.stopAtFirstError) throw error;
1386    addError(context, error);
1387    return 21;
1388  }
1389
1390
1391  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0
1392  function matchTokenAt_22(token, context) {
1393    if(match_TagLine(context, token)) {
1394      build(context, token);
1395      return 22;
1396    }
1397    if(match_ExamplesLine(context, token)) {
1398      endRule(context, 'Tags');
1399      build(context, token);
1400      return 23;
1401    }
1402    if(match_Comment(context, token)) {
1403      build(context, token);
1404      return 22;
1405    }
1406    if(match_Empty(context, token)) {
1407      build(context, token);
1408      return 22;
1409    }
1410    
1411    var stateComment = "State: 22 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0";
1412    token.detach();
1413    var expectedTokens = ["#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1414    var error = token.isEof ?
1415      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1416      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1417    if (this.stopAtFirstError) throw error;
1418    addError(context, error);
1419    return 22;
1420  }
1421
1422
1423  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0
1424  function matchTokenAt_23(token, context) {
1425    if(match_Empty(context, token)) {
1426      build(context, token);
1427      return 23;
1428    }
1429    if(match_Comment(context, token)) {
1430      build(context, token);
1431      return 25;
1432    }
1433    if(match_TableRow(context, token)) {
1434      build(context, token);
1435      return 26;
1436    }
1437    if(match_Other(context, token)) {
1438      startRule(context, 'Description');
1439      build(context, token);
1440      return 24;
1441    }
1442    
1443    var stateComment = "State: 23 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0";
1444    token.detach();
1445    var expectedTokens = ["#Empty", "#Comment", "#TableRow", "#Other"];
1446    var error = token.isEof ?
1447      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1448      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1449    if (this.stopAtFirstError) throw error;
1450    addError(context, error);
1451    return 23;
1452  }
1453
1454
1455  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0
1456  function matchTokenAt_24(token, context) {
1457    if(match_Comment(context, token)) {
1458      endRule(context, 'Description');
1459      build(context, token);
1460      return 25;
1461    }
1462    if(match_TableRow(context, token)) {
1463      endRule(context, 'Description');
1464      build(context, token);
1465      return 26;
1466    }
1467    if(match_Other(context, token)) {
1468      build(context, token);
1469      return 24;
1470    }
1471    
1472    var stateComment = "State: 24 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0";
1473    token.detach();
1474    var expectedTokens = ["#Comment", "#TableRow", "#Other"];
1475    var error = token.isEof ?
1476      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1477      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1478    if (this.stopAtFirstError) throw error;
1479    addError(context, error);
1480    return 24;
1481  }
1482
1483
1484  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0
1485  function matchTokenAt_25(token, context) {
1486    if(match_Comment(context, token)) {
1487      build(context, token);
1488      return 25;
1489    }
1490    if(match_TableRow(context, token)) {
1491      build(context, token);
1492      return 26;
1493    }
1494    if(match_Empty(context, token)) {
1495      build(context, token);
1496      return 25;
1497    }
1498    
1499    var stateComment = "State: 25 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0";
1500    token.detach();
1501    var expectedTokens = ["#Comment", "#TableRow", "#Empty"];
1502    var error = token.isEof ?
1503      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1504      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1505    if (this.stopAtFirstError) throw error;
1506    addError(context, error);
1507    return 25;
1508  }
1509
1510
1511  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0
1512  function matchTokenAt_26(token, context) {
1513    if(match_EOF(context, token)) {
1514      endRule(context, 'Examples');
1515      endRule(context, 'ScenarioOutline');
1516      endRule(context, 'Scenario_Definition');
1517      build(context, token);
1518      return 27;
1519    }
1520    if(match_TableRow(context, token)) {
1521      build(context, token);
1522      return 26;
1523    }
1524    if(match_TagLine(context, token)) {
1525      if(lookahead_0(context, token)) {
1526      endRule(context, 'Examples');
1527      startRule(context, 'Examples');
1528      startRule(context, 'Tags');
1529      build(context, token);
1530      return 22;
1531      }
1532    }
1533    if(match_TagLine(context, token)) {
1534      endRule(context, 'Examples');
1535      endRule(context, 'ScenarioOutline');
1536      endRule(context, 'Scenario_Definition');
1537      startRule(context, 'Scenario_Definition');
1538      startRule(context, 'Tags');
1539      build(context, token);
1540      return 11;
1541    }
1542    if(match_ExamplesLine(context, token)) {
1543      endRule(context, 'Examples');
1544      startRule(context, 'Examples');
1545      build(context, token);
1546      return 23;
1547    }
1548    if(match_ScenarioLine(context, token)) {
1549      endRule(context, 'Examples');
1550      endRule(context, 'ScenarioOutline');
1551      endRule(context, 'Scenario_Definition');
1552      startRule(context, 'Scenario_Definition');
1553      startRule(context, 'Scenario');
1554      build(context, token);
1555      return 12;
1556    }
1557    if(match_ScenarioOutlineLine(context, token)) {
1558      endRule(context, 'Examples');
1559      endRule(context, 'ScenarioOutline');
1560      endRule(context, 'Scenario_Definition');
1561      startRule(context, 'Scenario_Definition');
1562      startRule(context, 'ScenarioOutline');
1563      build(context, token);
1564      return 17;
1565    }
1566    if(match_Comment(context, token)) {
1567      build(context, token);
1568      return 26;
1569    }
1570    if(match_Empty(context, token)) {
1571      build(context, token);
1572      return 26;
1573    }
1574    
1575    var stateComment = "State: 26 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0";
1576    token.detach();
1577    var expectedTokens = ["#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1578    var error = token.isEof ?
1579      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1580      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1581    if (this.stopAtFirstError) throw error;
1582    addError(context, error);
1583    return 26;
1584  }
1585
1586
1587  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1588  function matchTokenAt_28(token, context) {
1589    if(match_DocStringSeparator(context, token)) {
1590      build(context, token);
1591      return 29;
1592    }
1593    if(match_Other(context, token)) {
1594      build(context, token);
1595      return 28;
1596    }
1597    
1598    var stateComment = "State: 28 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1599    token.detach();
1600    var expectedTokens = ["#DocStringSeparator", "#Other"];
1601    var error = token.isEof ?
1602      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1603      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1604    if (this.stopAtFirstError) throw error;
1605    addError(context, error);
1606    return 28;
1607  }
1608
1609
1610  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1611  function matchTokenAt_29(token, context) {
1612    if(match_StepLine(context, token)) {
1613      endRule(context, 'DocString');
1614      endRule(context, 'Step');
1615      startRule(context, 'Step');
1616      build(context, token);
1617      return 20;
1618    }
1619    if(match_TagLine(context, token)) {
1620      endRule(context, 'DocString');
1621      endRule(context, 'Step');
1622      startRule(context, 'Examples');
1623      startRule(context, 'Tags');
1624      build(context, token);
1625      return 22;
1626    }
1627    if(match_ExamplesLine(context, token)) {
1628      endRule(context, 'DocString');
1629      endRule(context, 'Step');
1630      startRule(context, 'Examples');
1631      build(context, token);
1632      return 23;
1633    }
1634    if(match_Comment(context, token)) {
1635      build(context, token);
1636      return 29;
1637    }
1638    if(match_Empty(context, token)) {
1639      build(context, token);
1640      return 29;
1641    }
1642    
1643    var stateComment = "State: 29 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1644    token.detach();
1645    var expectedTokens = ["#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1646    var error = token.isEof ?
1647      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1648      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1649    if (this.stopAtFirstError) throw error;
1650    addError(context, error);
1651    return 29;
1652  }
1653
1654
1655  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1656  function matchTokenAt_30(token, context) {
1657    if(match_DocStringSeparator(context, token)) {
1658      build(context, token);
1659      return 31;
1660    }
1661    if(match_Other(context, token)) {
1662      build(context, token);
1663      return 30;
1664    }
1665    
1666    var stateComment = "State: 30 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1667    token.detach();
1668    var expectedTokens = ["#DocStringSeparator", "#Other"];
1669    var error = token.isEof ?
1670      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1671      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1672    if (this.stopAtFirstError) throw error;
1673    addError(context, error);
1674    return 30;
1675  }
1676
1677
1678  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1679  function matchTokenAt_31(token, context) {
1680    if(match_EOF(context, token)) {
1681      endRule(context, 'DocString');
1682      endRule(context, 'Step');
1683      endRule(context, 'Scenario');
1684      endRule(context, 'Scenario_Definition');
1685      build(context, token);
1686      return 27;
1687    }
1688    if(match_StepLine(context, token)) {
1689      endRule(context, 'DocString');
1690      endRule(context, 'Step');
1691      startRule(context, 'Step');
1692      build(context, token);
1693      return 15;
1694    }
1695    if(match_TagLine(context, token)) {
1696      endRule(context, 'DocString');
1697      endRule(context, 'Step');
1698      endRule(context, 'Scenario');
1699      endRule(context, 'Scenario_Definition');
1700      startRule(context, 'Scenario_Definition');
1701      startRule(context, 'Tags');
1702      build(context, token);
1703      return 11;
1704    }
1705    if(match_ScenarioLine(context, token)) {
1706      endRule(context, 'DocString');
1707      endRule(context, 'Step');
1708      endRule(context, 'Scenario');
1709      endRule(context, 'Scenario_Definition');
1710      startRule(context, 'Scenario_Definition');
1711      startRule(context, 'Scenario');
1712      build(context, token);
1713      return 12;
1714    }
1715    if(match_ScenarioOutlineLine(context, token)) {
1716      endRule(context, 'DocString');
1717      endRule(context, 'Step');
1718      endRule(context, 'Scenario');
1719      endRule(context, 'Scenario_Definition');
1720      startRule(context, 'Scenario_Definition');
1721      startRule(context, 'ScenarioOutline');
1722      build(context, token);
1723      return 17;
1724    }
1725    if(match_Comment(context, token)) {
1726      build(context, token);
1727      return 31;
1728    }
1729    if(match_Empty(context, token)) {
1730      build(context, token);
1731      return 31;
1732    }
1733    
1734    var stateComment = "State: 31 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1735    token.detach();
1736    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1737    var error = token.isEof ?
1738      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1739      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1740    if (this.stopAtFirstError) throw error;
1741    addError(context, error);
1742    return 31;
1743  }
1744
1745
1746  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1747  function matchTokenAt_32(token, context) {
1748    if(match_DocStringSeparator(context, token)) {
1749      build(context, token);
1750      return 33;
1751    }
1752    if(match_Other(context, token)) {
1753      build(context, token);
1754      return 32;
1755    }
1756    
1757    var stateComment = "State: 32 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1758    token.detach();
1759    var expectedTokens = ["#DocStringSeparator", "#Other"];
1760    var error = token.isEof ?
1761      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1762      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1763    if (this.stopAtFirstError) throw error;
1764    addError(context, error);
1765    return 32;
1766  }
1767
1768
1769  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1770  function matchTokenAt_33(token, context) {
1771    if(match_EOF(context, token)) {
1772      endRule(context, 'DocString');
1773      endRule(context, 'Step');
1774      endRule(context, 'Background');
1775      build(context, token);
1776      return 27;
1777    }
1778    if(match_StepLine(context, token)) {
1779      endRule(context, 'DocString');
1780      endRule(context, 'Step');
1781      startRule(context, 'Step');
1782      build(context, token);
1783      return 9;
1784    }
1785    if(match_TagLine(context, token)) {
1786      endRule(context, 'DocString');
1787      endRule(context, 'Step');
1788      endRule(context, 'Background');
1789      startRule(context, 'Scenario_Definition');
1790      startRule(context, 'Tags');
1791      build(context, token);
1792      return 11;
1793    }
1794    if(match_ScenarioLine(context, token)) {
1795      endRule(context, 'DocString');
1796      endRule(context, 'Step');
1797      endRule(context, 'Background');
1798      startRule(context, 'Scenario_Definition');
1799      startRule(context, 'Scenario');
1800      build(context, token);
1801      return 12;
1802    }
1803    if(match_ScenarioOutlineLine(context, token)) {
1804      endRule(context, 'DocString');
1805      endRule(context, 'Step');
1806      endRule(context, 'Background');
1807      startRule(context, 'Scenario_Definition');
1808      startRule(context, 'ScenarioOutline');
1809      build(context, token);
1810      return 17;
1811    }
1812    if(match_Comment(context, token)) {
1813      build(context, token);
1814      return 33;
1815    }
1816    if(match_Empty(context, token)) {
1817      build(context, token);
1818      return 33;
1819    }
1820    
1821    var stateComment = "State: 33 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1822    token.detach();
1823    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1824    var error = token.isEof ?
1825      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1826      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1827    if (this.stopAtFirstError) throw error;
1828    addError(context, error);
1829    return 33;
1830  }
1831
1832
1833
1834  function match_EOF(context, token) {
1835    return handleExternalError(context, false, function () {
1836      return context.tokenMatcher.match_EOF(token);
1837    });
1838  }
1839
1840
1841  function match_Empty(context, token) {
1842    if(token.isEof) return false;
1843    return handleExternalError(context, false, function () {
1844      return context.tokenMatcher.match_Empty(token);
1845    });
1846  }
1847
1848
1849  function match_Comment(context, token) {
1850    if(token.isEof) return false;
1851    return handleExternalError(context, false, function () {
1852      return context.tokenMatcher.match_Comment(token);
1853    });
1854  }
1855
1856
1857  function match_TagLine(context, token) {
1858    if(token.isEof) return false;
1859    return handleExternalError(context, false, function () {
1860      return context.tokenMatcher.match_TagLine(token);
1861    });
1862  }
1863
1864
1865  function match_FeatureLine(context, token) {
1866    if(token.isEof) return false;
1867    return handleExternalError(context, false, function () {
1868      return context.tokenMatcher.match_FeatureLine(token);
1869    });
1870  }
1871
1872
1873  function match_BackgroundLine(context, token) {
1874    if(token.isEof) return false;
1875    return handleExternalError(context, false, function () {
1876      return context.tokenMatcher.match_BackgroundLine(token);
1877    });
1878  }
1879
1880
1881  function match_ScenarioLine(context, token) {
1882    if(token.isEof) return false;
1883    return handleExternalError(context, false, function () {
1884      return context.tokenMatcher.match_ScenarioLine(token);
1885    });
1886  }
1887
1888
1889  function match_ScenarioOutlineLine(context, token) {
1890    if(token.isEof) return false;
1891    return handleExternalError(context, false, function () {
1892      return context.tokenMatcher.match_ScenarioOutlineLine(token);
1893    });
1894  }
1895
1896
1897  function match_ExamplesLine(context, token) {
1898    if(token.isEof) return false;
1899    return handleExternalError(context, false, function () {
1900      return context.tokenMatcher.match_ExamplesLine(token);
1901    });
1902  }
1903
1904
1905  function match_StepLine(context, token) {
1906    if(token.isEof) return false;
1907    return handleExternalError(context, false, function () {
1908      return context.tokenMatcher.match_StepLine(token);
1909    });
1910  }
1911
1912
1913  function match_DocStringSeparator(context, token) {
1914    if(token.isEof) return false;
1915    return handleExternalError(context, false, function () {
1916      return context.tokenMatcher.match_DocStringSeparator(token);
1917    });
1918  }
1919
1920
1921  function match_TableRow(context, token) {
1922    if(token.isEof) return false;
1923    return handleExternalError(context, false, function () {
1924      return context.tokenMatcher.match_TableRow(token);
1925    });
1926  }
1927
1928
1929  function match_Language(context, token) {
1930    if(token.isEof) return false;
1931    return handleExternalError(context, false, function () {
1932      return context.tokenMatcher.match_Language(token);
1933    });
1934  }
1935
1936
1937  function match_Other(context, token) {
1938    if(token.isEof) return false;
1939    return handleExternalError(context, false, function () {
1940      return context.tokenMatcher.match_Other(token);
1941    });
1942  }
1943
1944
1945
1946  function lookahead_0(context, currentToken) {
1947    currentToken.detach();
1948    var token;
1949    var queue = [];
1950    var match = false;
1951    do {
1952      token = readToken(context);
1953      token.detach();
1954      queue.push(token);
1955
1956      if (false  || match_ExamplesLine(context, token)) {
1957        match = true;
1958        break;
1959      }
1960    } while(false  || match_Empty(context, token) || match_Comment(context, token) || match_TagLine(context, token));
1961
1962    context.tokenQueue = context.tokenQueue.concat(queue);
1963
1964    return match;
1965  }
1966
1967
1968}
1969
Full Screen

Accelerate Your Automation Test Cycles With LambdaTest

Leverage LambdaTest’s cloud-based platform to execute your automation tests in parallel and trim down your test execution time significantly. Your first 100 automation testing minutes are on us.

Try LambdaTest

Run JavaScript Tests on LambdaTest Cloud Grid

Execute automation tests with Cucumber-gherkin on a cloud-based Grid of 3000+ real browsers and operating systems for both web and mobile applications.

Test now for Free
LambdaTestX

We use cookies to give you the best experience. Cookies help to provide a more personalized experience and relevant advertising for you, and web analytics for us. Learn More in our Cookies policy, Privacy & Terms of service

Allow Cookie
Sarah

I hope you find the best code examples for your project.

If you want to accelerate automated browser testing, try LambdaTest. Your first 100 automation testing minutes are FREE.

Sarah Elson (Product & Growth Lead)