cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-require 'cucumber/formatter/interceptor'
-
-module Cucumber::Formatter
-  describe Interceptor::Pipe do
-    let(:pipe) do
-      pipe = double('original pipe')
-
-      allow(pipe).to receive(:instance_of?) { true }
-
-      pipe
-    end
-
-    describe '#wrap!' do
-      it 'raises an ArgumentError if its not passed :stderr/:stdout' do
-        expect {
-          Interceptor::Pipe.wrap(:nonsense)
-        }.to raise_error(ArgumentError)
-      end
-
-      context 'when passed :stderr' do
-        before :each do
-          @stderr = $stdout
-        end
-
-        it 'wraps $stderr' do
-          wrapped = Interceptor::Pipe.wrap(:stderr)
-
-          expect($stderr).to be_instance_of Interceptor::Pipe
-          expect($stderr).to be wrapped
-        end
-
-        after :each do
-          $stderr = @stderr
-        end
-      end
-
-      context 'when passed :stdout' do
-        before :each do
-          @stdout = $stdout
-        end
-
-        it 'wraps $stdout' do
-          wrapped = Interceptor::Pipe.wrap(:stdout)
-
-          expect($stdout).to be_instance_of Interceptor::Pipe
-          expect($stdout).to be wrapped
-        end
-
-        after :each do
-          $stdout = @stdout
-        end
-      end
-    end
-
-    describe '#unwrap!' do
-      before :each do
-        @stdout = $stdout
-        @wrapped = Interceptor::Pipe.wrap(:stdout)
-      end
-
-      it 'raises an ArgumentError if it wasn\'t passed :stderr/:stdout' do
-        expect {
-          Interceptor::Pipe.unwrap!(:nonsense)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'resets $stdout when #unwrap! is called' do
-        interceptor = Interceptor::Pipe.unwrap! :stdout
-
-        expect(interceptor).to be_instance_of Interceptor::Pipe
-        expect($stdout).not_to be interceptor
-      end
-
-      it 'noops if $stdout or $stderr has been overwritten' do
-        $stdout = StringIO.new
-        pipe = Interceptor::Pipe.unwrap! :stdout
-        expect(pipe).to eq $stdout
-
-        $stderr = StringIO.new
-        pipe = Interceptor::Pipe.unwrap! :stderr
-        expect(pipe).to eq $stderr
-      end
-
-      it 'disables the pipe bypass' do
-        buffer = '(::)'
-        Interceptor::Pipe.unwrap! :stdout
-
-        expect(@wrapped).to receive(:write).with(buffer)
-        expect(@wrapped.buffer).not_to receive(:<<)
-
-        @wrapped.write(buffer)
-      end
-
-      after :each do
-        $stdout = @stdout
-      end
-    end
-
-    describe '#write' do
-      let(:buffer) { 'Some stupid buffer' }
-      let(:pi) { Interceptor::Pipe.new(pipe) }
-
-      it 'writes arguments to the original pipe' do
-        expect(pipe).to receive(:write).with(buffer) { buffer.size }
-        expect(pi.write(buffer)).to eq buffer.size
-      end
-
-      it 'adds the buffer to its stored output' do
-        allow(pipe).to receive(:write)
-
-        pi.write(buffer)
-
-        expect(pi.buffer).not_to be_empty
-        expect(pi.buffer.first).to eq buffer
-      end
-    end
-
-    describe '#method_missing' do
-      let(:pi) { Interceptor::Pipe.new(pipe) }
-
-      it 'passes #tty? to the original pipe' do
-        expect(pipe).to receive(:tty?) { true }
-        expect(pi.tty?).to be true
-      end
-    end
-
-    describe '#respond_to' do
-      let(:pi) { Interceptor::Pipe.wrap(:stderr) }
-
-      it 'responds to all methods $stderr has' do
-        $stderr.methods.each { |m| expect(pi.respond_to?(m)).to be true }
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/junit_spec.rb

@@ -1,252 +0,0 @@
-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(runtime, '', {})
-        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/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 a root system-out node' do
-              expect(@doc.xpath('//testsuite/system-out').size).to eq 1
-            end
-
-            it 'has a root system-err node' do
-              expect(@doc.xpath('//testsuite/system-err').size).to eq 1
-            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(runtime, '', {: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

@@ -1,2090 +0,0 @@
-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'
-
-module Cucumber
-  module Formatter::LegacyApi
-    describe Adapter do
-      include Core::Gherkin::Writer
-      include Core
-
-      let(:report)    { Adapter.new(formatter, runtime.results, runtime.support_code, runtime.configuration) }
-      let(:formatter) { double('formatter').as_null_object }
-      let(:runtime)   { Runtime.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 SimpleStepDefinitions
-        def find_match(test_step)
-          if test_step.name =~ /pass/
-            return SimpleStepMatch.new {}
-          end
-
-          if test_step.name =~ /fail/
-            return SimpleStepMatch.new { raise Failure }
-          end
-
-          NoStepMatch.new test_step.source.last, test_step.name
-        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.
-          [ Hooks.before_hook(source) {} ]
-        end
-
-        def after_hooks(source)
-          # We add an after hook to make sure the adapter can cope with it
-          [ Hooks.after_hook(source) {} ]
-        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,
-                        :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,
-                        :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,
-                        :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.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,
-                        :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,
-                        :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.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,
-                        :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,
-                        :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,
-                        :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,
-                        :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,
-                        :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.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,
-                        :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.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,
-                        :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,
-                          :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)
-              Runtime::StepHooks.new [-> { raise Failure }]
-            end
-          end
-
-          it 'prints the exception within the step' do
-            filters = [
-              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
-              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)
-              Runtime::BeforeHooks.new([proc { raise Failure }]).apply_to(test_case)
-            end
-          end
-
-          it 'prints the exception after the scenario name' do
-            filters = [
-              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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,
-                          :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)
-              Runtime::BeforeHooks.new([proc { raise Failure }, proc { }]).apply_to(test_case)
-            end
-          end
-
-          it 'prints the exception after the scenario name' do
-            filters = [
-              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
-              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)
-              Runtime::AfterHooks.new([proc { raise Failure }]).apply_to(test_case)
-            end
-          end
-
-          it 'prints the exception after the steps' do
-            filters = [
-              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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,
-                        :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)
-              Runtime::AfterHooks.new([proc { raise Failure }, proc {}]).apply_to(test_case)
-            end
-          end
-
-          it 'prints the exception after the steps' do
-            filters = [
-              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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(SimpleStepDefinitions.new),
-              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
-
-      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
-
-      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 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(SimpleStepDefinitions.new),
-          AddBeforeAndAfterHooks.new
-        ]
-      end
-
-    end
-  end
-end