cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -7,17 +7,18 @@ module Cucumber
       def transform(regexp)
         RbTransform.new(nil, regexp, lambda { |a| })
       end
+
       describe "#to_s" do
         it "converts captures groups to non-capture groups" do
-          transform(/(a|b)bc/).to_s.should == "(?:a|b)bc"
+          expect(transform(/(a|b)bc/).to_s).to eq "(?:a|b)bc"
         end
 
         it "leaves non capture groups alone" do
-          transform(/(?:a|b)bc/).to_s.should == "(?:a|b)bc"
+          expect(transform(/(?:a|b)bc/).to_s).to eq "(?:a|b)bc"
         end
 
         it "strips away anchors" do
-          transform(/^xyz$/).to_s.should == "xyz"
+          expect(transform(/^xyz$/).to_s).to eq "xyz"
         end
       end
     end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -6,14 +6,16 @@ module Cucumber
     describe RegexpArgumentMatcher do
       include RSpec::WorkInProgress
 
-      it "should create 2 arguments" do
+      it "creates 2 arguments" do
         arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [["like", 2], ["fish", 7]]
+
+        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [["like", 2], ["fish", 7]]
       end
 
-      it "should create 2 arguments when first group is optional" do
+      it "creates 2 arguments when first group is optional" do
         arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [[nil, nil], ["Login failed.", 21]]
+
+        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ["Login failed.", 21]]
       end
     end
   end

data/spec/cucumber/rb_support/snippet_spec.rb

@@ -4,16 +4,15 @@ require 'cucumber/rb_support/snippet'
 module Cucumber
   module RbSupport
     describe Snippet do
-
       let(:code_keyword) { "Given" }
 
       before do
         @pattern = 'we have a missing step'
-        @multiline_argument_class = nil
+        @multiline_argument = Core::Ast::EmptyMultilineArgument.new
       end
 
       let(:snippet) do
-        snippet_class.new(code_keyword, @pattern, @multiline_argument_class)
+        snippet_class.new(code_keyword, @pattern, @multiline_argument)
       end
 
       def unindented(s)
@@ -24,76 +23,87 @@ module Cucumber
         let(:snippet_class) { Snippet::Regexp }
         let(:snippet_text) { snippet.to_s }
 
-        it "should wrap snippet patterns in parentheses" do
+        it "wraps snippet patterns in parentheses" do
           @pattern = 'A "string" with 4 spaces'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A "(.*?)" with (\\d+) spaces$/) do |arg1, arg2|
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise numbers in name and make according regexp" do
+        it "recognises numbers in name and make according regexp" do
           @pattern = 'Cloud 9 yeah'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^Cloud (\\d+) yeah$/) do |arg1|
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise a mix of ints, strings and why not a table too" do
+        it "recognises a mix of ints, strings and why not a table too" do
           @pattern = 'I have 9 "awesome" cukes in 37 "boxes"'
-          @multiline_argument_class = Cucumber::Ast::Table
+          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^I have (\\d+) "(.*?)" cukes in (\\d+) "(.*?)"$/) do |arg1, arg2, arg3, arg4, table|
-            # table is a Cucumber::Ast::Table
-            pending # express the regexp above with the code you wish you had
+            # table is a Cucumber::Core::Ast::DataTable
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise quotes in name and make according regexp" do
+        it "recognises quotes in name and make according regexp" do
           @pattern = 'A "first" arg'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A "(.*?)" arg$/) do |arg1|
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise several quoted words in name and make according regexp and args" do
+        it "recognises several quoted words in name and make according regexp and args" do
           @pattern = 'A "first" and "second" arg'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A "(.*?)" and "(.*?)" arg$/) do |arg1, arg2|
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should not use quote group when there are no quotes" do
+        it "does not use quote group when there are no quotes" do
           @pattern = 'A first arg'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A first arg$/) do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should be helpful with tables" do
+        it "is helpful with tables" do
           @pattern = 'A "first" arg'
-          @multiline_argument_class = Cucumber::Ast::Table
+          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A "(.*?)" arg$/) do |arg1, table|
-            # table is a Cucumber::Ast::Table
-            pending # express the regexp above with the code you wish you had
+            # table is a Cucumber::Core::Ast::DataTable
+            pending # Write code here that turns the phrase above into concrete actions
+          end
+          })
+        end
+
+        it "is helpful with doc string" do
+          @pattern = 'A "first" arg'
+          @multiline_argument = Core::Ast::MultilineArgument.from("", Core::Ast::Location.new(""))
+
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "(.*?)" arg$/) do |arg1, string|
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
@@ -103,9 +113,9 @@ module Cucumber
         let(:snippet_class) { Snippet::Classic }
 
         it "renders snippet as unwrapped regular expression" do
-          snippet.to_s.should eql unindented(%{
+          expect(snippet.to_s).to eq unindented(%{
           Given /^we have a missing step$/ do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
@@ -115,14 +125,13 @@ module Cucumber
         let(:snippet_class) { Snippet::Percent }
 
         it "renders snippet as percent-style regular expression" do
-          snippet.to_s.should eql unindented(%{
+          expect(snippet.to_s).to eq unindented(%{
           Given %r{^we have a missing step$} do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
       end
-
     end
   end
 end

data/spec/cucumber/reports/legacy_formatter_spec.rb

@@ -0,0 +1,1750 @@
+require 'cucumber/reports/legacy_formatter'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/mappings'
+
+module Cucumber
+  describe Reports::LegacyFormatter do
+    include Core::Gherkin::Writer
+    include Core
+
+    let(:report)    { Reports::LegacyFormatter.new(runtime, [formatter]) }
+    let(:formatter) { double('formatter').as_null_object }
+    let(:runtime)   { Runtime.new }
+    let(:mappings)  { Mappings.new(runtime) }
+
+    before(:each) do
+      define_steps do
+        Given(/pass/) { }
+        Given(/fail/) { raise Failure }
+      end
+    end
+    Failure = Class.new(StandardError)
+
+    context 'message order' do
+      let(:formatter) { MessageSpy.new }
+
+      it 'two features' do
+        gherkin_docs = [
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end,
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end,
+        ]
+        execute gherkin_docs, mappings, report
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a scenario with no steps' do
+        execute_gherkin do
+          feature do
+            scenario
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                  :after_tags,
+                :scenario_name,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a scenario with no steps coming after another scenario' do
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+            scenario
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                  :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                  :after_tags,
+                :scenario_name,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a scenario with one step' do
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                  :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a scenario with two steps, one of them failing' do
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+              step 'failing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+          :before_feature,
+          :before_tags,
+          :after_tags,
+          :feature_name,
+          :before_feature_element,
+          :before_tags,
+          :after_tags,
+          :scenario_name,
+          :before_steps,
+          :before_step,
+          :before_step_result,
+          :step_name,
+          :after_step_result,
+          :after_step,
+          :before_step,
+          :before_step_result,
+          :step_name,
+          :exception,
+          :after_step_result,
+          :after_step,
+          :after_steps,
+          :after_feature_element,
+          :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with two scenarios' do
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and two scenarios' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and one scenario and one scenario outline' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and one scenario outline and one scenario' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and two scenario outlines' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and one scenario outline with two rows' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background and one scenario outline with two examples tables' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background with two steps' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a background' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+          :before_feature,
+          :before_tags,
+          :after_tags,
+          :feature_name,
+          :before_background,
+          :background_name,
+          :before_steps,
+          :before_step,
+          :before_step_result,
+          :step_name,
+          :after_step_result,
+          :after_step,
+          :after_steps,
+          :after_background,
+          :before_feature_element,
+          :before_tags,
+          :after_tags,
+          :scenario_name,
+          :before_steps,
+          :before_step,
+          :before_step_result,
+          :step_name,
+          :after_step_result,
+          :after_step,
+          :after_steps,
+          :after_feature_element,
+          :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'scenario outline' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'scenario outline after scenario' do
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'scenario outline before scenario' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'scenario outline two rows' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'scenario outline two examples tables' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'two scenario outline' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'pass'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'failing scenario outline' do
+        execute_gherkin do
+          feature do
+            scenario_outline do
+              step '<result>ing'
+              examples do
+                row 'result'
+                row 'fail'
+              end
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+                :before_examples_array,
+                  :before_examples,
+                    :examples_name,
+                    :before_outline_table,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                      :before_table_row,
+                        :before_table_cell,
+                          :table_cell_value,
+                        :after_table_cell,
+                      :after_table_row,
+                    :after_outline_table,
+                  :after_examples,
+                :after_examples_array,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      it 'a feature with a failing background and two scenarios' do
+        execute_gherkin do
+          feature do
+            background do
+              step 'failing'
+            end
+            scenario do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+        expect( formatter.messages ).to eq [
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                      :exception,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+        ]
+      end
+
+      context 'in expand mode' do
+        let(:runtime) { Runtime.new expand: true }
+        let(:formatter) { MessageSpy.new }
+
+        it 'scenario outline two rows' do
+          execute_gherkin do
+            feature do
+              scenario_outline do
+                step '<result>ing'
+                examples do
+                  row 'result'
+                  row 'pass'
+                  row 'pass'
+                end
+              end
+            end
+          end
+          expect( formatter.messages ).to eq [
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
+                  :before_tags,
+                  :after_tags,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                        :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                  :before_examples_array,
+                    :before_examples,
+                      :examples_name,
+                      :before_outline_table,
+                        :scenario_name,
+                        :before_step,
+                          :before_step_result,
+                            :step_name,
+                          :after_step_result,
+                        :after_step,
+                        :scenario_name,
+                        :before_step,
+                          :before_step_result,
+                            :step_name,
+                          :after_step_result,
+                        :after_step,
+                      :after_outline_table,
+                    :after_examples,
+                  :after_examples_array,
+                :after_feature_element,
+              :after_feature,
+            :after_features
+          ]
+        end
+      end
+
+      context 'with exception in after step hook' do
+        it 'prints the exception within the step' do
+          define_steps do
+            AfterStep do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+          expect( formatter.messages ).to eq([
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                  :exception,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+          ])
+        end
+      end
+
+      context 'with exception in before hooks' do
+        it 'prints the exception after the scenario name' do
+          define_steps do
+            Before do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+
+          expect( formatter.messages ).to eq([
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :exception,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+          ])
+        end
+
+        it 'prints the exception after the background name' do
+          define_steps do
+            Before do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+
+          expect( formatter.messages ).to eq([
+          :before_features,
+            :before_feature,
+              :before_tags,
+              :after_tags,
+              :feature_name,
+              :before_background,
+                :background_name,
+                :exception,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                      :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_background,
+              :before_feature_element,
+                :before_tags,
+                :after_tags,
+                :scenario_name,
+                :before_steps,
+                  :before_step,
+                    :before_step_result,
+                    :step_name,
+                    :after_step_result,
+                  :after_step,
+                :after_steps,
+              :after_feature_element,
+            :after_feature,
+          :after_features
+          ])
+        end
+
+
+        it 'prints the exception before the examples table row' do
+          define_steps do
+            Before do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              scenario_outline do
+                step '<status>ing'
+                examples do
+                  row 'status'
+                  row 'pass'
+                end
+              end
+            end
+          end
+
+          expect( formatter.messages ).to eq([
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
+                  :before_tags,
+                  :after_tags,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                        :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                  :before_examples_array,
+                    :before_examples,
+                      :examples_name,
+                      :before_outline_table,
+                        :before_table_row,
+                          :before_table_cell,
+                            :table_cell_value,
+                          :after_table_cell,
+                        :after_table_row,
+                        :exception,
+                        :before_table_row,
+                          :before_table_cell,
+                            :table_cell_value,
+                          :after_table_cell,
+                        :after_table_row,
+                      :after_outline_table,
+                    :after_examples,
+                  :after_examples_array,
+                :after_feature_element,
+              :after_feature,
+            :after_features
+          ])
+        end
+      end
+
+      context 'with exception in after hooks' do
+        it 'prints the exception after the steps' do
+          define_steps do
+            After do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+
+          expect( formatter.messages ).to eq([
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
+                  :before_tags,
+                  :after_tags,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                      :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                  :exception,
+                :after_feature_element,
+              :after_feature,
+            :after_features
+          ])
+        end
+
+        it 'prints the exception after the examples table row' do
+          define_steps do
+            After do
+              raise 'an exception'
+            end
+          end
+          execute_gherkin do
+            feature do
+              scenario_outline do
+                step '<status>ing'
+                examples do
+                  row 'status'
+                  row 'pass'
+                end
+              end
+            end
+          end
+
+          expect( formatter.messages ).to eq([
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
+                  :before_tags,
+                  :after_tags,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                        :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                  :before_examples_array,
+                    :before_examples,
+                      :examples_name,
+                      :before_outline_table,
+                        :before_table_row,
+                          :before_table_cell,
+                            :table_cell_value,
+                          :after_table_cell,
+                        :after_table_row,
+                        :before_table_row,
+                          :before_table_cell,
+                            :table_cell_value,
+                          :after_table_cell,
+                        :after_table_row,
+                        :exception,
+                      :after_outline_table,
+                    :after_examples,
+                  :after_examples_array,
+                :after_feature_element,
+              :after_feature,
+            :after_features
+          ])
+        end
+      end
+    end
+
+    it 'passes an object responding to failed? with the after_feature_element message' do
+      expect( formatter ).to receive(:after_feature_element) do |scenario|
+        expect( scenario ).to be_failed
+      end
+      execute_gherkin do
+        feature do
+          scenario do
+            step 'failing'
+          end
+        end
+      end
+    end
+
+    context 'in strict mode' do
+      let(:runtime) { Runtime.new strict: true }
+
+      it 'passes an exception to the formatter for undefined steps' do
+      expect( formatter ).to receive(:exception) do |exception|
+        expect( exception.message ).to eq %{Undefined step: "this step is undefined"}
+      end
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'this step is undefined'
+            end
+          end
+        end
+      end
+    end
+
+    class MessageSpy
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def method_missing(message, *args)
+        @messages << message
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        true
+      end
+    end
+
+    def execute_gherkin(&gherkin)
+      execute [gherkin(&gherkin)], mappings, report
+    end
+
+    def define_steps(&block)
+      runtime.load_programming_language('rb')
+      dsl = Object.new
+      dsl.extend RbSupport::RbDsl
+      dsl.instance_exec &block
+    end
+  end
+end