How to use match_token_at_32 method in Gherkin-python

Best Python code snippet using gherkin-python

Run Gherkin-python automation tests on LambdaTest cloud grid

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

parser.py

Source: parser.py Github

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

Execute automation tests with Gherkin-python 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)