mobiusloop 0.1.2

data/spec/cucumber/formatter/junit_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
+
+require 'cucumber/formatter/junit'
+require 'nokogiri'
+
+module Cucumber
+  module Formatter
+    describe Junit do
+      extend SpecHelperDsl
+      include SpecHelper
+
+      class TestDoubleJunitFormatter < Junit
+        attr_reader :written_files
+
+        def write_file(feature_filename, data)
+          @written_files ||= {}
+          @written_files[feature_filename] = data
+        end
+      end
+
+      context "With no options" do
+        before(:each) do
+          allow(File).to receive(:directory?) { true }
+          @formatter = TestDoubleJunitFormatter.new(actual_runtime.configuration.with_options(out_stream: ''))
+        end
+
+        after(:each) do
+          $stdout = STDOUT
+        end
+
+        describe "is able to strip control chars from cdata" do
+          before(:each) do
+            run_defined_feature
+            @doc = Nokogiri.XML(@formatter.written_files.values.first)
+          end
+          define_feature "
+              Feature: One passing scenario, one failing scenario
+
+                Scenario: Passing
+                  Given a passing ctrl scenario
+            "
+          class Junit
+            def before_step(step)
+              if step.name.match("a passing ctrl scenario")
+                Interceptor::Pipe.unwrap! :stdout
+                @fake_io = $stdout = StringIO.new
+                $stdout.sync = true
+                @interceptedout = Interceptor::Pipe.wrap(:stdout)
+              end
+            end
+
+            def after_step(step)
+              if step.name.match("a passing ctrl scenario")
+                @interceptedout.write("boo\b\cx\e\a\f boo ")
+                $stdout = STDOUT
+                @fake_io.close
+              end
+            end
+          end
+
+          it { expect(@doc.xpath('//testsuite/testcase/system-out').first.content).to match(/\s+boo boo\s+/) }
+        end
+
+        describe "a feature with no name" do
+          define_feature <<-FEATURE
+            Feature:
+              Scenario: Passing
+                Given a passing scenario
+          FEATURE
+
+          it "raises an exception" do
+            expect(-> {
+              run_defined_feature
+            }).to raise_error(Junit::UnNamedFeatureError)
+          end
+        end
+
+        describe "given a single feature" do
+          before(:each) do
+            run_defined_feature
+            @doc = Nokogiri.XML(@formatter.written_files.values.first)
+          end
+
+          describe "with a single scenario" do
+            define_feature <<-FEATURE
+              Feature: One passing scenario, one failing scenario
+
+                Scenario: Passing
+                  Given a passing scenario
+            FEATURE
+
+            it { expect(@doc.to_s).to match /One passing scenario, one failing scenario/ }
+
+            it 'has not a root system-out node' do
+              expect(@doc.xpath('//testsuite/system-out').size).to eq 0
+            end
+
+            it 'has not a root system-err node' do
+              expect(@doc.xpath('//testsuite/system-err').size).to eq 0
+            end
+
+            it 'has a system-out node under <testcase/>' do
+              expect(@doc.xpath('//testcase/system-out').size).to eq 1
+            end
+
+            it 'has a system-err node under <testcase/>' do
+              expect(@doc.xpath('//testcase/system-err').size).to eq 1
+            end
+          end
+
+          describe "with a scenario in a subdirectory" do
+            define_feature %{
+              Feature: One passing scenario, one failing scenario
+
+                Scenario: Passing
+                  Given a passing scenario
+            }, File.join('features', 'some', 'path', 'spec.feature')
+
+            it 'writes the filename including the subdirectory' do
+              expect(@formatter.written_files.keys.first).to eq File.join('', 'TEST-features-some-path-spec.xml')
+            end
+          end
+
+          describe "with a scenario outline table" do
+            define_steps do
+              Given(/.*/) {  }
+            end
+
+            define_feature <<-FEATURE
+              Feature: Eat things when hungry
+
+                Scenario Outline: Eat things
+                  Given <Things>
+                  And stuff:
+                    | foo |
+                    | bar |
+
+                Examples: Good
+                  | Things   |
+                  | Cucumber |
+                  | Whisky   |
+                Examples: Evil
+                  | Things   |
+                  | Big Mac  |
+            FEATURE
+
+            it { expect(@doc.to_s).to match /Eat things when hungry/ }
+            it { expect(@doc.to_s).to match /Cucumber/ }
+            it { expect(@doc.to_s).to match /Whisky/ }
+            it { expect(@doc.to_s).to match /Big Mac/ }
+            it { expect(@doc.to_s).not_to match /Things/ }
+            it { expect(@doc.to_s).not_to match /Good|Evil/ }
+            it { expect(@doc.to_s).not_to match /type="skipped"/}
+          end
+
+          describe "scenario with skipped test in junit report" do
+            define_feature <<-FEATURE
+              Feature: junit report with skipped test
+
+                Scenario Outline: skip a test and junit report of the same
+                  Given a <skip> scenario
+
+                Examples:
+                  | skip   |
+                  | undefined |
+                  | still undefined  |
+            FEATURE
+
+            it { expect(@doc.to_s).to match /skipped="2"/}
+          end
+
+          describe "with a regular data table scenario" do
+            define_steps do
+              Given(/the following items on a shortlist/) { |table| }
+              When(/I go.*/) {  }
+              Then(/I should have visited at least/) { |table| }
+            end
+
+            define_feature <<-FEATURE
+              Feature: Shortlist
+
+                Scenario: Procure items
+                  Given the following items on a shortlist:
+                    | item    |
+                    | milk    |
+                    | cookies |
+                  When I get some..
+                  Then I'll eat 'em
+
+            FEATURE
+            # these type of tables shouldn't crash (or generate test cases)
+            it { expect(@doc.to_s).not_to match /milk/ }
+            it { expect(@doc.to_s).not_to match /cookies/ }
+          end
+        end
+      end
+      
+      context "In --expand mode" do
+        let(:runtime)   { Runtime.new({:expand => true}) }
+        before(:each) do
+          allow(File).to receive(:directory?) { true }
+          @formatter = TestDoubleJunitFormatter.new(actual_runtime.configuration.with_options(out_stream: '', :expand => true))
+        end
+
+        after(:each) do
+          $stdout = STDOUT
+        end
+
+        describe "given a single feature" do
+          before(:each) do
+            run_defined_feature
+            @doc = Nokogiri.XML(@formatter.written_files.values.first)
+          end
+          
+          describe "with a scenario outline table" do
+            define_steps do
+              Given(/.*/) {  }
+            end
+
+            define_feature <<-FEATURE
+              Feature: Eat things when hungry
+
+                Scenario Outline: Eat things
+                  Given <Things>
+                  And stuff:
+                    | foo |
+                    | bar |
+
+                Examples: Good
+                  | Things   |
+                  | Cucumber |
+                  | Whisky   |
+                Examples: Evil
+                  | Things   |
+                  | Big Mac  |
+            FEATURE
+
+            it { expect(@doc.to_s).to match /Eat things when hungry/ }
+            it { expect(@doc.to_s).to match /Cucumber/ }
+            it { expect(@doc.to_s).to match /Whisky/ }
+            it { expect(@doc.to_s).to match /Big Mac/ }
+            it { expect(@doc.to_s).not_to match /Things/ }
+            it { expect(@doc.to_s).not_to match /Good|Evil/ }
+            it { expect(@doc.to_s).not_to match /type="skipped"/}
+          end
+        end
+        
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/legacy_api/adapter_spec.rb

@@ -0,0 +1,2182 @@
+require 'cucumber/formatter/legacy_api/adapter'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
+require 'cucumber/filters'
+require 'spec_helper'
+
+module Cucumber
+  module Formatter::LegacyApi
+    describe Adapter do
+      include Core::Gherkin::Writer
+      include Core
+
+      let(:report)    { Adapter.new(formatter, runtime.results, runtime.configuration) }
+      let(:formatter) { double('formatter').as_null_object }
+      let(:runtime)   { Runtime.new }
+      let(:step_match_search) { SimpleStepDefinitionSearch.new }
+
+      Failure = Class.new(StandardError)
+
+      class SimpleStepMatch
+        def initialize(&block)
+          @block = block
+        end
+
+        def activate(test_step)
+          test_step.with_action &@block
+        end
+      end
+
+      class SimpleStepDefinitionSearch
+        def call(name)
+          if name =~ /pass/
+            return [SimpleStepMatch.new {}]
+          end
+
+          if name =~ /fail/
+            return [SimpleStepMatch.new { raise Failure }]
+          end
+
+          []
+        end
+      end
+
+      class HookWrapper
+        def initialize(proc)
+          @proc = proc
+        end
+
+        def source_location
+          @proc.source_location
+        end
+
+        def location
+          source_location
+        end
+
+        def invoke(pseudo_method, arguments, &block)
+          @proc.call
+        end
+      end
+
+      class AddBeforeAndAfterHooks < Core::Filter.new
+        def test_case(test_case)
+          steps = before_hooks(test_case.source) +
+            test_case.test_steps +
+            after_hooks(test_case.source)
+          test_case.with_steps(steps).describe_to receiver
+        end
+
+        private
+
+        def before_hooks(source)
+          # The adapter is built on the assumption that each test case will have at least one step. This is annoying
+          # for tests, but a safe assumption for production use as we always add one hook to initialize the world.
+          hook = proc {}
+          [ Hooks.before_hook(source, hook.source_location, &hook) ]
+        end
+
+        def after_hooks(source)
+          # We add an after hook to make sure the adapter can cope with it
+          hook = proc {}
+          [ Hooks.after_hook(source, hook.source_location, &hook) ]
+        end
+      end
+
+      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,
+          ]
+          runner = Core::Test::Runner.new(report)
+          compile gherkin_docs, runner, default_filters
+          expect( formatter.legacy_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.legacy_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.legacy_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.legacy_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.legacy_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.legacy_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 an empty scenario' do
+          execute_gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+              scenario
+            end
+          end
+          expect( formatter.legacy_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,
+                :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.legacy_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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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.legacy_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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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.legacy_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.legacy_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,
+                          :before_tags,
+                          :after_tags,
+                          :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
+
+          class FailingAfterStepHook
+            def find_after_step_hooks(test_case)
+              failing_hook = HookWrapper.new(proc { raise Failure })
+              Runtime::StepHooks.new [failing_hook]
+            end
+          end
+
+          it 'prints the exception within the step' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAfterStepHooks.new(FailingAfterStepHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+            expect( formatter.legacy_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 a single before hook' do
+          class FailingBeforeHook
+            def apply_before_hooks(test_case)
+              failing_hook = HookWrapper.new(proc { raise Failure })
+              Runtime::BeforeHooks.new([failing_hook], RunningTestCase.new(test_case)).apply_to(test_case)
+            end
+          end
+
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                background do
+                  step 'passing'
+                end
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario_outline do
+                  step '<status>ing'
+                  examples do
+                    row 'status'
+                    row 'pass'
+                  end
+                end
+              end
+            end
+
+            expect( formatter.legacy_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,
+                          :before_tags,
+                          :after_tags,
+                          :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 the first of several before hooks' do
+          # This proves that the second before hook's result doesn't overwrite
+          # the result of the first one.
+          class FailingAndPassingBeforeHooks
+            def apply_before_hooks(test_case)
+              failing_hook = HookWrapper.new(proc { raise Failure })
+              passing_hook = HookWrapper.new(proc {})
+              Runtime::BeforeHooks.new([failing_hook, passing_hook], RunningTestCase.new(test_case)).apply_to(test_case)
+            end
+          end
+
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyBeforeHooks.new(FailingAndPassingBeforeHooks.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+        end
+
+        context 'with exception in after hooks' do
+
+          class FailingAfterHook
+            def apply_after_hooks(test_case)
+              failing_hook = HookWrapper.new(proc { raise Failure })
+              Runtime::AfterHooks.new([failing_hook], RunningTestCase.new(test_case)).apply_to(test_case)
+            end
+          end
+
+          it 'prints the exception after the steps' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario_outline do
+                  step '<status>ing'
+                  examples do
+                    row 'status'
+                    row 'pass'
+                  end
+                end
+              end
+            end
+
+            expect( formatter.legacy_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,
+                        :before_tags,
+                        :after_tags,
+                        :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
+
+        context 'with exception in the first of several after hooks' do
+          class FailingThenPassingAfterHooks
+            def apply_after_hooks(test_case)
+              failing_hook = HookWrapper.new(proc { raise Failure })
+              passing_hook = HookWrapper.new(proc {})
+              Runtime::AfterHooks.new([failing_hook, passing_hook], RunningTestCase.new(test_case)).apply_to(test_case)
+            end
+          end
+
+          it 'prints the exception after the steps' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAfterHooks.new(FailingThenPassingAfterHooks.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+        end
+
+        context 'with an exception in an after hook but no steps' do
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                end
+              end
+            end
+
+            expect( formatter.legacy_messages ).to eq([
+              :before_features,
+                :before_feature,
+                  :before_tags,
+                  :after_tags,
+                  :feature_name,
+                  :before_feature_element,
+                    :before_tags,
+                    :after_tags,
+                    :scenario_name,
+                    :exception,
+                  :after_feature_element,
+                :after_feature,
+              :after_features,
+            ])
+          end
+        end
+
+        context 'with an exception in an around hook before the test case is run' do
+          class FailingAroundHookBeforeRunningTestCase
+            def find_around_hooks(test_case)
+              [
+                Hooks.around_hook(test_case.source) { raise Failure }
+              ]
+            end
+          end
+
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAroundHooks.new(FailingAroundHookBeforeRunningTestCase.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                end
+              end
+            end
+
+            expect( formatter.legacy_messages ).to eq([
+              :before_features,
+                :before_feature,
+                  :before_tags,
+                  :after_tags,
+                  :feature_name,
+                  :before_feature_element,
+                    :before_tags,
+                    :after_tags,
+                    :scenario_name,
+                    :exception,
+                  :after_feature_element,
+                :after_feature,
+              :after_features,
+            ])
+          end
+        end
+
+        context 'with an exception in an around hook after the test case is run' do
+          class FailingAroundHookAfterRunningTestCase
+            def find_around_hooks(test_case)
+              [
+                Hooks.around_hook(test_case.source) { |run_test_case| run_test_case.call; raise Failure }
+              ]
+            end
+          end
+
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+              Filters::ApplyAroundHooks.new(FailingAroundHookAfterRunningTestCase.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
+              feature do
+                scenario do
+                  step
+                end
+              end
+            end
+
+            expect( formatter.legacy_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
+      end
+
+      describe 'before_step_result message' do
+        context 'when the step matches' do
+          it "sends the step match to the formatter" do
+            expect(formatter).to receive(:before_step_result) do |_, step_match, *|
+              expect(step_match).to be_a SimpleStepMatch
+            end
+            execute_gherkin do
+              feature do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+          end
+        end
+
+        context "when the step doesn't match" do
+          it "sends a null object to the formatter" do
+          end
+        end
+      end
+
+      it 'passes nil as the multiline arg when there is none' do
+        expect(formatter).to receive(:after_step_result) do |keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line|
+          expect(multiline_arg).to be_nil
+        end
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      end
+
+      context "after_feature_element callback" do
+        it 'passes an object reflecting the status of the scenario' do
+          expect( formatter ).to receive(:after_feature_element).once do |scenario|
+            expect( scenario ).to be_failed
+          end
+          execute_gherkin do
+            feature do
+              scenario do
+                step 'failing'
+                step 'this will be skipped'
+              end
+            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 legacy_messages
+          @messages - [
+            :before_test_step,
+            :before_test_case,
+            :after_test_step,
+            :after_test_case,
+            :done
+          ]
+        end
+
+        def method_missing(message, *args)
+          @messages << message
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          true
+        end
+      end
+
+      def execute_gherkin(filters = default_filters, &gherkin)
+        runner = Core::Test::Runner.new(report)
+        compile [gherkin(&gherkin)], runner, filters
+      end
+
+      def default_filters
+        [
+          Filters::ActivateSteps.new(step_match_search, runtime.configuration),
+          AddBeforeAndAfterHooks.new
+        ]
+      end
+
+    end
+  end
+end