How to use matchTokenAt_9 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');
3var AstBuilder = require('./ast_builder');
4var TokenScanner = require('./token_scanner');
5var TokenMatcher = require('./token_matcher');
6
7var RULE_TYPES = [
8  'None',
9  '_EOF', // #EOF
10  '_Empty', // #Empty
11  '_Comment', // #Comment
12  '_TagLine', // #TagLine
13  '_ScenarioLine', // #ScenarioLine
14  '_ExamplesLine', // #ExamplesLine
15  '_StepLine', // #StepLine
16  '_DocStringSeparator', // #DocStringSeparator
17  '_TableRow', // #TableRow
18  '_Language', // #Language
19  '_Other', // #Other
20  'GherkinDocument', // GherkinDocument! := Scenario_Definition*
21  'Scenario_Definition', // Scenario_Definition! := Tags? Scenario
22  'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
23  'Scenario_Step', // Scenario_Step := Step
24  'Step', // Step! := #StepLine Step_Arg?
25  'Step_Arg', // Step_Arg := (DataTable | DocString)
26  'DataTable', // DataTable! := #TableRow+
27  'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
28  'Tags', // Tags! := #TagLine+
29  'Scenario_Description', // Scenario_Description := Description_Helper
30  'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
31  'Description', // Description! := #Other+
32];
33
34module.exports = function Parser(builder) {
35  builder = builder || new AstBuilder();
36  var self = this;
37  var context;
38
39  this.parse = function(tokenScanner, tokenMatcher) {
40    if(typeof tokenScanner == 'string') {
41      tokenScanner = new TokenScanner(tokenScanner);
42    }
43    tokenMatcher = tokenMatcher || new TokenMatcher();
44    builder.reset();
45    tokenMatcher.reset();
46    context = {
47      tokenScanner: tokenScanner,
48      tokenMatcher: tokenMatcher,
49      tokenQueue: [],
50      errors: []
51    };
52    startRule(context, "GherkinDocument");
53    var state = 0;
54    var token = null;
55    while(true) {
56      token = readToken(context);
57      state = matchToken(state, token, context);
58      if(token.isEof) break;
59    }
60
61    endRule(context, "GherkinDocument");
62
63    if(context.errors.length > 0) {
64      throw Errors.CompositeParserException.create(context.errors);
65    }
66
67    return getResult();
68  };
69
70  function addError(context, error) {
71    context.errors.push(error);
72    if (context.errors.length > 10)
73      throw Errors.CompositeParserException.create(context.errors);
74  }
75
76  function startRule(context, ruleType) {
77    handleAstError(context, function () {
78      builder.startRule(ruleType);
79    });
80  }
81
82  function endRule(context, ruleType) {
83    handleAstError(context, function () {
84      builder.endRule(ruleType);
85    });
86  }
87
88  function build(context, token) {
89    handleAstError(context, function () {
90      builder.build(token);
91    });
92  }
93
94  function getResult() {
95    return builder.getResult();
96  }
97
98  function handleAstError(context, action) {
99    handleExternalError(context, true, action)
100  }
101
102  function handleExternalError(context, defaultValue, action) {
103    if(self.stopAtFirstError) return action();
104    try {
105      return action();
106    } catch (e) {
107      if(e instanceof Errors.CompositeParserException) {
108        e.errors.forEach(function (error) {
109          addError(context, error);
110        });
111      } else if(
112        e instanceof Errors.ParserException ||
113        e instanceof Errors.AstBuilderException ||
114        e instanceof Errors.UnexpectedTokenException ||
115        e instanceof Errors.NoSuchLanguageException
116      ) {
117        addError(context, e);
118      } else {
119        throw e;
120      }
121    }
122    return defaultValue;
123  }
124
125  function readToken(context) {
126    return context.tokenQueue.length > 0 ?
127      context.tokenQueue.shift() :
128      context.tokenScanner.read();
129  }
130
131  function matchToken(state, token, context) {
132    switch(state) {
133    case 0:
134      return matchTokenAt_0(token, context);
135    case 1:
136      return matchTokenAt_1(token, context);
137    case 2:
138      return matchTokenAt_2(token, context);
139    case 3:
140      return matchTokenAt_3(token, context);
141    case 4:
142      return matchTokenAt_4(token, context);
143    case 5:
144      return matchTokenAt_5(token, context);
145    case 6:
146      return matchTokenAt_6(token, context);
147    case 8:
148      return matchTokenAt_8(token, context);
149    case 9:
150      return matchTokenAt_9(token, context);
151    default:
152      throw new Error("Unknown state: " + state);
153    }
154  }
155
156
157  // Start
158  function matchTokenAt_0(token, context) {
159    if(match_EOF(context, token)) {
160      build(context, token);
161      return 7;
162    }
163    if(match_TagLine(context, token)) {
164      startRule(context, 'Scenario_Definition');
165      startRule(context, 'Tags');
166      build(context, token);
167      return 1;
168    }
169    if(match_ScenarioLine(context, token)) {
170      startRule(context, 'Scenario_Definition');
171      startRule(context, 'Scenario');
172      build(context, token);
173      return 2;
174    }
175    if(match_Comment(context, token)) {
176      build(context, token);
177      return 0;
178    }
179    if(match_Empty(context, token)) {
180      build(context, token);
181      return 0;
182    }
183    
184    var stateComment = "State: 0 - Start";
185    token.detach();
186    var expectedTokens = ["#EOF", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
187    var error = token.isEof ?
188      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
189      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
190    if (self.stopAtFirstError) throw error;
191    addError(context, error);
192    return 0;
193  }
194
195
196  // GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0
197  function matchTokenAt_1(token, context) {
198    if(match_TagLine(context, token)) {
199      build(context, token);
200      return 1;
201    }
202    if(match_ScenarioLine(context, token)) {
203      endRule(context, 'Tags');
204      startRule(context, 'Scenario');
205      build(context, token);
206      return 2;
207    }
208    if(match_Comment(context, token)) {
209      build(context, token);
210      return 1;
211    }
212    if(match_Empty(context, token)) {
213      build(context, token);
214      return 1;
215    }
216    
217    var stateComment = "State: 1 - GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0";
218    token.detach();
219    var expectedTokens = ["#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
220    var error = token.isEof ?
221      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
222      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
223    if (self.stopAtFirstError) throw error;
224    addError(context, error);
225    return 1;
226  }
227
228
229  // GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0
230  function matchTokenAt_2(token, context) {
231    if(match_EOF(context, token)) {
232      endRule(context, 'Scenario');
233      endRule(context, 'Scenario_Definition');
234      build(context, token);
235      return 7;
236    }
237    if(match_Empty(context, token)) {
238      build(context, token);
239      return 2;
240    }
241    if(match_Comment(context, token)) {
242      build(context, token);
243      return 4;
244    }
245    if(match_StepLine(context, token)) {
246      startRule(context, 'Step');
247      build(context, token);
248      return 5;
249    }
250    if(match_TagLine(context, token)) {
251      endRule(context, 'Scenario');
252      endRule(context, 'Scenario_Definition');
253      startRule(context, 'Scenario_Definition');
254      startRule(context, 'Tags');
255      build(context, token);
256      return 1;
257    }
258    if(match_ScenarioLine(context, token)) {
259      endRule(context, 'Scenario');
260      endRule(context, 'Scenario_Definition');
261      startRule(context, 'Scenario_Definition');
262      startRule(context, 'Scenario');
263      build(context, token);
264      return 2;
265    }
266    if(match_Other(context, token)) {
267      startRule(context, 'Description');
268      build(context, token);
269      return 3;
270    }
271    
272    var stateComment = "State: 2 - GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0";
273    token.detach();
274    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
275    var error = token.isEof ?
276      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
277      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
278    if (self.stopAtFirstError) throw error;
279    addError(context, error);
280    return 2;
281  }
282
283
284  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
285  function matchTokenAt_3(token, context) {
286    if(match_EOF(context, token)) {
287      endRule(context, 'Description');
288      endRule(context, 'Scenario');
289      endRule(context, 'Scenario_Definition');
290      build(context, token);
291      return 7;
292    }
293    if(match_Comment(context, token)) {
294      endRule(context, 'Description');
295      build(context, token);
296      return 4;
297    }
298    if(match_StepLine(context, token)) {
299      endRule(context, 'Description');
300      startRule(context, 'Step');
301      build(context, token);
302      return 5;
303    }
304    if(match_TagLine(context, token)) {
305      endRule(context, 'Description');
306      endRule(context, 'Scenario');
307      endRule(context, 'Scenario_Definition');
308      startRule(context, 'Scenario_Definition');
309      startRule(context, 'Tags');
310      build(context, token);
311      return 1;
312    }
313    if(match_ScenarioLine(context, token)) {
314      endRule(context, 'Description');
315      endRule(context, 'Scenario');
316      endRule(context, 'Scenario_Definition');
317      startRule(context, 'Scenario_Definition');
318      startRule(context, 'Scenario');
319      build(context, token);
320      return 2;
321    }
322    if(match_Other(context, token)) {
323      build(context, token);
324      return 3;
325    }
326    
327    var stateComment = "State: 3 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
328    token.detach();
329    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
330    var error = token.isEof ?
331      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
332      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
333    if (self.stopAtFirstError) throw error;
334    addError(context, error);
335    return 3;
336  }
337
338
339  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
340  function matchTokenAt_4(token, context) {
341    if(match_EOF(context, token)) {
342      endRule(context, 'Scenario');
343      endRule(context, 'Scenario_Definition');
344      build(context, token);
345      return 7;
346    }
347    if(match_Comment(context, token)) {
348      build(context, token);
349      return 4;
350    }
351    if(match_StepLine(context, token)) {
352      startRule(context, 'Step');
353      build(context, token);
354      return 5;
355    }
356    if(match_TagLine(context, token)) {
357      endRule(context, 'Scenario');
358      endRule(context, 'Scenario_Definition');
359      startRule(context, 'Scenario_Definition');
360      startRule(context, 'Tags');
361      build(context, token);
362      return 1;
363    }
364    if(match_ScenarioLine(context, token)) {
365      endRule(context, 'Scenario');
366      endRule(context, 'Scenario_Definition');
367      startRule(context, 'Scenario_Definition');
368      startRule(context, 'Scenario');
369      build(context, token);
370      return 2;
371    }
372    if(match_Empty(context, token)) {
373      build(context, token);
374      return 4;
375    }
376    
377    var stateComment = "State: 4 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
378    token.detach();
379    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Empty"];
380    var error = token.isEof ?
381      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
382      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
383    if (self.stopAtFirstError) throw error;
384    addError(context, error);
385    return 4;
386  }
387
388
389  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
390  function matchTokenAt_5(token, context) {
391    if(match_EOF(context, token)) {
392      endRule(context, 'Step');
393      endRule(context, 'Scenario');
394      endRule(context, 'Scenario_Definition');
395      build(context, token);
396      return 7;
397    }
398    if(match_TableRow(context, token)) {
399      startRule(context, 'DataTable');
400      build(context, token);
401      return 6;
402    }
403    if(match_DocStringSeparator(context, token)) {
404      startRule(context, 'DocString');
405      build(context, token);
406      return 8;
407    }
408    if(match_StepLine(context, token)) {
409      endRule(context, 'Step');
410      startRule(context, 'Step');
411      build(context, token);
412      return 5;
413    }
414    if(match_TagLine(context, token)) {
415      endRule(context, 'Step');
416      endRule(context, 'Scenario');
417      endRule(context, 'Scenario_Definition');
418      startRule(context, 'Scenario_Definition');
419      startRule(context, 'Tags');
420      build(context, token);
421      return 1;
422    }
423    if(match_ScenarioLine(context, token)) {
424      endRule(context, 'Step');
425      endRule(context, 'Scenario');
426      endRule(context, 'Scenario_Definition');
427      startRule(context, 'Scenario_Definition');
428      startRule(context, 'Scenario');
429      build(context, token);
430      return 2;
431    }
432    if(match_Comment(context, token)) {
433      build(context, token);
434      return 5;
435    }
436    if(match_Empty(context, token)) {
437      build(context, token);
438      return 5;
439    }
440    
441    var stateComment = "State: 5 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
442    token.detach();
443    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
444    var error = token.isEof ?
445      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
446      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
447    if (self.stopAtFirstError) throw error;
448    addError(context, error);
449    return 5;
450  }
451
452
453  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0
454  function matchTokenAt_6(token, context) {
455    if(match_EOF(context, token)) {
456      endRule(context, 'DataTable');
457      endRule(context, 'Step');
458      endRule(context, 'Scenario');
459      endRule(context, 'Scenario_Definition');
460      build(context, token);
461      return 7;
462    }
463    if(match_TableRow(context, token)) {
464      build(context, token);
465      return 6;
466    }
467    if(match_StepLine(context, token)) {
468      endRule(context, 'DataTable');
469      endRule(context, 'Step');
470      startRule(context, 'Step');
471      build(context, token);
472      return 5;
473    }
474    if(match_TagLine(context, token)) {
475      endRule(context, 'DataTable');
476      endRule(context, 'Step');
477      endRule(context, 'Scenario');
478      endRule(context, 'Scenario_Definition');
479      startRule(context, 'Scenario_Definition');
480      startRule(context, 'Tags');
481      build(context, token);
482      return 1;
483    }
484    if(match_ScenarioLine(context, token)) {
485      endRule(context, 'DataTable');
486      endRule(context, 'Step');
487      endRule(context, 'Scenario');
488      endRule(context, 'Scenario_Definition');
489      startRule(context, 'Scenario_Definition');
490      startRule(context, 'Scenario');
491      build(context, token);
492      return 2;
493    }
494    if(match_Comment(context, token)) {
495      build(context, token);
496      return 6;
497    }
498    if(match_Empty(context, token)) {
499      build(context, token);
500      return 6;
501    }
502    
503    var stateComment = "State: 6 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0";
504    token.detach();
505    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
506    var error = token.isEof ?
507      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
508      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
509    if (self.stopAtFirstError) throw error;
510    addError(context, error);
511    return 6;
512  }
513
514
515  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:0>#DocStringSeparator:0
516  function matchTokenAt_8(token, context) {
517    if(match_DocStringSeparator(context, token)) {
518      build(context, token);
519      return 9;
520    }
521    if(match_Other(context, token)) {
522      build(context, token);
523      return 8;
524    }
525    
526    var stateComment = "State: 8 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
527    token.detach();
528    var expectedTokens = ["#DocStringSeparator", "#Other"];
529    var error = token.isEof ?
530      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
531      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
532    if (self.stopAtFirstError) throw error;
533    addError(context, error);
534    return 8;
535  }
536
537
538  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0
539  function matchTokenAt_9(token, context) {
540    if(match_EOF(context, token)) {
541      endRule(context, 'DocString');
542      endRule(context, 'Step');
543      endRule(context, 'Scenario');
544      endRule(context, 'Scenario_Definition');
545      build(context, token);
546      return 7;
547    }
548    if(match_StepLine(context, token)) {
549      endRule(context, 'DocString');
550      endRule(context, 'Step');
551      startRule(context, 'Step');
552      build(context, token);
553      return 5;
554    }
555    if(match_TagLine(context, token)) {
556      endRule(context, 'DocString');
557      endRule(context, 'Step');
558      endRule(context, 'Scenario');
559      endRule(context, 'Scenario_Definition');
560      startRule(context, 'Scenario_Definition');
561      startRule(context, 'Tags');
562      build(context, token);
563      return 1;
564    }
565    if(match_ScenarioLine(context, token)) {
566      endRule(context, 'DocString');
567      endRule(context, 'Step');
568      endRule(context, 'Scenario');
569      endRule(context, 'Scenario_Definition');
570      startRule(context, 'Scenario_Definition');
571      startRule(context, 'Scenario');
572      build(context, token);
573      return 2;
574    }
575    if(match_Comment(context, token)) {
576      build(context, token);
577      return 9;
578    }
579    if(match_Empty(context, token)) {
580      build(context, token);
581      return 9;
582    }
583    
584    var stateComment = "State: 9 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
585    token.detach();
586    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
587    var error = token.isEof ?
588      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
589      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
590    if (self.stopAtFirstError) throw error;
591    addError(context, error);
592    return 9;
593  }
594
595
596
597  function match_EOF(context, token) {
598    return handleExternalError(context, false, function () {
599      return context.tokenMatcher.match_EOF(token);
600    });
601  }
602
603
604  function match_Empty(context, token) {
605    if(token.isEof) return false;
606    return handleExternalError(context, false, function () {
607      return context.tokenMatcher.match_Empty(token);
608    });
609  }
610
611
612  function match_Comment(context, token) {
613    if(token.isEof) return false;
614    return handleExternalError(context, false, function () {
615      return context.tokenMatcher.match_Comment(token);
616    });
617  }
618
619
620  function match_TagLine(context, token) {
621    if(token.isEof) return false;
622    return handleExternalError(context, false, function () {
623      return context.tokenMatcher.match_TagLine(token);
624    });
625  }
626
627
628  function match_ScenarioLine(context, token) {
629    if(token.isEof) return false;
630    return handleExternalError(context, false, function () {
631      return context.tokenMatcher.match_ScenarioLine(token);
632    });
633  }
634
635
636  function match_ExamplesLine(context, token) {
637    if(token.isEof) return false;
638    return handleExternalError(context, false, function () {
639      return context.tokenMatcher.match_ExamplesLine(token);
640    });
641  }
642
643
644  function match_StepLine(context, token) {
645    if(token.isEof) return false;
646    return handleExternalError(context, false, function () {
647      return context.tokenMatcher.match_StepLine(token);
648    });
649  }
650
651
652  function match_DocStringSeparator(context, token) {
653    if(token.isEof) return false;
654    return handleExternalError(context, false, function () {
655      return context.tokenMatcher.match_DocStringSeparator(token);
656    });
657  }
658
659
660  function match_TableRow(context, token) {
661    if(token.isEof) return false;
662    return handleExternalError(context, false, function () {
663      return context.tokenMatcher.match_TableRow(token);
664    });
665  }
666
667
668  function match_Language(context, token) {
669    if(token.isEof) return false;
670    return handleExternalError(context, false, function () {
671      return context.tokenMatcher.match_Language(token);
672    });
673  }
674
675
676  function match_Other(context, token) {
677    if(token.isEof) return false;
678    return handleExternalError(context, false, function () {
679      return context.tokenMatcher.match_Other(token);
680    });
681  }
682
683
684
685}
686
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)