cucumber-core 3.0.0 → 3.1.0

data/spec/cucumber/core/test/duration_matcher.rb

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-# frozen_string_literal: true
-require 'cucumber/core/test/result'
-require 'rspec/expectations'
-
-module Cucumber::Core::Test
-  RSpec::Matchers.define :be_duration do |expected|
-    match do |actual|
-      actual.tap { |duration| @nanoseconds = duration.nanoseconds }
-      @nanoseconds == expected
-    end
-  end
-
-  RSpec::Matchers.define :an_unknown_duration do
-    match do |actual|
-      actual.tap { raise "#tap block was executed, not an UnknownDuration" }
-      expect(actual).to respond_to(:nanoseconds)
-    end
-  end
-end

data/spec/cucumber/core/test/filters/locations_filter_spec.rb

@@ -1,405 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core'
-require 'cucumber/core/test/filters/locations_filter'
-require 'timeout'
-require 'cucumber/core/ast/location'
-
-module Cucumber::Core
-  describe Test::LocationsFilter do
-    include Cucumber::Core::Gherkin::Writer
-    include Cucumber::Core
-
-    let(:receiver) { SpyReceiver.new }
-
-    let(:doc) do
-      gherkin('features/test.feature') do
-        feature do
-          scenario 'x' do
-            step 'a step'
-          end
-
-          scenario 'y' do
-            step 'a step'
-          end
-        end
-      end
-    end
-
-    it "sorts by the given locations" do
-      locations = [
-        Ast::Location.new('features/test.feature', 6),
-        Ast::Location.new('features/test.feature', 3)
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq locations
-    end
-
-    it "works with wildcard locations" do
-      locations = [
-        Ast::Location.new('features/test.feature')
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq [
-        Ast::Location.new('features/test.feature', 3),
-        Ast::Location.new('features/test.feature', 6)
-      ]
-    end
-
-    it "filters out scenarios that don't match" do
-      locations = [
-        Ast::Location.new('features/test.feature', 3)
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq locations
-    end
-
-    describe "matching location" do
-      let(:file) { 'features/path/to/the.feature' }
-
-      let(:test_cases) do
-        receiver = double.as_null_object
-        result = []
-        allow(receiver).to receive(:test_case) { |test_case| result << test_case }
-        compile [doc], receiver
-        result
-      end
-
-      context "for a scenario" do
-        let(:doc) do
-          Gherkin::Document.new(file, <<-END)
-            Feature:
-
-              Scenario: one
-                Given one a
-
-              # comment
-              @tags
-              Scenario: two
-                Given two a
-                And two b
-
-              Scenario: three
-                Given three b
-
-              Scenario: with docstring
-                Given a docstring
-                  """
-                  this is a docstring
-                  """
-
-              Scenario: with a table
-                Given a table
-                  | a | b |
-                  | 1 | 2 |
-                  | 3 | 4 |
-
-          END
-        end
-
-        def test_case_named(name)
-          test_cases.find { |c| c.name == name }
-        end
-
-        it 'matches the precise location of the scenario' do
-          location = test_case_named('two').location
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it 'matches multiple locations' do
-          good_location = Ast::Location.new(file, 8)
-          bad_location = Ast::Location.new(file, 5)
-          filter = Test::LocationsFilter.new([good_location, bad_location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it 'matches a location on the last step of the scenario' do
-          location = Ast::Location.new(file, 10)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it "matches a location on the scenario's comment" do
-          location = Ast::Location.new(file, 6)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it "matches a location on the scenario's tags" do
-          location = Ast::Location.new(file, 7)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it "doesn't match a location after the last step of the scenario" do
-          location = Ast::Location.new(file, 11)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-
-        it "doesn't match a location before the scenario" do
-          location = Ast::Location.new(file, 5)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-
-        context "with a docstring" do
-          let(:test_case) do
-            test_cases.find { |c| c.name == 'with docstring' }
-          end
-
-          it "matches a location at the start the docstring" do
-            location = Ast::Location.new(file, 17)
-            filter = Test::LocationsFilter.new([location])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq [test_case.location]
-          end
-
-          it "matches a location in the middle of the docstring" do
-            location = Ast::Location.new(file, 18)
-            filter = Test::LocationsFilter.new([location])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq [test_case.location]
-          end
-
-          it "matches a location at the end of the docstring" do
-            location = Ast::Location.new(file, 19)
-            filter = Test::LocationsFilter.new([location])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq [test_case.location]
-          end
-
-          it "does not match a location after the docstring" do
-            location = Ast::Location.new(file, 20)
-            filter = Test::LocationsFilter.new([location])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq []
-          end
-        end
-
-        context "with a table" do
-          let(:test_case) do
-            test_cases.find { |c| c.name == 'with a table' }
-          end
-
-          it "matches a location at the start of the table" do
-            location = Ast::Location.new(file, 23)
-            expect( test_case.match_locations?([location]) ).to be_truthy
-          end
-
-          it "matches a location in the middle of the table" do
-            location = Ast::Location.new(file, 24)
-            expect( test_case.match_locations?([location]) ).to be_truthy
-          end
-
-          it "matches a location at the end of the table" do
-            location = Ast::Location.new(file, 25)
-            expect( test_case.match_locations?([location]) ).to be_truthy
-          end
-
-          it "does not match a location after the table" do
-            location = Ast::Location.new(file, 26)
-            expect( test_case.match_locations?([location]) ).to be_falsey
-          end
-        end
-
-        context "with duplicate locations in the filter" do
-          it "matches each test case only once" do
-            location_tc_two = test_case_named('two').location
-            location_tc_one = test_case_named('one').location
-            location_last_step_tc_two = Ast::Location.new(file, 10)
-            filter = Test::LocationsFilter.new([location_tc_two, location_tc_one, location_last_step_tc_two])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq [test_case_named('two').location, location_tc_one = test_case_named('one').location]
-          end
-        end
-      end
-
-      context "for a scenario outline" do
-        let(:doc) do
-          Gherkin::Document.new(file, <<-END)
-            Feature:
-
-              Scenario: one
-                Given one a
-
-              # comment on line 6
-              @tags-on-line-7
-              Scenario Outline: two
-                Given two a
-                And two <arg>
-                  """
-                  docstring
-                  """
-
-                # comment on line 15
-                @tags-on-line-16
-                Examples: x1
-                  | arg |
-                  | b   |
-
-                Examples: x2
-                  | arg |
-                  | c   |
-                  | d   |
-
-              Scenario: three
-                Given three b
-          END
-        end
-
-        let(:test_case) do
-          test_cases.find { |c| c.name == "two, x1 (#1)" }
-        end
-
-        it "matches row location to the test case of the row" do
-          locations = [
-            Ast::Location.new(file, 19),
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case.location]
-        end
-
-        it "matches examples location with all test cases of the table" do
-          locations = [
-            Ast::Location.new(file, 21),
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations.map(&:line)).to eq [23, 24]
-        end
-
-        it "matches outline location with the all test cases of all the tables" do
-          locations = [
-            Ast::Location.new(file, 8),
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations.map(&:line)).to eq [19, 23, 24]
-        end
-
-        it "matches outline step location the all test cases of all the tables" do
-          locations = [
-            Ast::Location.new(file, 10)
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations.map(&:line)).to eq [19, 23, 24]
-        end
-
-        it 'matches a location on a step of the scenario outline' do
-          location = Ast::Location.new(file, 10)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to include test_case.location
-        end
-
-        it 'matches a location on the docstring of a step of the scenario outline' do
-          location = Ast::Location.new(file, 12)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to include test_case.location
-        end
-
-        it "matches a location on the scenario outline's comment" do
-          location = Ast::Location.new(file, 6)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to include test_case.location
-        end
-
-        it "matches a location on the scenario outline's tags" do
-          location = Ast::Location.new(file, 7)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to include test_case.location
-        end
-
-        it "doesn't match a location after the last row of the examples table" do
-          location = Ast::Location.new(file, 20)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-
-        it "doesn't match a location before the scenario outline" do
-          location = Ast::Location.new(file, 5)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-      end
-    end
-
-    context "under load", slow: true do
-      num_features = 50
-      num_scenarios_per_feature = 50
-
-      let(:docs) do
-        (1..num_features).map do |i|
-          gherkin("features/test_#{i}.feature") do
-            feature do
-              (1..num_scenarios_per_feature).each do |j|
-                scenario "scenario #{j}" do
-                  step
-                end
-              end
-            end
-          end
-        end
-      end
-
-      num_locations = num_features
-      let(:locations) do
-        (1..num_locations).map do |i|
-          (1..num_scenarios_per_feature).map do |j|
-            line = 3 + (j - 1) * 3
-            Ast::Location.new("features/test_#{i}.feature", line)
-          end
-        end.flatten
-      end
-
-      max_duration_ms = 10000
-      max_duration_ms = max_duration_ms * 2.5 if defined?(JRUBY_VERSION)
-      it "filters #{num_features * num_scenarios_per_feature} test cases within #{max_duration_ms}ms" do
-        filter = Test::LocationsFilter.new(locations)
-        Timeout.timeout(max_duration_ms / 1000.0) do
-          compile docs, receiver, [filter]
-        end
-        expect(receiver.test_cases.length).to eq num_features * num_scenarios_per_feature
-      end
-
-    end
-  end
-
-  class SpyReceiver
-    def test_case(test_case)
-      test_cases << test_case
-    end
-
-    def done
-    end
-
-    def test_case_locations
-      test_cases.map(&:location)
-    end
-
-    def test_cases
-      @test_cases ||= []
-    end
-
-  end
-end

data/spec/cucumber/core/test/result_spec.rb

@@ -1,474 +0,0 @@
-# -*- encoding: utf-8 -*-
-# frozen_string_literal: true
-require 'cucumber/core/test/result'
-require 'cucumber/core/test/duration_matcher'
-
-module Cucumber::Core::Test
-  describe Result do
-
-    let(:visitor) { double('visitor') }
-    let(:args)    { double('args')    }
-
-    describe Result::Passed do
-      subject(:result) { Result::Passed.new(duration) }
-      let(:duration)   { Result::Duration.new(1 * 1000 * 1000) }
-
-      it "describes itself to a visitor" do
-        expect( visitor ).to receive(:passed).with(args)
-        expect( visitor ).to receive(:duration).with(duration, args)
-        result.describe_to(visitor, args)
-      end
-
-      it "converts to a string" do
-        expect( result.to_s ).to eq "✓"
-      end
-
-      it "has a duration" do
-        expect( result.duration ).to eq duration
-      end
-
-      it "requires the constructor argument" do
-        expect { Result::Passed.new }.to raise_error(ArgumentError)
-      end
-
-      it "does nothing when appending the backtrace" do
-        expect( result.with_appended_backtrace(double) ).to equal result
-      end
-
-      it "does nothing when filtering the backtrace" do
-        expect( result.with_filtered_backtrace(double) ).to equal result
-      end
-
-      specify { expect( result.to_sym ).to eq :passed }
-
-      specify { expect( result ).to     be_passed    }
-      specify { expect( result ).not_to be_failed    }
-      specify { expect( result ).not_to be_undefined }
-      specify { expect( result ).not_to be_unknown   }
-      specify { expect( result ).not_to be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-
-      specify { expect( result ).to be_ok }
-      specify { expect( result.ok? ).to be_truthy }
-    end
-
-    describe Result::Failed do
-      subject(:result) { Result::Failed.new(duration, exception) }
-      let(:duration)   { Result::Duration.new(1 * 1000 * 1000) }
-      let(:exception)  { StandardError.new("error message") }
-
-      it "describes itself to a visitor" do
-        expect( visitor ).to receive(:failed).with(args)
-        expect( visitor ).to receive(:duration).with(duration, args)
-        expect( visitor ).to receive(:exception).with(exception, args)
-        result.describe_to(visitor, args)
-      end
-
-      it "has a duration" do
-        expect( result.duration ).to eq duration
-      end
-
-      it "requires both constructor arguments" do
-        expect { Result::Failed.new }.to raise_error(ArgumentError)
-        expect { Result::Failed.new(duration) }.to raise_error(ArgumentError)
-      end
-
-      it "does nothing if step has no backtrace line" do
-        result.exception.set_backtrace("exception backtrace")
-        step = "does not respond_to?(:backtrace_line)"
-
-        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq(["exception backtrace"])
-      end
-
-      it "appends the backtrace line of the step" do
-        result.exception.set_backtrace("exception backtrace")
-        step = double
-        expect( step ).to receive(:backtrace_line).and_return("step_line")
-
-        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq(["exception backtrace", "step_line"])
-      end
-
-      it "apply filters to the exception" do
-        filter_class = double
-        filter = double
-        filtered_exception = double
-        expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
-        expect( filter ).to receive(:exception).and_return(filtered_exception)
-
-        expect( result.with_filtered_backtrace(filter_class).exception ).to equal filtered_exception
-      end
-
-      specify { expect( result.to_sym ).to eq :failed }
-
-      specify { expect( result ).not_to be_passed    }
-      specify { expect( result ).to     be_failed    }
-      specify { expect( result ).not_to be_undefined }
-      specify { expect( result ).not_to be_unknown   }
-      specify { expect( result ).not_to be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-
-      specify { expect( result ).to_not be_ok }
-      specify { expect( result.ok? ).to be_falsey }
-    end
-
-    describe Result::Unknown do
-      subject(:result) { Result::Unknown.new }
-
-      it "doesn't describe itself to a visitor" do
-        visitor = double('never receives anything')
-        result.describe_to(visitor, args)
-      end
-
-      it "defines a with_filtered_backtrace method" do
-        expect(result.with_filtered_backtrace(double("filter"))).to eql result
-      end
-
-      specify { expect( result.to_sym ).to eq :unknown }
-
-      specify { expect( result ).not_to be_passed    }
-      specify { expect( result ).not_to be_failed    }
-      specify { expect( result ).not_to be_undefined }
-      specify { expect( result ).to     be_unknown   }
-      specify { expect( result ).not_to be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-    end
-
-    describe Result::Raisable do
-      context "with or without backtrace" do
-        subject(:result) { Result::Raisable.new }
-
-        it "does nothing if step has no backtrace line" do
-          step = "does not respond_to?(:backtrace_line)"
-
-          expect( result.with_appended_backtrace(step).backtrace ).to eq(nil)
-        end
-      end
-
-      context "without backtrace" do
-        subject(:result) { Result::Raisable.new }
-
-        it "set the backtrace to the backtrace line of the step" do
-          step = double
-          expect( step ).to receive(:backtrace_line).and_return("step_line")
-
-          expect( result.with_appended_backtrace(step).backtrace ).to eq(["step_line"])
-        end
-
-        it "does nothing when filtering the backtrace" do
-          expect( result.with_filtered_backtrace(double) ).to equal result
-        end
-      end
-
-      context "with backtrace" do
-        subject(:result) { Result::Raisable.new("message", 0, "backtrace") }
-
-        it "appends the backtrace line of the step" do
-          step = double
-          expect( step ).to receive(:backtrace_line).and_return("step_line")
-
-          expect( result.with_appended_backtrace(step).backtrace ).to eq(["backtrace", "step_line"])
-        end
-
-        it "apply filters to the backtrace" do
-          filter_class = double
-          filter = double
-          filtered_result = double
-          expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
-          expect( filter ).to receive(:exception).and_return(filtered_result)
-
-          expect( result.with_filtered_backtrace(filter_class) ).to equal filtered_result
-        end
-      end
-    end
-
-    describe Result::Undefined do
-      subject(:result) { Result::Undefined.new }
-
-      it "describes itself to a visitor" do
-        expect( visitor ).to receive(:undefined).with(args)
-        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
-        result.describe_to(visitor, args)
-      end
-
-      specify { expect( result.to_sym ).to eq :undefined }
-
-      specify { expect( result ).not_to be_passed    }
-      specify { expect( result ).not_to be_failed    }
-      specify { expect( result ).to     be_undefined }
-      specify { expect( result ).not_to be_unknown   }
-      specify { expect( result ).not_to be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-
-      specify { expect( result ).to be_ok }
-      specify { expect( result.ok? ).to be_truthy }
-      be_strict = Result::StrictConfiguration.new([:undefined])
-      specify { expect( result.ok?(be_strict) ).to be_falsey }
-    end
-
-    describe Result::Skipped do
-      subject(:result) { Result::Skipped.new }
-
-      it "describes itself to a visitor" do
-        expect( visitor ).to receive(:skipped).with(args)
-        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
-        result.describe_to(visitor, args)
-      end
-
-      specify { expect( result.to_sym ).to eq :skipped }
-
-      specify { expect( result ).not_to be_passed    }
-      specify { expect( result ).not_to be_failed    }
-      specify { expect( result ).not_to be_undefined }
-      specify { expect( result ).not_to be_unknown   }
-      specify { expect( result ).to     be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-
-      specify { expect( result ).to be_ok }
-      specify { expect( result.ok? ).to be_truthy }
-    end
-
-    describe Result::Pending do
-      subject(:result) { Result::Pending.new }
-
-      it "describes itself to a visitor" do
-        expect( visitor ).to receive(:pending).with(result, args)
-        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
-        result.describe_to(visitor, args)
-      end
-
-      specify { expect( result.to_sym ).to eq :pending }
-
-      specify { expect( result ).not_to be_passed    }
-      specify { expect( result ).not_to be_failed    }
-      specify { expect( result ).not_to be_undefined }
-      specify { expect( result ).not_to be_unknown   }
-      specify { expect( result ).not_to be_skipped   }
-      specify { expect( result ).not_to be_flaky     }
-      specify { expect( result ).to     be_pending   }
-
-      specify { expect( result ).to be_ok }
-      specify { expect( result.ok? ).to be_truthy }
-      be_strict = Result::StrictConfiguration.new([:pending])
-      specify { expect( result.ok?(be_strict) ).to be_falsey }
-    end
-
-    describe Result::Flaky do
-      specify { expect( Result::Flaky.ok?(false) ).to be_truthy }
-      specify { expect( Result::Flaky.ok?(true) ).to be_falsey }
-    end
-
-    describe Result::StrictConfiguration do
-      subject(:strict_configuration) { Result::StrictConfiguration.new}
-      
-      describe '#set_strict' do
-        context 'no type argument' do
-          it 'sets all result types to the setting argument' do
-            strict_configuration.set_strict(true)
-            expect( strict_configuration.strict?(:undefined) ).to be_truthy
-            expect( strict_configuration.strict?(:pending) ).to be_truthy
-            expect( strict_configuration.strict?(:flaky) ).to be_truthy
-
-            strict_configuration.set_strict(false)
-            expect( strict_configuration.strict?(:undefined) ).to be_falsey
-            expect( strict_configuration.strict?(:pending) ).to be_falsey
-            expect( strict_configuration.strict?(:flaky) ).to be_falsey
-          end
-        end
-        context 'with type argument' do
-          it 'sets the specified result type to the setting argument' do
-            strict_configuration.set_strict(true, :undefined)
-            expect( strict_configuration.strict?(:undefined) ).to be_truthy
-            expect( strict_configuration.set?(:pending) ).to be_falsey
-            expect( strict_configuration.set?(:flaky) ).to be_falsey
-
-            strict_configuration.set_strict(false, :undefined)
-            expect( strict_configuration.strict?(:undefined) ).to be_falsey
-            expect( strict_configuration.set?(:pending) ).to be_falsey
-            expect( strict_configuration.set?(:flaky) ).to be_falsey
-          end
-        end
-      end
-
-      describe '#strict?' do
-        context 'no type argument' do
-          it 'returns true if any result type is set to strict' do
-            strict_configuration.set_strict(false, :pending)
-            expect( strict_configuration.strict? ).to be_falsey
-
-            strict_configuration.set_strict(true, :flaky)
-            expect( strict_configuration.strict? ).to be_truthy
-          end
-        end
-        context 'with type argument' do
-          it 'returns true if the specified result type is set to strict' do
-            strict_configuration.set_strict(false, :pending)
-            strict_configuration.set_strict(true, :flaky)
-
-            expect( strict_configuration.strict?(:undefined) ).to be_falsey
-            expect( strict_configuration.strict?(:pending) ).to be_falsey
-            expect( strict_configuration.strict?(:flaky) ).to be_truthy
-          end
-        end
-      end
-
-      describe '#merge!' do
-        let(:merged_configuration) { Result::StrictConfiguration.new }
-        it 'sets the not default values from the argument accordingly' do
-            strict_configuration.set_strict(false, :undefined)
-            strict_configuration.set_strict(false, :pending)
-            strict_configuration.set_strict(true, :flaky)
-            merged_configuration.set_strict(true, :pending)
-            merged_configuration.set_strict(false, :flaky)
-            strict_configuration.merge!(merged_configuration)
-
-            expect( strict_configuration.strict?(:undefined) ).to be_falsey
-            expect( strict_configuration.strict?(:pending) ).to be_truthy
-            expect( strict_configuration.strict?(:flaky) ).to be_falsey
-        end
-      end
-    end
-
-    describe Result::Summary do
-      let(:summary)   { Result::Summary.new }
-      let(:failed)    { Result::Failed.new(Result::Duration.new(10), exception) }
-      let(:passed)    { Result::Passed.new(Result::Duration.new(11)) }
-      let(:skipped)   { Result::Skipped.new }
-      let(:unknown)   { Result::Unknown.new }
-      let(:pending)   { Result::Pending.new }
-      let(:undefined) { Result::Undefined.new }
-      let(:exception) { StandardError.new }
-
-      it "counts failed results" do
-        failed.describe_to summary
-        expect( summary.total_failed   ).to eq 1
-        expect( summary.total(:failed) ).to eq 1
-        expect( summary.total          ).to eq 1
-      end
-
-      it "counts passed results" do
-        passed.describe_to summary
-        expect( summary.total_passed   ).to eq 1
-        expect( summary.total(:passed) ).to eq 1
-        expect( summary.total          ).to eq 1
-      end
-
-      it "counts skipped results" do
-        skipped.describe_to summary
-        expect( summary.total_skipped   ).to eq 1
-        expect( summary.total(:skipped) ).to eq 1
-        expect( summary.total           ).to eq 1
-      end
-
-      it "counts undefined results" do
-        undefined.describe_to summary
-        expect( summary.total_undefined   ).to eq 1
-        expect( summary.total(:undefined) ).to eq 1
-        expect( summary.total             ).to eq 1
-      end
-
-      it "counts abitrary raisable results" do
-        flickering = Class.new(Result::Raisable) do
-          def describe_to(visitor, *args)
-            visitor.flickering(*args)
-          end
-        end
-
-        flickering.new.describe_to summary
-        expect( summary.total_flickering   ).to eq 1
-        expect( summary.total(:flickering) ).to eq 1
-        expect( summary.total              ).to eq 1
-      end
-
-      it "returns zero for a status where no messges have been received" do
-        expect( summary.total_passed   ).to eq 0
-        expect( summary.total(:passed) ).to eq 0
-        expect( summary.total_ponies   ).to eq 0
-        expect( summary.total(:ponies) ).to eq 0
-      end
-
-      it "doesn't count unknown results" do
-        unknown.describe_to summary
-        expect( summary.total ).to eq 0
-      end
-
-      it "counts combinations" do
-        [passed, passed, failed, skipped, undefined].each { |r| r.describe_to summary }
-        expect( summary.total           ).to eq 5
-        expect( summary.total_passed    ).to eq 2
-        expect( summary.total_failed    ).to eq 1
-        expect( summary.total_skipped   ).to eq 1
-        expect( summary.total_undefined ).to eq 1
-      end
-
-      it "records durations" do
-        [passed, failed].each { |r| r.describe_to summary }
-        expect( summary.durations[0] ).to be_duration 11
-        expect( summary.durations[1] ).to be_duration 10
-      end
-
-      it "records exceptions" do
-        [passed, failed].each { |r| r.describe_to summary }
-        expect( summary.exceptions ).to eq [exception]
-      end
-
-      context "ok? result" do
-        it "passed result is ok" do
-          passed.describe_to summary
-          expect( summary.ok? ).to be true
-        end
-
-        it "skipped result is ok" do
-          skipped.describe_to summary
-          expect( summary.ok? ).to be true
-        end
-
-        it "failed result is not ok" do
-          failed.describe_to summary
-          expect( summary.ok? ).to be false
-        end
-
-        it "pending result is ok if not strict" do
-          pending.describe_to summary
-          expect( summary.ok? ).to be true
-          be_strict = Result::StrictConfiguration.new([:pending])
-          expect( summary.ok?(be_strict) ).to be false
-        end
-
-        it "undefined result is ok if not strict" do
-          undefined.describe_to summary
-          expect( summary.ok? ).to be true
-          be_strict = Result::StrictConfiguration.new([:undefined])
-          expect( summary.ok?(be_strict) ).to be false
-        end
-
-        it "flaky result is ok if not strict" do
-          summary.flaky
-          expect( summary.ok? ).to be true
-          be_strict = Result::StrictConfiguration.new([:flaky])
-          expect( summary.ok?(be_strict) ).to be false
-        end
-      end
-    end
-
-    describe Result::Duration do
-      subject(:duration) { Result::Duration.new(10) }
-
-      it "#nanoseconds can be accessed in #tap" do
-        expect( duration.tap { |duration| @duration = duration.nanoseconds } ).to eq duration
-        expect( @duration ).to eq 10
-      end
-    end
-
-    describe Result::UnknownDuration do
-      subject(:duration) { Result::UnknownDuration.new }
-
-      it "#tap does not execute the passed block" do
-        expect( duration.tap { raise "tap executed block" } ).to eq duration
-      end
-
-      it "accessing #nanoseconds outside #tap block raises exception" do
-        expect { duration.nanoseconds }.to raise_error(RuntimeError)
-      end
-    end
-  end
-end